// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: experiments_specifics.proto

#ifndef PROTOBUF_experiments_5fspecifics_2eproto__INCLUDED
#define PROTOBUF_experiments_5fspecifics_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3003000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3003002 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
// @@protoc_insertion_point(includes)
namespace sync_pb {
class AutofillCullingFlags;
class AutofillCullingFlagsDefaultTypeInternal;
extern AutofillCullingFlagsDefaultTypeInternal _AutofillCullingFlags_default_instance_;
class EnhancedBookmarksFlags;
class EnhancedBookmarksFlagsDefaultTypeInternal;
extern EnhancedBookmarksFlagsDefaultTypeInternal _EnhancedBookmarksFlags_default_instance_;
class ExperimentsSpecifics;
class ExperimentsSpecificsDefaultTypeInternal;
extern ExperimentsSpecificsDefaultTypeInternal _ExperimentsSpecifics_default_instance_;
class FaviconSyncFlags;
class FaviconSyncFlagsDefaultTypeInternal;
extern FaviconSyncFlagsDefaultTypeInternal _FaviconSyncFlags_default_instance_;
class GcmChannelFlags;
class GcmChannelFlagsDefaultTypeInternal;
extern GcmChannelFlagsDefaultTypeInternal _GcmChannelFlags_default_instance_;
class GcmInvalidationsFlags;
class GcmInvalidationsFlagsDefaultTypeInternal;
extern GcmInvalidationsFlagsDefaultTypeInternal _GcmInvalidationsFlags_default_instance_;
class HistoryDeleteDirectives;
class HistoryDeleteDirectivesDefaultTypeInternal;
extern HistoryDeleteDirectivesDefaultTypeInternal _HistoryDeleteDirectives_default_instance_;
class KeystoreEncryptionFlags;
class KeystoreEncryptionFlagsDefaultTypeInternal;
extern KeystoreEncryptionFlagsDefaultTypeInternal _KeystoreEncryptionFlags_default_instance_;
class PreCommitUpdateAvoidanceFlags;
class PreCommitUpdateAvoidanceFlagsDefaultTypeInternal;
extern PreCommitUpdateAvoidanceFlagsDefaultTypeInternal _PreCommitUpdateAvoidanceFlags_default_instance_;
class WalletSyncFlags;
class WalletSyncFlagsDefaultTypeInternal;
extern WalletSyncFlagsDefaultTypeInternal _WalletSyncFlags_default_instance_;
}  // namespace sync_pb

namespace sync_pb {

namespace protobuf_experiments_5fspecifics_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static void InitDefaultsImpl();
  static void Shutdown();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_experiments_5fspecifics_2eproto

// ===================================================================

class KeystoreEncryptionFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.KeystoreEncryptionFlags) */ {
 public:
  KeystoreEncryptionFlags();
  virtual ~KeystoreEncryptionFlags();

  KeystoreEncryptionFlags(const KeystoreEncryptionFlags& from);

  inline KeystoreEncryptionFlags& operator=(const KeystoreEncryptionFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const KeystoreEncryptionFlags& default_instance();

  static inline const KeystoreEncryptionFlags* internal_default_instance() {
    return reinterpret_cast<const KeystoreEncryptionFlags*>(
               &_KeystoreEncryptionFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(KeystoreEncryptionFlags* other);

  // implements Message ----------------------------------------------

  inline KeystoreEncryptionFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  KeystoreEncryptionFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const KeystoreEncryptionFlags& from);
  void MergeFrom(const KeystoreEncryptionFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(KeystoreEncryptionFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.KeystoreEncryptionFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class HistoryDeleteDirectives : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.HistoryDeleteDirectives) */ {
 public:
  HistoryDeleteDirectives();
  virtual ~HistoryDeleteDirectives();

  HistoryDeleteDirectives(const HistoryDeleteDirectives& from);

  inline HistoryDeleteDirectives& operator=(const HistoryDeleteDirectives& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const HistoryDeleteDirectives& default_instance();

  static inline const HistoryDeleteDirectives* internal_default_instance() {
    return reinterpret_cast<const HistoryDeleteDirectives*>(
               &_HistoryDeleteDirectives_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(HistoryDeleteDirectives* other);

  // implements Message ----------------------------------------------

  inline HistoryDeleteDirectives* New() const PROTOBUF_FINAL { return New(NULL); }

  HistoryDeleteDirectives* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const HistoryDeleteDirectives& from);
  void MergeFrom(const HistoryDeleteDirectives& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(HistoryDeleteDirectives* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.HistoryDeleteDirectives)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class AutofillCullingFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.AutofillCullingFlags) */ {
 public:
  AutofillCullingFlags();
  virtual ~AutofillCullingFlags();

  AutofillCullingFlags(const AutofillCullingFlags& from);

  inline AutofillCullingFlags& operator=(const AutofillCullingFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const AutofillCullingFlags& default_instance();

  static inline const AutofillCullingFlags* internal_default_instance() {
    return reinterpret_cast<const AutofillCullingFlags*>(
               &_AutofillCullingFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(AutofillCullingFlags* other);

  // implements Message ----------------------------------------------

  inline AutofillCullingFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  AutofillCullingFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const AutofillCullingFlags& from);
  void MergeFrom(const AutofillCullingFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(AutofillCullingFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.AutofillCullingFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class FaviconSyncFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.FaviconSyncFlags) */ {
 public:
  FaviconSyncFlags();
  virtual ~FaviconSyncFlags();

  FaviconSyncFlags(const FaviconSyncFlags& from);

  inline FaviconSyncFlags& operator=(const FaviconSyncFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const FaviconSyncFlags& default_instance();

  static inline const FaviconSyncFlags* internal_default_instance() {
    return reinterpret_cast<const FaviconSyncFlags*>(
               &_FaviconSyncFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(FaviconSyncFlags* other);

  // implements Message ----------------------------------------------

  inline FaviconSyncFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  FaviconSyncFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const FaviconSyncFlags& from);
  void MergeFrom(const FaviconSyncFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(FaviconSyncFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // optional int32 favicon_sync_limit = 2 [default = 200];
  bool has_favicon_sync_limit() const;
  void clear_favicon_sync_limit();
  static const int kFaviconSyncLimitFieldNumber = 2;
  ::google::protobuf::int32 favicon_sync_limit() const;
  void set_favicon_sync_limit(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:sync_pb.FaviconSyncFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();
  void set_has_favicon_sync_limit();
  void clear_has_favicon_sync_limit();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  ::google::protobuf::int32 favicon_sync_limit_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class PreCommitUpdateAvoidanceFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.PreCommitUpdateAvoidanceFlags) */ {
 public:
  PreCommitUpdateAvoidanceFlags();
  virtual ~PreCommitUpdateAvoidanceFlags();

  PreCommitUpdateAvoidanceFlags(const PreCommitUpdateAvoidanceFlags& from);

  inline PreCommitUpdateAvoidanceFlags& operator=(const PreCommitUpdateAvoidanceFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const PreCommitUpdateAvoidanceFlags& default_instance();

  static inline const PreCommitUpdateAvoidanceFlags* internal_default_instance() {
    return reinterpret_cast<const PreCommitUpdateAvoidanceFlags*>(
               &_PreCommitUpdateAvoidanceFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(PreCommitUpdateAvoidanceFlags* other);

  // implements Message ----------------------------------------------

  inline PreCommitUpdateAvoidanceFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  PreCommitUpdateAvoidanceFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const PreCommitUpdateAvoidanceFlags& from);
  void MergeFrom(const PreCommitUpdateAvoidanceFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(PreCommitUpdateAvoidanceFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.PreCommitUpdateAvoidanceFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class GcmChannelFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.GcmChannelFlags) */ {
 public:
  GcmChannelFlags();
  virtual ~GcmChannelFlags();

  GcmChannelFlags(const GcmChannelFlags& from);

  inline GcmChannelFlags& operator=(const GcmChannelFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const GcmChannelFlags& default_instance();

  static inline const GcmChannelFlags* internal_default_instance() {
    return reinterpret_cast<const GcmChannelFlags*>(
               &_GcmChannelFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    5;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(GcmChannelFlags* other);

  // implements Message ----------------------------------------------

  inline GcmChannelFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  GcmChannelFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const GcmChannelFlags& from);
  void MergeFrom(const GcmChannelFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GcmChannelFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.GcmChannelFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class EnhancedBookmarksFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.EnhancedBookmarksFlags) */ {
 public:
  EnhancedBookmarksFlags();
  virtual ~EnhancedBookmarksFlags();

  EnhancedBookmarksFlags(const EnhancedBookmarksFlags& from);

  inline EnhancedBookmarksFlags& operator=(const EnhancedBookmarksFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const EnhancedBookmarksFlags& default_instance();

  static inline const EnhancedBookmarksFlags* internal_default_instance() {
    return reinterpret_cast<const EnhancedBookmarksFlags*>(
               &_EnhancedBookmarksFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    6;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(EnhancedBookmarksFlags* other);

  // implements Message ----------------------------------------------

  inline EnhancedBookmarksFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  EnhancedBookmarksFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const EnhancedBookmarksFlags& from);
  void MergeFrom(const EnhancedBookmarksFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(EnhancedBookmarksFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional string extension_id = 2;
  bool has_extension_id() const;
  void clear_extension_id();
  static const int kExtensionIdFieldNumber = 2;
  const ::std::string& extension_id() const;
  void set_extension_id(const ::std::string& value);
  #if LANG_CXX11
  void set_extension_id(::std::string&& value);
  #endif
  void set_extension_id(const char* value);
  void set_extension_id(const char* value, size_t size);
  ::std::string* mutable_extension_id();
  ::std::string* release_extension_id();
  void set_allocated_extension_id(::std::string* extension_id);

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.EnhancedBookmarksFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();
  void set_has_extension_id();
  void clear_has_extension_id();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::google::protobuf::internal::ArenaStringPtr extension_id_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class GcmInvalidationsFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.GcmInvalidationsFlags) */ {
 public:
  GcmInvalidationsFlags();
  virtual ~GcmInvalidationsFlags();

  GcmInvalidationsFlags(const GcmInvalidationsFlags& from);

  inline GcmInvalidationsFlags& operator=(const GcmInvalidationsFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const GcmInvalidationsFlags& default_instance();

  static inline const GcmInvalidationsFlags* internal_default_instance() {
    return reinterpret_cast<const GcmInvalidationsFlags*>(
               &_GcmInvalidationsFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    7;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(GcmInvalidationsFlags* other);

  // implements Message ----------------------------------------------

  inline GcmInvalidationsFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  GcmInvalidationsFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const GcmInvalidationsFlags& from);
  void MergeFrom(const GcmInvalidationsFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(GcmInvalidationsFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.GcmInvalidationsFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class WalletSyncFlags : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.WalletSyncFlags) */ {
 public:
  WalletSyncFlags();
  virtual ~WalletSyncFlags();

  WalletSyncFlags(const WalletSyncFlags& from);

  inline WalletSyncFlags& operator=(const WalletSyncFlags& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const WalletSyncFlags& default_instance();

  static inline const WalletSyncFlags* internal_default_instance() {
    return reinterpret_cast<const WalletSyncFlags*>(
               &_WalletSyncFlags_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    8;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(WalletSyncFlags* other);

  // implements Message ----------------------------------------------

  inline WalletSyncFlags* New() const PROTOBUF_FINAL { return New(NULL); }

  WalletSyncFlags* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const WalletSyncFlags& from);
  void MergeFrom(const WalletSyncFlags& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(WalletSyncFlags* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional bool enabled = 1;
  bool has_enabled() const;
  void clear_enabled();
  static const int kEnabledFieldNumber = 1;
  bool enabled() const;
  void set_enabled(bool value);

  // @@protoc_insertion_point(class_scope:sync_pb.WalletSyncFlags)
 private:
  void set_has_enabled();
  void clear_has_enabled();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  bool enabled_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ExperimentsSpecifics : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sync_pb.ExperimentsSpecifics) */ {
 public:
  ExperimentsSpecifics();
  virtual ~ExperimentsSpecifics();

  ExperimentsSpecifics(const ExperimentsSpecifics& from);

  inline ExperimentsSpecifics& operator=(const ExperimentsSpecifics& from) {
    CopyFrom(from);
    return *this;
  }

  inline const ::std::string& unknown_fields() const {
    return _internal_metadata_.unknown_fields();
  }

  inline ::std::string* mutable_unknown_fields() {
    return _internal_metadata_.mutable_unknown_fields();
  }

  static const ExperimentsSpecifics& default_instance();

  static inline const ExperimentsSpecifics* internal_default_instance() {
    return reinterpret_cast<const ExperimentsSpecifics*>(
               &_ExperimentsSpecifics_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    9;

  GOOGLE_ATTRIBUTE_NOINLINE void Swap(ExperimentsSpecifics* other);

  // implements Message ----------------------------------------------

  inline ExperimentsSpecifics* New() const PROTOBUF_FINAL { return New(NULL); }

  ExperimentsSpecifics* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
    PROTOBUF_FINAL;
  void CopyFrom(const ExperimentsSpecifics& from);
  void MergeFrom(const ExperimentsSpecifics& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  void DiscardUnknownFields();
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ExperimentsSpecifics* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::std::string GetTypeName() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // optional .sync_pb.KeystoreEncryptionFlags keystore_encryption = 1;
  bool has_keystore_encryption() const;
  void clear_keystore_encryption();
  static const int kKeystoreEncryptionFieldNumber = 1;
  const ::sync_pb::KeystoreEncryptionFlags& keystore_encryption() const;
  ::sync_pb::KeystoreEncryptionFlags* mutable_keystore_encryption();
  ::sync_pb::KeystoreEncryptionFlags* release_keystore_encryption();
  void set_allocated_keystore_encryption(::sync_pb::KeystoreEncryptionFlags* keystore_encryption);

  // optional .sync_pb.HistoryDeleteDirectives history_delete_directives = 2;
  bool has_history_delete_directives() const;
  void clear_history_delete_directives();
  static const int kHistoryDeleteDirectivesFieldNumber = 2;
  const ::sync_pb::HistoryDeleteDirectives& history_delete_directives() const;
  ::sync_pb::HistoryDeleteDirectives* mutable_history_delete_directives();
  ::sync_pb::HistoryDeleteDirectives* release_history_delete_directives();
  void set_allocated_history_delete_directives(::sync_pb::HistoryDeleteDirectives* history_delete_directives);

  // optional .sync_pb.AutofillCullingFlags autofill_culling = 3;
  bool has_autofill_culling() const;
  void clear_autofill_culling();
  static const int kAutofillCullingFieldNumber = 3;
  const ::sync_pb::AutofillCullingFlags& autofill_culling() const;
  ::sync_pb::AutofillCullingFlags* mutable_autofill_culling();
  ::sync_pb::AutofillCullingFlags* release_autofill_culling();
  void set_allocated_autofill_culling(::sync_pb::AutofillCullingFlags* autofill_culling);

  // optional .sync_pb.FaviconSyncFlags favicon_sync = 4;
  bool has_favicon_sync() const;
  void clear_favicon_sync();
  static const int kFaviconSyncFieldNumber = 4;
  const ::sync_pb::FaviconSyncFlags& favicon_sync() const;
  ::sync_pb::FaviconSyncFlags* mutable_favicon_sync();
  ::sync_pb::FaviconSyncFlags* release_favicon_sync();
  void set_allocated_favicon_sync(::sync_pb::FaviconSyncFlags* favicon_sync);

  // optional .sync_pb.PreCommitUpdateAvoidanceFlags pre_commit_update_avoidance = 5;
  bool has_pre_commit_update_avoidance() const;
  void clear_pre_commit_update_avoidance();
  static const int kPreCommitUpdateAvoidanceFieldNumber = 5;
  const ::sync_pb::PreCommitUpdateAvoidanceFlags& pre_commit_update_avoidance() const;
  ::sync_pb::PreCommitUpdateAvoidanceFlags* mutable_pre_commit_update_avoidance();
  ::sync_pb::PreCommitUpdateAvoidanceFlags* release_pre_commit_update_avoidance();
  void set_allocated_pre_commit_update_avoidance(::sync_pb::PreCommitUpdateAvoidanceFlags* pre_commit_update_avoidance);

  // optional .sync_pb.GcmChannelFlags gcm_channel = 6;
  bool has_gcm_channel() const;
  void clear_gcm_channel();
  static const int kGcmChannelFieldNumber = 6;
  const ::sync_pb::GcmChannelFlags& gcm_channel() const;
  ::sync_pb::GcmChannelFlags* mutable_gcm_channel();
  ::sync_pb::GcmChannelFlags* release_gcm_channel();
  void set_allocated_gcm_channel(::sync_pb::GcmChannelFlags* gcm_channel);

  // optional .sync_pb.EnhancedBookmarksFlags obsolete_enhanced_bookmarks = 7;
  bool has_obsolete_enhanced_bookmarks() const;
  void clear_obsolete_enhanced_bookmarks();
  static const int kObsoleteEnhancedBookmarksFieldNumber = 7;
  const ::sync_pb::EnhancedBookmarksFlags& obsolete_enhanced_bookmarks() const;
  ::sync_pb::EnhancedBookmarksFlags* mutable_obsolete_enhanced_bookmarks();
  ::sync_pb::EnhancedBookmarksFlags* release_obsolete_enhanced_bookmarks();
  void set_allocated_obsolete_enhanced_bookmarks(::sync_pb::EnhancedBookmarksFlags* obsolete_enhanced_bookmarks);

  // optional .sync_pb.GcmInvalidationsFlags gcm_invalidations = 8;
  bool has_gcm_invalidations() const;
  void clear_gcm_invalidations();
  static const int kGcmInvalidationsFieldNumber = 8;
  const ::sync_pb::GcmInvalidationsFlags& gcm_invalidations() const;
  ::sync_pb::GcmInvalidationsFlags* mutable_gcm_invalidations();
  ::sync_pb::GcmInvalidationsFlags* release_gcm_invalidations();
  void set_allocated_gcm_invalidations(::sync_pb::GcmInvalidationsFlags* gcm_invalidations);

  // optional .sync_pb.WalletSyncFlags obsolete_wallet_sync = 9;
  bool has_obsolete_wallet_sync() const;
  void clear_obsolete_wallet_sync();
  static const int kObsoleteWalletSyncFieldNumber = 9;
  const ::sync_pb::WalletSyncFlags& obsolete_wallet_sync() const;
  ::sync_pb::WalletSyncFlags* mutable_obsolete_wallet_sync();
  ::sync_pb::WalletSyncFlags* release_obsolete_wallet_sync();
  void set_allocated_obsolete_wallet_sync(::sync_pb::WalletSyncFlags* obsolete_wallet_sync);

  // @@protoc_insertion_point(class_scope:sync_pb.ExperimentsSpecifics)
 private:
  void set_has_keystore_encryption();
  void clear_has_keystore_encryption();
  void set_has_history_delete_directives();
  void clear_has_history_delete_directives();
  void set_has_autofill_culling();
  void clear_has_autofill_culling();
  void set_has_favicon_sync();
  void clear_has_favicon_sync();
  void set_has_pre_commit_update_avoidance();
  void clear_has_pre_commit_update_avoidance();
  void set_has_gcm_channel();
  void clear_has_gcm_channel();
  void set_has_obsolete_enhanced_bookmarks();
  void clear_has_obsolete_enhanced_bookmarks();
  void set_has_gcm_invalidations();
  void clear_has_gcm_invalidations();
  void set_has_obsolete_wallet_sync();
  void clear_has_obsolete_wallet_sync();

  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
  ::google::protobuf::internal::HasBits<1> _has_bits_;
  mutable int _cached_size_;
  ::sync_pb::KeystoreEncryptionFlags* keystore_encryption_;
  ::sync_pb::HistoryDeleteDirectives* history_delete_directives_;
  ::sync_pb::AutofillCullingFlags* autofill_culling_;
  ::sync_pb::FaviconSyncFlags* favicon_sync_;
  ::sync_pb::PreCommitUpdateAvoidanceFlags* pre_commit_update_avoidance_;
  ::sync_pb::GcmChannelFlags* gcm_channel_;
  ::sync_pb::EnhancedBookmarksFlags* obsolete_enhanced_bookmarks_;
  ::sync_pb::GcmInvalidationsFlags* gcm_invalidations_;
  ::sync_pb::WalletSyncFlags* obsolete_wallet_sync_;
  friend struct protobuf_experiments_5fspecifics_2eproto::TableStruct;
};
// ===================================================================


// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
// KeystoreEncryptionFlags

// optional bool enabled = 1;
inline bool KeystoreEncryptionFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void KeystoreEncryptionFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void KeystoreEncryptionFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void KeystoreEncryptionFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool KeystoreEncryptionFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.KeystoreEncryptionFlags.enabled)
  return enabled_;
}
inline void KeystoreEncryptionFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.KeystoreEncryptionFlags.enabled)
}

// -------------------------------------------------------------------

// HistoryDeleteDirectives

// optional bool enabled = 1;
inline bool HistoryDeleteDirectives::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void HistoryDeleteDirectives::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void HistoryDeleteDirectives::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void HistoryDeleteDirectives::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool HistoryDeleteDirectives::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.HistoryDeleteDirectives.enabled)
  return enabled_;
}
inline void HistoryDeleteDirectives::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.HistoryDeleteDirectives.enabled)
}

// -------------------------------------------------------------------

// AutofillCullingFlags

// optional bool enabled = 1;
inline bool AutofillCullingFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void AutofillCullingFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void AutofillCullingFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void AutofillCullingFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool AutofillCullingFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.AutofillCullingFlags.enabled)
  return enabled_;
}
inline void AutofillCullingFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.AutofillCullingFlags.enabled)
}

// -------------------------------------------------------------------

// FaviconSyncFlags

// optional bool enabled = 1;
inline bool FaviconSyncFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FaviconSyncFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FaviconSyncFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FaviconSyncFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool FaviconSyncFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.FaviconSyncFlags.enabled)
  return enabled_;
}
inline void FaviconSyncFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.FaviconSyncFlags.enabled)
}

// optional int32 favicon_sync_limit = 2 [default = 200];
inline bool FaviconSyncFlags::has_favicon_sync_limit() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void FaviconSyncFlags::set_has_favicon_sync_limit() {
  _has_bits_[0] |= 0x00000002u;
}
inline void FaviconSyncFlags::clear_has_favicon_sync_limit() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void FaviconSyncFlags::clear_favicon_sync_limit() {
  favicon_sync_limit_ = 200;
  clear_has_favicon_sync_limit();
}
inline ::google::protobuf::int32 FaviconSyncFlags::favicon_sync_limit() const {
  // @@protoc_insertion_point(field_get:sync_pb.FaviconSyncFlags.favicon_sync_limit)
  return favicon_sync_limit_;
}
inline void FaviconSyncFlags::set_favicon_sync_limit(::google::protobuf::int32 value) {
  set_has_favicon_sync_limit();
  favicon_sync_limit_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.FaviconSyncFlags.favicon_sync_limit)
}

// -------------------------------------------------------------------

// PreCommitUpdateAvoidanceFlags

// optional bool enabled = 1;
inline bool PreCommitUpdateAvoidanceFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void PreCommitUpdateAvoidanceFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void PreCommitUpdateAvoidanceFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void PreCommitUpdateAvoidanceFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool PreCommitUpdateAvoidanceFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.PreCommitUpdateAvoidanceFlags.enabled)
  return enabled_;
}
inline void PreCommitUpdateAvoidanceFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.PreCommitUpdateAvoidanceFlags.enabled)
}

// -------------------------------------------------------------------

// GcmChannelFlags

// optional bool enabled = 1;
inline bool GcmChannelFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GcmChannelFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GcmChannelFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GcmChannelFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool GcmChannelFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.GcmChannelFlags.enabled)
  return enabled_;
}
inline void GcmChannelFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.GcmChannelFlags.enabled)
}

// -------------------------------------------------------------------

// EnhancedBookmarksFlags

// optional bool enabled = 1;
inline bool EnhancedBookmarksFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EnhancedBookmarksFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EnhancedBookmarksFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EnhancedBookmarksFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool EnhancedBookmarksFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.EnhancedBookmarksFlags.enabled)
  return enabled_;
}
inline void EnhancedBookmarksFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.EnhancedBookmarksFlags.enabled)
}

// optional string extension_id = 2;
inline bool EnhancedBookmarksFlags::has_extension_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EnhancedBookmarksFlags::set_has_extension_id() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EnhancedBookmarksFlags::clear_has_extension_id() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EnhancedBookmarksFlags::clear_extension_id() {
  extension_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_extension_id();
}
inline const ::std::string& EnhancedBookmarksFlags::extension_id() const {
  // @@protoc_insertion_point(field_get:sync_pb.EnhancedBookmarksFlags.extension_id)
  return extension_id_.GetNoArena();
}
inline void EnhancedBookmarksFlags::set_extension_id(const ::std::string& value) {
  set_has_extension_id();
  extension_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:sync_pb.EnhancedBookmarksFlags.extension_id)
}
#if LANG_CXX11
inline void EnhancedBookmarksFlags::set_extension_id(::std::string&& value) {
  set_has_extension_id();
  extension_id_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:sync_pb.EnhancedBookmarksFlags.extension_id)
}
#endif
inline void EnhancedBookmarksFlags::set_extension_id(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  set_has_extension_id();
  extension_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:sync_pb.EnhancedBookmarksFlags.extension_id)
}
inline void EnhancedBookmarksFlags::set_extension_id(const char* value, size_t size) {
  set_has_extension_id();
  extension_id_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:sync_pb.EnhancedBookmarksFlags.extension_id)
}
inline ::std::string* EnhancedBookmarksFlags::mutable_extension_id() {
  set_has_extension_id();
  // @@protoc_insertion_point(field_mutable:sync_pb.EnhancedBookmarksFlags.extension_id)
  return extension_id_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* EnhancedBookmarksFlags::release_extension_id() {
  // @@protoc_insertion_point(field_release:sync_pb.EnhancedBookmarksFlags.extension_id)
  clear_has_extension_id();
  return extension_id_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void EnhancedBookmarksFlags::set_allocated_extension_id(::std::string* extension_id) {
  if (extension_id != NULL) {
    set_has_extension_id();
  } else {
    clear_has_extension_id();
  }
  extension_id_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), extension_id);
  // @@protoc_insertion_point(field_set_allocated:sync_pb.EnhancedBookmarksFlags.extension_id)
}

// -------------------------------------------------------------------

// GcmInvalidationsFlags

// optional bool enabled = 1;
inline bool GcmInvalidationsFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void GcmInvalidationsFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void GcmInvalidationsFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void GcmInvalidationsFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool GcmInvalidationsFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.GcmInvalidationsFlags.enabled)
  return enabled_;
}
inline void GcmInvalidationsFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.GcmInvalidationsFlags.enabled)
}

// -------------------------------------------------------------------

// WalletSyncFlags

// optional bool enabled = 1;
inline bool WalletSyncFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WalletSyncFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
inline void WalletSyncFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void WalletSyncFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
inline bool WalletSyncFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.WalletSyncFlags.enabled)
  return enabled_;
}
inline void WalletSyncFlags::set_enabled(bool value) {
  set_has_enabled();
  enabled_ = value;
  // @@protoc_insertion_point(field_set:sync_pb.WalletSyncFlags.enabled)
}

// -------------------------------------------------------------------

// ExperimentsSpecifics

// optional .sync_pb.KeystoreEncryptionFlags keystore_encryption = 1;
inline bool ExperimentsSpecifics::has_keystore_encryption() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void ExperimentsSpecifics::set_has_keystore_encryption() {
  _has_bits_[0] |= 0x00000001u;
}
inline void ExperimentsSpecifics::clear_has_keystore_encryption() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void ExperimentsSpecifics::clear_keystore_encryption() {
  if (keystore_encryption_ != NULL) keystore_encryption_->::sync_pb::KeystoreEncryptionFlags::Clear();
  clear_has_keystore_encryption();
}
inline const ::sync_pb::KeystoreEncryptionFlags& ExperimentsSpecifics::keystore_encryption() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.keystore_encryption)
  return keystore_encryption_ != NULL ? *keystore_encryption_
                         : *::sync_pb::KeystoreEncryptionFlags::internal_default_instance();
}
inline ::sync_pb::KeystoreEncryptionFlags* ExperimentsSpecifics::mutable_keystore_encryption() {
  set_has_keystore_encryption();
  if (keystore_encryption_ == NULL) {
    keystore_encryption_ = new ::sync_pb::KeystoreEncryptionFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.keystore_encryption)
  return keystore_encryption_;
}
inline ::sync_pb::KeystoreEncryptionFlags* ExperimentsSpecifics::release_keystore_encryption() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.keystore_encryption)
  clear_has_keystore_encryption();
  ::sync_pb::KeystoreEncryptionFlags* temp = keystore_encryption_;
  keystore_encryption_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_keystore_encryption(::sync_pb::KeystoreEncryptionFlags* keystore_encryption) {
  delete keystore_encryption_;
  keystore_encryption_ = keystore_encryption;
  if (keystore_encryption) {
    set_has_keystore_encryption();
  } else {
    clear_has_keystore_encryption();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.keystore_encryption)
}

// optional .sync_pb.HistoryDeleteDirectives history_delete_directives = 2;
inline bool ExperimentsSpecifics::has_history_delete_directives() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void ExperimentsSpecifics::set_has_history_delete_directives() {
  _has_bits_[0] |= 0x00000002u;
}
inline void ExperimentsSpecifics::clear_has_history_delete_directives() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void ExperimentsSpecifics::clear_history_delete_directives() {
  if (history_delete_directives_ != NULL) history_delete_directives_->::sync_pb::HistoryDeleteDirectives::Clear();
  clear_has_history_delete_directives();
}
inline const ::sync_pb::HistoryDeleteDirectives& ExperimentsSpecifics::history_delete_directives() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.history_delete_directives)
  return history_delete_directives_ != NULL ? *history_delete_directives_
                         : *::sync_pb::HistoryDeleteDirectives::internal_default_instance();
}
inline ::sync_pb::HistoryDeleteDirectives* ExperimentsSpecifics::mutable_history_delete_directives() {
  set_has_history_delete_directives();
  if (history_delete_directives_ == NULL) {
    history_delete_directives_ = new ::sync_pb::HistoryDeleteDirectives;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.history_delete_directives)
  return history_delete_directives_;
}
inline ::sync_pb::HistoryDeleteDirectives* ExperimentsSpecifics::release_history_delete_directives() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.history_delete_directives)
  clear_has_history_delete_directives();
  ::sync_pb::HistoryDeleteDirectives* temp = history_delete_directives_;
  history_delete_directives_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_history_delete_directives(::sync_pb::HistoryDeleteDirectives* history_delete_directives) {
  delete history_delete_directives_;
  history_delete_directives_ = history_delete_directives;
  if (history_delete_directives) {
    set_has_history_delete_directives();
  } else {
    clear_has_history_delete_directives();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.history_delete_directives)
}

// optional .sync_pb.AutofillCullingFlags autofill_culling = 3;
inline bool ExperimentsSpecifics::has_autofill_culling() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void ExperimentsSpecifics::set_has_autofill_culling() {
  _has_bits_[0] |= 0x00000004u;
}
inline void ExperimentsSpecifics::clear_has_autofill_culling() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void ExperimentsSpecifics::clear_autofill_culling() {
  if (autofill_culling_ != NULL) autofill_culling_->::sync_pb::AutofillCullingFlags::Clear();
  clear_has_autofill_culling();
}
inline const ::sync_pb::AutofillCullingFlags& ExperimentsSpecifics::autofill_culling() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.autofill_culling)
  return autofill_culling_ != NULL ? *autofill_culling_
                         : *::sync_pb::AutofillCullingFlags::internal_default_instance();
}
inline ::sync_pb::AutofillCullingFlags* ExperimentsSpecifics::mutable_autofill_culling() {
  set_has_autofill_culling();
  if (autofill_culling_ == NULL) {
    autofill_culling_ = new ::sync_pb::AutofillCullingFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.autofill_culling)
  return autofill_culling_;
}
inline ::sync_pb::AutofillCullingFlags* ExperimentsSpecifics::release_autofill_culling() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.autofill_culling)
  clear_has_autofill_culling();
  ::sync_pb::AutofillCullingFlags* temp = autofill_culling_;
  autofill_culling_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_autofill_culling(::sync_pb::AutofillCullingFlags* autofill_culling) {
  delete autofill_culling_;
  autofill_culling_ = autofill_culling;
  if (autofill_culling) {
    set_has_autofill_culling();
  } else {
    clear_has_autofill_culling();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.autofill_culling)
}

// optional .sync_pb.FaviconSyncFlags favicon_sync = 4;
inline bool ExperimentsSpecifics::has_favicon_sync() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void ExperimentsSpecifics::set_has_favicon_sync() {
  _has_bits_[0] |= 0x00000008u;
}
inline void ExperimentsSpecifics::clear_has_favicon_sync() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void ExperimentsSpecifics::clear_favicon_sync() {
  if (favicon_sync_ != NULL) favicon_sync_->::sync_pb::FaviconSyncFlags::Clear();
  clear_has_favicon_sync();
}
inline const ::sync_pb::FaviconSyncFlags& ExperimentsSpecifics::favicon_sync() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.favicon_sync)
  return favicon_sync_ != NULL ? *favicon_sync_
                         : *::sync_pb::FaviconSyncFlags::internal_default_instance();
}
inline ::sync_pb::FaviconSyncFlags* ExperimentsSpecifics::mutable_favicon_sync() {
  set_has_favicon_sync();
  if (favicon_sync_ == NULL) {
    favicon_sync_ = new ::sync_pb::FaviconSyncFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.favicon_sync)
  return favicon_sync_;
}
inline ::sync_pb::FaviconSyncFlags* ExperimentsSpecifics::release_favicon_sync() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.favicon_sync)
  clear_has_favicon_sync();
  ::sync_pb::FaviconSyncFlags* temp = favicon_sync_;
  favicon_sync_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_favicon_sync(::sync_pb::FaviconSyncFlags* favicon_sync) {
  delete favicon_sync_;
  favicon_sync_ = favicon_sync;
  if (favicon_sync) {
    set_has_favicon_sync();
  } else {
    clear_has_favicon_sync();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.favicon_sync)
}

// optional .sync_pb.PreCommitUpdateAvoidanceFlags pre_commit_update_avoidance = 5;
inline bool ExperimentsSpecifics::has_pre_commit_update_avoidance() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void ExperimentsSpecifics::set_has_pre_commit_update_avoidance() {
  _has_bits_[0] |= 0x00000010u;
}
inline void ExperimentsSpecifics::clear_has_pre_commit_update_avoidance() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void ExperimentsSpecifics::clear_pre_commit_update_avoidance() {
  if (pre_commit_update_avoidance_ != NULL) pre_commit_update_avoidance_->::sync_pb::PreCommitUpdateAvoidanceFlags::Clear();
  clear_has_pre_commit_update_avoidance();
}
inline const ::sync_pb::PreCommitUpdateAvoidanceFlags& ExperimentsSpecifics::pre_commit_update_avoidance() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.pre_commit_update_avoidance)
  return pre_commit_update_avoidance_ != NULL ? *pre_commit_update_avoidance_
                         : *::sync_pb::PreCommitUpdateAvoidanceFlags::internal_default_instance();
}
inline ::sync_pb::PreCommitUpdateAvoidanceFlags* ExperimentsSpecifics::mutable_pre_commit_update_avoidance() {
  set_has_pre_commit_update_avoidance();
  if (pre_commit_update_avoidance_ == NULL) {
    pre_commit_update_avoidance_ = new ::sync_pb::PreCommitUpdateAvoidanceFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.pre_commit_update_avoidance)
  return pre_commit_update_avoidance_;
}
inline ::sync_pb::PreCommitUpdateAvoidanceFlags* ExperimentsSpecifics::release_pre_commit_update_avoidance() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.pre_commit_update_avoidance)
  clear_has_pre_commit_update_avoidance();
  ::sync_pb::PreCommitUpdateAvoidanceFlags* temp = pre_commit_update_avoidance_;
  pre_commit_update_avoidance_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_pre_commit_update_avoidance(::sync_pb::PreCommitUpdateAvoidanceFlags* pre_commit_update_avoidance) {
  delete pre_commit_update_avoidance_;
  pre_commit_update_avoidance_ = pre_commit_update_avoidance;
  if (pre_commit_update_avoidance) {
    set_has_pre_commit_update_avoidance();
  } else {
    clear_has_pre_commit_update_avoidance();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.pre_commit_update_avoidance)
}

// optional .sync_pb.GcmChannelFlags gcm_channel = 6;
inline bool ExperimentsSpecifics::has_gcm_channel() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
inline void ExperimentsSpecifics::set_has_gcm_channel() {
  _has_bits_[0] |= 0x00000020u;
}
inline void ExperimentsSpecifics::clear_has_gcm_channel() {
  _has_bits_[0] &= ~0x00000020u;
}
inline void ExperimentsSpecifics::clear_gcm_channel() {
  if (gcm_channel_ != NULL) gcm_channel_->::sync_pb::GcmChannelFlags::Clear();
  clear_has_gcm_channel();
}
inline const ::sync_pb::GcmChannelFlags& ExperimentsSpecifics::gcm_channel() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.gcm_channel)
  return gcm_channel_ != NULL ? *gcm_channel_
                         : *::sync_pb::GcmChannelFlags::internal_default_instance();
}
inline ::sync_pb::GcmChannelFlags* ExperimentsSpecifics::mutable_gcm_channel() {
  set_has_gcm_channel();
  if (gcm_channel_ == NULL) {
    gcm_channel_ = new ::sync_pb::GcmChannelFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.gcm_channel)
  return gcm_channel_;
}
inline ::sync_pb::GcmChannelFlags* ExperimentsSpecifics::release_gcm_channel() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.gcm_channel)
  clear_has_gcm_channel();
  ::sync_pb::GcmChannelFlags* temp = gcm_channel_;
  gcm_channel_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_gcm_channel(::sync_pb::GcmChannelFlags* gcm_channel) {
  delete gcm_channel_;
  gcm_channel_ = gcm_channel;
  if (gcm_channel) {
    set_has_gcm_channel();
  } else {
    clear_has_gcm_channel();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.gcm_channel)
}

// optional .sync_pb.EnhancedBookmarksFlags obsolete_enhanced_bookmarks = 7;
inline bool ExperimentsSpecifics::has_obsolete_enhanced_bookmarks() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
inline void ExperimentsSpecifics::set_has_obsolete_enhanced_bookmarks() {
  _has_bits_[0] |= 0x00000040u;
}
inline void ExperimentsSpecifics::clear_has_obsolete_enhanced_bookmarks() {
  _has_bits_[0] &= ~0x00000040u;
}
inline void ExperimentsSpecifics::clear_obsolete_enhanced_bookmarks() {
  if (obsolete_enhanced_bookmarks_ != NULL) obsolete_enhanced_bookmarks_->::sync_pb::EnhancedBookmarksFlags::Clear();
  clear_has_obsolete_enhanced_bookmarks();
}
inline const ::sync_pb::EnhancedBookmarksFlags& ExperimentsSpecifics::obsolete_enhanced_bookmarks() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.obsolete_enhanced_bookmarks)
  return obsolete_enhanced_bookmarks_ != NULL ? *obsolete_enhanced_bookmarks_
                         : *::sync_pb::EnhancedBookmarksFlags::internal_default_instance();
}
inline ::sync_pb::EnhancedBookmarksFlags* ExperimentsSpecifics::mutable_obsolete_enhanced_bookmarks() {
  set_has_obsolete_enhanced_bookmarks();
  if (obsolete_enhanced_bookmarks_ == NULL) {
    obsolete_enhanced_bookmarks_ = new ::sync_pb::EnhancedBookmarksFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.obsolete_enhanced_bookmarks)
  return obsolete_enhanced_bookmarks_;
}
inline ::sync_pb::EnhancedBookmarksFlags* ExperimentsSpecifics::release_obsolete_enhanced_bookmarks() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.obsolete_enhanced_bookmarks)
  clear_has_obsolete_enhanced_bookmarks();
  ::sync_pb::EnhancedBookmarksFlags* temp = obsolete_enhanced_bookmarks_;
  obsolete_enhanced_bookmarks_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_obsolete_enhanced_bookmarks(::sync_pb::EnhancedBookmarksFlags* obsolete_enhanced_bookmarks) {
  delete obsolete_enhanced_bookmarks_;
  obsolete_enhanced_bookmarks_ = obsolete_enhanced_bookmarks;
  if (obsolete_enhanced_bookmarks) {
    set_has_obsolete_enhanced_bookmarks();
  } else {
    clear_has_obsolete_enhanced_bookmarks();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.obsolete_enhanced_bookmarks)
}

// optional .sync_pb.GcmInvalidationsFlags gcm_invalidations = 8;
inline bool ExperimentsSpecifics::has_gcm_invalidations() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
inline void ExperimentsSpecifics::set_has_gcm_invalidations() {
  _has_bits_[0] |= 0x00000080u;
}
inline void ExperimentsSpecifics::clear_has_gcm_invalidations() {
  _has_bits_[0] &= ~0x00000080u;
}
inline void ExperimentsSpecifics::clear_gcm_invalidations() {
  if (gcm_invalidations_ != NULL) gcm_invalidations_->::sync_pb::GcmInvalidationsFlags::Clear();
  clear_has_gcm_invalidations();
}
inline const ::sync_pb::GcmInvalidationsFlags& ExperimentsSpecifics::gcm_invalidations() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.gcm_invalidations)
  return gcm_invalidations_ != NULL ? *gcm_invalidations_
                         : *::sync_pb::GcmInvalidationsFlags::internal_default_instance();
}
inline ::sync_pb::GcmInvalidationsFlags* ExperimentsSpecifics::mutable_gcm_invalidations() {
  set_has_gcm_invalidations();
  if (gcm_invalidations_ == NULL) {
    gcm_invalidations_ = new ::sync_pb::GcmInvalidationsFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.gcm_invalidations)
  return gcm_invalidations_;
}
inline ::sync_pb::GcmInvalidationsFlags* ExperimentsSpecifics::release_gcm_invalidations() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.gcm_invalidations)
  clear_has_gcm_invalidations();
  ::sync_pb::GcmInvalidationsFlags* temp = gcm_invalidations_;
  gcm_invalidations_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_gcm_invalidations(::sync_pb::GcmInvalidationsFlags* gcm_invalidations) {
  delete gcm_invalidations_;
  gcm_invalidations_ = gcm_invalidations;
  if (gcm_invalidations) {
    set_has_gcm_invalidations();
  } else {
    clear_has_gcm_invalidations();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.gcm_invalidations)
}

// optional .sync_pb.WalletSyncFlags obsolete_wallet_sync = 9;
inline bool ExperimentsSpecifics::has_obsolete_wallet_sync() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
inline void ExperimentsSpecifics::set_has_obsolete_wallet_sync() {
  _has_bits_[0] |= 0x00000100u;
}
inline void ExperimentsSpecifics::clear_has_obsolete_wallet_sync() {
  _has_bits_[0] &= ~0x00000100u;
}
inline void ExperimentsSpecifics::clear_obsolete_wallet_sync() {
  if (obsolete_wallet_sync_ != NULL) obsolete_wallet_sync_->::sync_pb::WalletSyncFlags::Clear();
  clear_has_obsolete_wallet_sync();
}
inline const ::sync_pb::WalletSyncFlags& ExperimentsSpecifics::obsolete_wallet_sync() const {
  // @@protoc_insertion_point(field_get:sync_pb.ExperimentsSpecifics.obsolete_wallet_sync)
  return obsolete_wallet_sync_ != NULL ? *obsolete_wallet_sync_
                         : *::sync_pb::WalletSyncFlags::internal_default_instance();
}
inline ::sync_pb::WalletSyncFlags* ExperimentsSpecifics::mutable_obsolete_wallet_sync() {
  set_has_obsolete_wallet_sync();
  if (obsolete_wallet_sync_ == NULL) {
    obsolete_wallet_sync_ = new ::sync_pb::WalletSyncFlags;
  }
  // @@protoc_insertion_point(field_mutable:sync_pb.ExperimentsSpecifics.obsolete_wallet_sync)
  return obsolete_wallet_sync_;
}
inline ::sync_pb::WalletSyncFlags* ExperimentsSpecifics::release_obsolete_wallet_sync() {
  // @@protoc_insertion_point(field_release:sync_pb.ExperimentsSpecifics.obsolete_wallet_sync)
  clear_has_obsolete_wallet_sync();
  ::sync_pb::WalletSyncFlags* temp = obsolete_wallet_sync_;
  obsolete_wallet_sync_ = NULL;
  return temp;
}
inline void ExperimentsSpecifics::set_allocated_obsolete_wallet_sync(::sync_pb::WalletSyncFlags* obsolete_wallet_sync) {
  delete obsolete_wallet_sync_;
  obsolete_wallet_sync_ = obsolete_wallet_sync;
  if (obsolete_wallet_sync) {
    set_has_obsolete_wallet_sync();
  } else {
    clear_has_obsolete_wallet_sync();
  }
  // @@protoc_insertion_point(field_set_allocated:sync_pb.ExperimentsSpecifics.obsolete_wallet_sync)
}

#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


}  // namespace sync_pb

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_experiments_5fspecifics_2eproto__INCLUDED