zhuyujia-webhopper/collector/adg-linux/gen/components/sync/protocol/experiments_specifics.pb.cc

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "experiments_specifics.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.h>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/wire_format_lite_inl.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)

namespace sync_pb {
class KeystoreEncryptionFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<KeystoreEncryptionFlags> {
} _KeystoreEncryptionFlags_default_instance_;
class HistoryDeleteDirectivesDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<HistoryDeleteDirectives> {
} _HistoryDeleteDirectives_default_instance_;
class AutofillCullingFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<AutofillCullingFlags> {
} _AutofillCullingFlags_default_instance_;
class FaviconSyncFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<FaviconSyncFlags> {
} _FaviconSyncFlags_default_instance_;
class PreCommitUpdateAvoidanceFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<PreCommitUpdateAvoidanceFlags> {
} _PreCommitUpdateAvoidanceFlags_default_instance_;
class GcmChannelFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<GcmChannelFlags> {
} _GcmChannelFlags_default_instance_;
class EnhancedBookmarksFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<EnhancedBookmarksFlags> {
} _EnhancedBookmarksFlags_default_instance_;
class GcmInvalidationsFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<GcmInvalidationsFlags> {
} _GcmInvalidationsFlags_default_instance_;
class WalletSyncFlagsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<WalletSyncFlags> {
} _WalletSyncFlags_default_instance_;
class ExperimentsSpecificsDefaultTypeInternal : public ::google::protobuf::internal::ExplicitlyConstructed<ExperimentsSpecifics> {
} _ExperimentsSpecifics_default_instance_;

namespace protobuf_experiments_5fspecifics_2eproto {

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTableField
    const TableStruct::entries[] = {
  {0, 0, 0, ::google::protobuf::internal::kInvalidMask, 0, 0},
};

PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::AuxillaryParseTableField
    const TableStruct::aux[] = {
  ::google::protobuf::internal::AuxillaryParseTableField(),
};
PROTOBUF_CONSTEXPR_VAR ::google::protobuf::internal::ParseTable const
    TableStruct::schema[] = {
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
  { NULL, NULL, 0, -1, -1, false },
};


void TableStruct::Shutdown() {
  _KeystoreEncryptionFlags_default_instance_.Shutdown();
  _HistoryDeleteDirectives_default_instance_.Shutdown();
  _AutofillCullingFlags_default_instance_.Shutdown();
  _FaviconSyncFlags_default_instance_.Shutdown();
  _PreCommitUpdateAvoidanceFlags_default_instance_.Shutdown();
  _GcmChannelFlags_default_instance_.Shutdown();
  _EnhancedBookmarksFlags_default_instance_.Shutdown();
  _GcmInvalidationsFlags_default_instance_.Shutdown();
  _WalletSyncFlags_default_instance_.Shutdown();
  _ExperimentsSpecifics_default_instance_.Shutdown();
}

void TableStruct::InitDefaultsImpl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  ::google::protobuf::internal::InitProtobufDefaults();
  _KeystoreEncryptionFlags_default_instance_.DefaultConstruct();
  _HistoryDeleteDirectives_default_instance_.DefaultConstruct();
  _AutofillCullingFlags_default_instance_.DefaultConstruct();
  _FaviconSyncFlags_default_instance_.DefaultConstruct();
  _PreCommitUpdateAvoidanceFlags_default_instance_.DefaultConstruct();
  _GcmChannelFlags_default_instance_.DefaultConstruct();
  _EnhancedBookmarksFlags_default_instance_.DefaultConstruct();
  _GcmInvalidationsFlags_default_instance_.DefaultConstruct();
  _WalletSyncFlags_default_instance_.DefaultConstruct();
  _ExperimentsSpecifics_default_instance_.DefaultConstruct();
  _ExperimentsSpecifics_default_instance_.get_mutable()->keystore_encryption_ = const_cast< ::sync_pb::KeystoreEncryptionFlags*>(
      ::sync_pb::KeystoreEncryptionFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->history_delete_directives_ = const_cast< ::sync_pb::HistoryDeleteDirectives*>(
      ::sync_pb::HistoryDeleteDirectives::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->autofill_culling_ = const_cast< ::sync_pb::AutofillCullingFlags*>(
      ::sync_pb::AutofillCullingFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->favicon_sync_ = const_cast< ::sync_pb::FaviconSyncFlags*>(
      ::sync_pb::FaviconSyncFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->pre_commit_update_avoidance_ = const_cast< ::sync_pb::PreCommitUpdateAvoidanceFlags*>(
      ::sync_pb::PreCommitUpdateAvoidanceFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->gcm_channel_ = const_cast< ::sync_pb::GcmChannelFlags*>(
      ::sync_pb::GcmChannelFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->obsolete_enhanced_bookmarks_ = const_cast< ::sync_pb::EnhancedBookmarksFlags*>(
      ::sync_pb::EnhancedBookmarksFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->gcm_invalidations_ = const_cast< ::sync_pb::GcmInvalidationsFlags*>(
      ::sync_pb::GcmInvalidationsFlags::internal_default_instance());
  _ExperimentsSpecifics_default_instance_.get_mutable()->obsolete_wallet_sync_ = const_cast< ::sync_pb::WalletSyncFlags*>(
      ::sync_pb::WalletSyncFlags::internal_default_instance());
}

void InitDefaults() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &TableStruct::InitDefaultsImpl);
}
void AddDescriptorsImpl() {
  InitDefaults();
  ::google::protobuf::internal::OnShutdown(&TableStruct::Shutdown);
}

void AddDescriptors() {
  static GOOGLE_PROTOBUF_DECLARE_ONCE(once);
  ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl);
}

}  // namespace protobuf_experiments_5fspecifics_2eproto


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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int KeystoreEncryptionFlags::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

KeystoreEncryptionFlags::KeystoreEncryptionFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.KeystoreEncryptionFlags)
}
KeystoreEncryptionFlags::KeystoreEncryptionFlags(const KeystoreEncryptionFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.KeystoreEncryptionFlags)
}

void KeystoreEncryptionFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

KeystoreEncryptionFlags::~KeystoreEncryptionFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.KeystoreEncryptionFlags)
  SharedDtor();
}

void KeystoreEncryptionFlags::SharedDtor() {
}

void KeystoreEncryptionFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const KeystoreEncryptionFlags& KeystoreEncryptionFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

KeystoreEncryptionFlags* KeystoreEncryptionFlags::New(::google::protobuf::Arena* arena) const {
  KeystoreEncryptionFlags* n = new KeystoreEncryptionFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void KeystoreEncryptionFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.KeystoreEncryptionFlags)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool KeystoreEncryptionFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.KeystoreEncryptionFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.KeystoreEncryptionFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.KeystoreEncryptionFlags)
  return false;
#undef DO_
}

void KeystoreEncryptionFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.KeystoreEncryptionFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.KeystoreEncryptionFlags)
}

size_t KeystoreEncryptionFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.KeystoreEncryptionFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void KeystoreEncryptionFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const KeystoreEncryptionFlags*>(&from));
}

void KeystoreEncryptionFlags::MergeFrom(const KeystoreEncryptionFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.KeystoreEncryptionFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void KeystoreEncryptionFlags::CopyFrom(const KeystoreEncryptionFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.KeystoreEncryptionFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool KeystoreEncryptionFlags::IsInitialized() const {
  return true;
}

void KeystoreEncryptionFlags::Swap(KeystoreEncryptionFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void KeystoreEncryptionFlags::InternalSwap(KeystoreEncryptionFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string KeystoreEncryptionFlags::GetTypeName() const {
  return "sync_pb.KeystoreEncryptionFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// KeystoreEncryptionFlags

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int HistoryDeleteDirectives::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

HistoryDeleteDirectives::HistoryDeleteDirectives()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.HistoryDeleteDirectives)
}
HistoryDeleteDirectives::HistoryDeleteDirectives(const HistoryDeleteDirectives& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.HistoryDeleteDirectives)
}

void HistoryDeleteDirectives::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

HistoryDeleteDirectives::~HistoryDeleteDirectives() {
  // @@protoc_insertion_point(destructor:sync_pb.HistoryDeleteDirectives)
  SharedDtor();
}

void HistoryDeleteDirectives::SharedDtor() {
}

void HistoryDeleteDirectives::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const HistoryDeleteDirectives& HistoryDeleteDirectives::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

HistoryDeleteDirectives* HistoryDeleteDirectives::New(::google::protobuf::Arena* arena) const {
  HistoryDeleteDirectives* n = new HistoryDeleteDirectives;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void HistoryDeleteDirectives::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.HistoryDeleteDirectives)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool HistoryDeleteDirectives::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.HistoryDeleteDirectives)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.HistoryDeleteDirectives)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.HistoryDeleteDirectives)
  return false;
#undef DO_
}

void HistoryDeleteDirectives::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.HistoryDeleteDirectives)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.HistoryDeleteDirectives)
}

size_t HistoryDeleteDirectives::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.HistoryDeleteDirectives)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void HistoryDeleteDirectives::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const HistoryDeleteDirectives*>(&from));
}

void HistoryDeleteDirectives::MergeFrom(const HistoryDeleteDirectives& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.HistoryDeleteDirectives)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void HistoryDeleteDirectives::CopyFrom(const HistoryDeleteDirectives& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.HistoryDeleteDirectives)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool HistoryDeleteDirectives::IsInitialized() const {
  return true;
}

void HistoryDeleteDirectives::Swap(HistoryDeleteDirectives* other) {
  if (other == this) return;
  InternalSwap(other);
}
void HistoryDeleteDirectives::InternalSwap(HistoryDeleteDirectives* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string HistoryDeleteDirectives::GetTypeName() const {
  return "sync_pb.HistoryDeleteDirectives";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// HistoryDeleteDirectives

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int AutofillCullingFlags::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

AutofillCullingFlags::AutofillCullingFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.AutofillCullingFlags)
}
AutofillCullingFlags::AutofillCullingFlags(const AutofillCullingFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.AutofillCullingFlags)
}

void AutofillCullingFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

AutofillCullingFlags::~AutofillCullingFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.AutofillCullingFlags)
  SharedDtor();
}

void AutofillCullingFlags::SharedDtor() {
}

void AutofillCullingFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const AutofillCullingFlags& AutofillCullingFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

AutofillCullingFlags* AutofillCullingFlags::New(::google::protobuf::Arena* arena) const {
  AutofillCullingFlags* n = new AutofillCullingFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void AutofillCullingFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.AutofillCullingFlags)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool AutofillCullingFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.AutofillCullingFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.AutofillCullingFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.AutofillCullingFlags)
  return false;
#undef DO_
}

void AutofillCullingFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.AutofillCullingFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.AutofillCullingFlags)
}

size_t AutofillCullingFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.AutofillCullingFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void AutofillCullingFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const AutofillCullingFlags*>(&from));
}

void AutofillCullingFlags::MergeFrom(const AutofillCullingFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.AutofillCullingFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void AutofillCullingFlags::CopyFrom(const AutofillCullingFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.AutofillCullingFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool AutofillCullingFlags::IsInitialized() const {
  return true;
}

void AutofillCullingFlags::Swap(AutofillCullingFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void AutofillCullingFlags::InternalSwap(AutofillCullingFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string AutofillCullingFlags::GetTypeName() const {
  return "sync_pb.AutofillCullingFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// AutofillCullingFlags

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int FaviconSyncFlags::kEnabledFieldNumber;
const int FaviconSyncFlags::kFaviconSyncLimitFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

FaviconSyncFlags::FaviconSyncFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.FaviconSyncFlags)
}
FaviconSyncFlags::FaviconSyncFlags(const FaviconSyncFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::memcpy(&enabled_, &from.enabled_,
    static_cast<size_t>(reinterpret_cast<char*>(&favicon_sync_limit_) -
    reinterpret_cast<char*>(&enabled_)) + sizeof(favicon_sync_limit_));
  // @@protoc_insertion_point(copy_constructor:sync_pb.FaviconSyncFlags)
}

void FaviconSyncFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
  favicon_sync_limit_ = 200;
}

FaviconSyncFlags::~FaviconSyncFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.FaviconSyncFlags)
  SharedDtor();
}

void FaviconSyncFlags::SharedDtor() {
}

void FaviconSyncFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const FaviconSyncFlags& FaviconSyncFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

FaviconSyncFlags* FaviconSyncFlags::New(::google::protobuf::Arena* arena) const {
  FaviconSyncFlags* n = new FaviconSyncFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void FaviconSyncFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.FaviconSyncFlags)
  if (_has_bits_[0 / 32] & 3u) {
    enabled_ = false;
    favicon_sync_limit_ = 200;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool FaviconSyncFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.FaviconSyncFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional int32 favicon_sync_limit = 2 [default = 200];
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(16u)) {
          set_has_favicon_sync_limit();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(
                 input, &favicon_sync_limit_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.FaviconSyncFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.FaviconSyncFlags)
  return false;
#undef DO_
}

void FaviconSyncFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.FaviconSyncFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  // optional int32 favicon_sync_limit = 2 [default = 200];
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->favicon_sync_limit(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.FaviconSyncFlags)
}

size_t FaviconSyncFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.FaviconSyncFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional bool enabled = 1;
    if (has_enabled()) {
      total_size += 1 + 1;
    }

    // optional int32 favicon_sync_limit = 2 [default = 200];
    if (has_favicon_sync_limit()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::Int32Size(
          this->favicon_sync_limit());
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void FaviconSyncFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const FaviconSyncFlags*>(&from));
}

void FaviconSyncFlags::MergeFrom(const FaviconSyncFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.FaviconSyncFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      enabled_ = from.enabled_;
    }
    if (cached_has_bits & 0x00000002u) {
      favicon_sync_limit_ = from.favicon_sync_limit_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void FaviconSyncFlags::CopyFrom(const FaviconSyncFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.FaviconSyncFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool FaviconSyncFlags::IsInitialized() const {
  return true;
}

void FaviconSyncFlags::Swap(FaviconSyncFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void FaviconSyncFlags::InternalSwap(FaviconSyncFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(favicon_sync_limit_, other->favicon_sync_limit_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string FaviconSyncFlags::GetTypeName() const {
  return "sync_pb.FaviconSyncFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// FaviconSyncFlags

// optional bool enabled = 1;
bool FaviconSyncFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void FaviconSyncFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000001u;
}
void FaviconSyncFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000001u;
}
void FaviconSyncFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
bool FaviconSyncFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.FaviconSyncFlags.enabled)
  return enabled_;
}
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];
bool FaviconSyncFlags::has_favicon_sync_limit() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void FaviconSyncFlags::set_has_favicon_sync_limit() {
  _has_bits_[0] |= 0x00000002u;
}
void FaviconSyncFlags::clear_has_favicon_sync_limit() {
  _has_bits_[0] &= ~0x00000002u;
}
void FaviconSyncFlags::clear_favicon_sync_limit() {
  favicon_sync_limit_ = 200;
  clear_has_favicon_sync_limit();
}
::google::protobuf::int32 FaviconSyncFlags::favicon_sync_limit() const {
  // @@protoc_insertion_point(field_get:sync_pb.FaviconSyncFlags.favicon_sync_limit)
  return favicon_sync_limit_;
}
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)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int PreCommitUpdateAvoidanceFlags::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

PreCommitUpdateAvoidanceFlags::PreCommitUpdateAvoidanceFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.PreCommitUpdateAvoidanceFlags)
}
PreCommitUpdateAvoidanceFlags::PreCommitUpdateAvoidanceFlags(const PreCommitUpdateAvoidanceFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.PreCommitUpdateAvoidanceFlags)
}

void PreCommitUpdateAvoidanceFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

PreCommitUpdateAvoidanceFlags::~PreCommitUpdateAvoidanceFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.PreCommitUpdateAvoidanceFlags)
  SharedDtor();
}

void PreCommitUpdateAvoidanceFlags::SharedDtor() {
}

void PreCommitUpdateAvoidanceFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const PreCommitUpdateAvoidanceFlags& PreCommitUpdateAvoidanceFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

PreCommitUpdateAvoidanceFlags* PreCommitUpdateAvoidanceFlags::New(::google::protobuf::Arena* arena) const {
  PreCommitUpdateAvoidanceFlags* n = new PreCommitUpdateAvoidanceFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void PreCommitUpdateAvoidanceFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.PreCommitUpdateAvoidanceFlags)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool PreCommitUpdateAvoidanceFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.PreCommitUpdateAvoidanceFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.PreCommitUpdateAvoidanceFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.PreCommitUpdateAvoidanceFlags)
  return false;
#undef DO_
}

void PreCommitUpdateAvoidanceFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.PreCommitUpdateAvoidanceFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.PreCommitUpdateAvoidanceFlags)
}

size_t PreCommitUpdateAvoidanceFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.PreCommitUpdateAvoidanceFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void PreCommitUpdateAvoidanceFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const PreCommitUpdateAvoidanceFlags*>(&from));
}

void PreCommitUpdateAvoidanceFlags::MergeFrom(const PreCommitUpdateAvoidanceFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.PreCommitUpdateAvoidanceFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void PreCommitUpdateAvoidanceFlags::CopyFrom(const PreCommitUpdateAvoidanceFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.PreCommitUpdateAvoidanceFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PreCommitUpdateAvoidanceFlags::IsInitialized() const {
  return true;
}

void PreCommitUpdateAvoidanceFlags::Swap(PreCommitUpdateAvoidanceFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void PreCommitUpdateAvoidanceFlags::InternalSwap(PreCommitUpdateAvoidanceFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string PreCommitUpdateAvoidanceFlags::GetTypeName() const {
  return "sync_pb.PreCommitUpdateAvoidanceFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// PreCommitUpdateAvoidanceFlags

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int GcmChannelFlags::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

GcmChannelFlags::GcmChannelFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.GcmChannelFlags)
}
GcmChannelFlags::GcmChannelFlags(const GcmChannelFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.GcmChannelFlags)
}

void GcmChannelFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

GcmChannelFlags::~GcmChannelFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.GcmChannelFlags)
  SharedDtor();
}

void GcmChannelFlags::SharedDtor() {
}

void GcmChannelFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GcmChannelFlags& GcmChannelFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

GcmChannelFlags* GcmChannelFlags::New(::google::protobuf::Arena* arena) const {
  GcmChannelFlags* n = new GcmChannelFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void GcmChannelFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.GcmChannelFlags)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool GcmChannelFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.GcmChannelFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.GcmChannelFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.GcmChannelFlags)
  return false;
#undef DO_
}

void GcmChannelFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.GcmChannelFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.GcmChannelFlags)
}

size_t GcmChannelFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.GcmChannelFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GcmChannelFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GcmChannelFlags*>(&from));
}

void GcmChannelFlags::MergeFrom(const GcmChannelFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.GcmChannelFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void GcmChannelFlags::CopyFrom(const GcmChannelFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.GcmChannelFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GcmChannelFlags::IsInitialized() const {
  return true;
}

void GcmChannelFlags::Swap(GcmChannelFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void GcmChannelFlags::InternalSwap(GcmChannelFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string GcmChannelFlags::GetTypeName() const {
  return "sync_pb.GcmChannelFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// GcmChannelFlags

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int EnhancedBookmarksFlags::kEnabledFieldNumber;
const int EnhancedBookmarksFlags::kExtensionIdFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

EnhancedBookmarksFlags::EnhancedBookmarksFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.EnhancedBookmarksFlags)
}
EnhancedBookmarksFlags::EnhancedBookmarksFlags(const EnhancedBookmarksFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  extension_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  if (from.has_extension_id()) {
    extension_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.extension_id_);
  }
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.EnhancedBookmarksFlags)
}

void EnhancedBookmarksFlags::SharedCtor() {
  _cached_size_ = 0;
  extension_id_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  enabled_ = false;
}

EnhancedBookmarksFlags::~EnhancedBookmarksFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.EnhancedBookmarksFlags)
  SharedDtor();
}

void EnhancedBookmarksFlags::SharedDtor() {
  extension_id_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void EnhancedBookmarksFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const EnhancedBookmarksFlags& EnhancedBookmarksFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

EnhancedBookmarksFlags* EnhancedBookmarksFlags::New(::google::protobuf::Arena* arena) const {
  EnhancedBookmarksFlags* n = new EnhancedBookmarksFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void EnhancedBookmarksFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.EnhancedBookmarksFlags)
  if (has_extension_id()) {
    GOOGLE_DCHECK(!extension_id_.IsDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()));
    (*extension_id_.UnsafeRawStringPointer())->clear();
  }
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool EnhancedBookmarksFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.EnhancedBookmarksFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional string extension_id = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_extension_id()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.EnhancedBookmarksFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.EnhancedBookmarksFlags)
  return false;
#undef DO_
}

void EnhancedBookmarksFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.EnhancedBookmarksFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  // optional string extension_id = 2;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->extension_id(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.EnhancedBookmarksFlags)
}

size_t EnhancedBookmarksFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.EnhancedBookmarksFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 3u) {
    // optional string extension_id = 2;
    if (has_extension_id()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::StringSize(
          this->extension_id());
    }

    // optional bool enabled = 1;
    if (has_enabled()) {
      total_size += 1 + 1;
    }

  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void EnhancedBookmarksFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const EnhancedBookmarksFlags*>(&from));
}

void EnhancedBookmarksFlags::MergeFrom(const EnhancedBookmarksFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.EnhancedBookmarksFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 3u) {
    if (cached_has_bits & 0x00000001u) {
      set_has_extension_id();
      extension_id_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.extension_id_);
    }
    if (cached_has_bits & 0x00000002u) {
      enabled_ = from.enabled_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
}

void EnhancedBookmarksFlags::CopyFrom(const EnhancedBookmarksFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.EnhancedBookmarksFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool EnhancedBookmarksFlags::IsInitialized() const {
  return true;
}

void EnhancedBookmarksFlags::Swap(EnhancedBookmarksFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void EnhancedBookmarksFlags::InternalSwap(EnhancedBookmarksFlags* other) {
  extension_id_.Swap(&other->extension_id_);
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string EnhancedBookmarksFlags::GetTypeName() const {
  return "sync_pb.EnhancedBookmarksFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// EnhancedBookmarksFlags

// optional bool enabled = 1;
bool EnhancedBookmarksFlags::has_enabled() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void EnhancedBookmarksFlags::set_has_enabled() {
  _has_bits_[0] |= 0x00000002u;
}
void EnhancedBookmarksFlags::clear_has_enabled() {
  _has_bits_[0] &= ~0x00000002u;
}
void EnhancedBookmarksFlags::clear_enabled() {
  enabled_ = false;
  clear_has_enabled();
}
bool EnhancedBookmarksFlags::enabled() const {
  // @@protoc_insertion_point(field_get:sync_pb.EnhancedBookmarksFlags.enabled)
  return enabled_;
}
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;
bool EnhancedBookmarksFlags::has_extension_id() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void EnhancedBookmarksFlags::set_has_extension_id() {
  _has_bits_[0] |= 0x00000001u;
}
void EnhancedBookmarksFlags::clear_has_extension_id() {
  _has_bits_[0] &= ~0x00000001u;
}
void EnhancedBookmarksFlags::clear_extension_id() {
  extension_id_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_extension_id();
}
const ::std::string& EnhancedBookmarksFlags::extension_id() const {
  // @@protoc_insertion_point(field_get:sync_pb.EnhancedBookmarksFlags.extension_id)
  return extension_id_.GetNoArena();
}
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
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
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)
}
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)
}
::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());
}
::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());
}
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)
}

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int GcmInvalidationsFlags::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

GcmInvalidationsFlags::GcmInvalidationsFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.GcmInvalidationsFlags)
}
GcmInvalidationsFlags::GcmInvalidationsFlags(const GcmInvalidationsFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.GcmInvalidationsFlags)
}

void GcmInvalidationsFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

GcmInvalidationsFlags::~GcmInvalidationsFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.GcmInvalidationsFlags)
  SharedDtor();
}

void GcmInvalidationsFlags::SharedDtor() {
}

void GcmInvalidationsFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const GcmInvalidationsFlags& GcmInvalidationsFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

GcmInvalidationsFlags* GcmInvalidationsFlags::New(::google::protobuf::Arena* arena) const {
  GcmInvalidationsFlags* n = new GcmInvalidationsFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void GcmInvalidationsFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.GcmInvalidationsFlags)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool GcmInvalidationsFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.GcmInvalidationsFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.GcmInvalidationsFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.GcmInvalidationsFlags)
  return false;
#undef DO_
}

void GcmInvalidationsFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.GcmInvalidationsFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.GcmInvalidationsFlags)
}

size_t GcmInvalidationsFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.GcmInvalidationsFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void GcmInvalidationsFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const GcmInvalidationsFlags*>(&from));
}

void GcmInvalidationsFlags::MergeFrom(const GcmInvalidationsFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.GcmInvalidationsFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void GcmInvalidationsFlags::CopyFrom(const GcmInvalidationsFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.GcmInvalidationsFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool GcmInvalidationsFlags::IsInitialized() const {
  return true;
}

void GcmInvalidationsFlags::Swap(GcmInvalidationsFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void GcmInvalidationsFlags::InternalSwap(GcmInvalidationsFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string GcmInvalidationsFlags::GetTypeName() const {
  return "sync_pb.GcmInvalidationsFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// GcmInvalidationsFlags

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int WalletSyncFlags::kEnabledFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

WalletSyncFlags::WalletSyncFlags()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.WalletSyncFlags)
}
WalletSyncFlags::WalletSyncFlags(const WalletSyncFlags& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  enabled_ = from.enabled_;
  // @@protoc_insertion_point(copy_constructor:sync_pb.WalletSyncFlags)
}

void WalletSyncFlags::SharedCtor() {
  _cached_size_ = 0;
  enabled_ = false;
}

WalletSyncFlags::~WalletSyncFlags() {
  // @@protoc_insertion_point(destructor:sync_pb.WalletSyncFlags)
  SharedDtor();
}

void WalletSyncFlags::SharedDtor() {
}

void WalletSyncFlags::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const WalletSyncFlags& WalletSyncFlags::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

WalletSyncFlags* WalletSyncFlags::New(::google::protobuf::Arena* arena) const {
  WalletSyncFlags* n = new WalletSyncFlags;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void WalletSyncFlags::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.WalletSyncFlags)
  enabled_ = false;
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool WalletSyncFlags::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.WalletSyncFlags)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional bool enabled = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(8u)) {
          set_has_enabled();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &enabled_)));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.WalletSyncFlags)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.WalletSyncFlags)
  return false;
#undef DO_
}

void WalletSyncFlags::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.WalletSyncFlags)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool enabled = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(1, this->enabled(), output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.WalletSyncFlags)
}

size_t WalletSyncFlags::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.WalletSyncFlags)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  // optional bool enabled = 1;
  if (has_enabled()) {
    total_size += 1 + 1;
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void WalletSyncFlags::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const WalletSyncFlags*>(&from));
}

void WalletSyncFlags::MergeFrom(const WalletSyncFlags& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.WalletSyncFlags)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from.has_enabled()) {
    set_enabled(from.enabled());
  }
}

void WalletSyncFlags::CopyFrom(const WalletSyncFlags& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.WalletSyncFlags)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool WalletSyncFlags::IsInitialized() const {
  return true;
}

void WalletSyncFlags::Swap(WalletSyncFlags* other) {
  if (other == this) return;
  InternalSwap(other);
}
void WalletSyncFlags::InternalSwap(WalletSyncFlags* other) {
  std::swap(enabled_, other->enabled_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string WalletSyncFlags::GetTypeName() const {
  return "sync_pb.WalletSyncFlags";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// WalletSyncFlags

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

#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ExperimentsSpecifics::kKeystoreEncryptionFieldNumber;
const int ExperimentsSpecifics::kHistoryDeleteDirectivesFieldNumber;
const int ExperimentsSpecifics::kAutofillCullingFieldNumber;
const int ExperimentsSpecifics::kFaviconSyncFieldNumber;
const int ExperimentsSpecifics::kPreCommitUpdateAvoidanceFieldNumber;
const int ExperimentsSpecifics::kGcmChannelFieldNumber;
const int ExperimentsSpecifics::kObsoleteEnhancedBookmarksFieldNumber;
const int ExperimentsSpecifics::kGcmInvalidationsFieldNumber;
const int ExperimentsSpecifics::kObsoleteWalletSyncFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ExperimentsSpecifics::ExperimentsSpecifics()
  : ::google::protobuf::MessageLite(), _internal_metadata_(NULL) {
  if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) {
    protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  }
  SharedCtor();
  // @@protoc_insertion_point(constructor:sync_pb.ExperimentsSpecifics)
}
ExperimentsSpecifics::ExperimentsSpecifics(const ExperimentsSpecifics& from)
  : ::google::protobuf::MessageLite(),
      _internal_metadata_(NULL),
      _has_bits_(from._has_bits_),
      _cached_size_(0) {
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  if (from.has_keystore_encryption()) {
    keystore_encryption_ = new ::sync_pb::KeystoreEncryptionFlags(*from.keystore_encryption_);
  } else {
    keystore_encryption_ = NULL;
  }
  if (from.has_history_delete_directives()) {
    history_delete_directives_ = new ::sync_pb::HistoryDeleteDirectives(*from.history_delete_directives_);
  } else {
    history_delete_directives_ = NULL;
  }
  if (from.has_autofill_culling()) {
    autofill_culling_ = new ::sync_pb::AutofillCullingFlags(*from.autofill_culling_);
  } else {
    autofill_culling_ = NULL;
  }
  if (from.has_favicon_sync()) {
    favicon_sync_ = new ::sync_pb::FaviconSyncFlags(*from.favicon_sync_);
  } else {
    favicon_sync_ = NULL;
  }
  if (from.has_pre_commit_update_avoidance()) {
    pre_commit_update_avoidance_ = new ::sync_pb::PreCommitUpdateAvoidanceFlags(*from.pre_commit_update_avoidance_);
  } else {
    pre_commit_update_avoidance_ = NULL;
  }
  if (from.has_gcm_channel()) {
    gcm_channel_ = new ::sync_pb::GcmChannelFlags(*from.gcm_channel_);
  } else {
    gcm_channel_ = NULL;
  }
  if (from.has_obsolete_enhanced_bookmarks()) {
    obsolete_enhanced_bookmarks_ = new ::sync_pb::EnhancedBookmarksFlags(*from.obsolete_enhanced_bookmarks_);
  } else {
    obsolete_enhanced_bookmarks_ = NULL;
  }
  if (from.has_gcm_invalidations()) {
    gcm_invalidations_ = new ::sync_pb::GcmInvalidationsFlags(*from.gcm_invalidations_);
  } else {
    gcm_invalidations_ = NULL;
  }
  if (from.has_obsolete_wallet_sync()) {
    obsolete_wallet_sync_ = new ::sync_pb::WalletSyncFlags(*from.obsolete_wallet_sync_);
  } else {
    obsolete_wallet_sync_ = NULL;
  }
  // @@protoc_insertion_point(copy_constructor:sync_pb.ExperimentsSpecifics)
}

void ExperimentsSpecifics::SharedCtor() {
  _cached_size_ = 0;
  ::memset(&keystore_encryption_, 0, static_cast<size_t>(
      reinterpret_cast<char*>(&obsolete_wallet_sync_) -
      reinterpret_cast<char*>(&keystore_encryption_)) + sizeof(obsolete_wallet_sync_));
}

ExperimentsSpecifics::~ExperimentsSpecifics() {
  // @@protoc_insertion_point(destructor:sync_pb.ExperimentsSpecifics)
  SharedDtor();
}

void ExperimentsSpecifics::SharedDtor() {
  if (this != internal_default_instance()) {
    delete keystore_encryption_;
  }
  if (this != internal_default_instance()) {
    delete history_delete_directives_;
  }
  if (this != internal_default_instance()) {
    delete autofill_culling_;
  }
  if (this != internal_default_instance()) {
    delete favicon_sync_;
  }
  if (this != internal_default_instance()) {
    delete pre_commit_update_avoidance_;
  }
  if (this != internal_default_instance()) {
    delete gcm_channel_;
  }
  if (this != internal_default_instance()) {
    delete obsolete_enhanced_bookmarks_;
  }
  if (this != internal_default_instance()) {
    delete gcm_invalidations_;
  }
  if (this != internal_default_instance()) {
    delete obsolete_wallet_sync_;
  }
}

void ExperimentsSpecifics::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ExperimentsSpecifics& ExperimentsSpecifics::default_instance() {
  protobuf_experiments_5fspecifics_2eproto::InitDefaults();
  return *internal_default_instance();
}

ExperimentsSpecifics* ExperimentsSpecifics::New(::google::protobuf::Arena* arena) const {
  ExperimentsSpecifics* n = new ExperimentsSpecifics;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ExperimentsSpecifics::Clear() {
// @@protoc_insertion_point(message_clear_start:sync_pb.ExperimentsSpecifics)
  if (_has_bits_[0 / 32] & 255u) {
    if (has_keystore_encryption()) {
      GOOGLE_DCHECK(keystore_encryption_ != NULL);
      keystore_encryption_->::sync_pb::KeystoreEncryptionFlags::Clear();
    }
    if (has_history_delete_directives()) {
      GOOGLE_DCHECK(history_delete_directives_ != NULL);
      history_delete_directives_->::sync_pb::HistoryDeleteDirectives::Clear();
    }
    if (has_autofill_culling()) {
      GOOGLE_DCHECK(autofill_culling_ != NULL);
      autofill_culling_->::sync_pb::AutofillCullingFlags::Clear();
    }
    if (has_favicon_sync()) {
      GOOGLE_DCHECK(favicon_sync_ != NULL);
      favicon_sync_->::sync_pb::FaviconSyncFlags::Clear();
    }
    if (has_pre_commit_update_avoidance()) {
      GOOGLE_DCHECK(pre_commit_update_avoidance_ != NULL);
      pre_commit_update_avoidance_->::sync_pb::PreCommitUpdateAvoidanceFlags::Clear();
    }
    if (has_gcm_channel()) {
      GOOGLE_DCHECK(gcm_channel_ != NULL);
      gcm_channel_->::sync_pb::GcmChannelFlags::Clear();
    }
    if (has_obsolete_enhanced_bookmarks()) {
      GOOGLE_DCHECK(obsolete_enhanced_bookmarks_ != NULL);
      obsolete_enhanced_bookmarks_->::sync_pb::EnhancedBookmarksFlags::Clear();
    }
    if (has_gcm_invalidations()) {
      GOOGLE_DCHECK(gcm_invalidations_ != NULL);
      gcm_invalidations_->::sync_pb::GcmInvalidationsFlags::Clear();
    }
  }
  if (has_obsolete_wallet_sync()) {
    GOOGLE_DCHECK(obsolete_wallet_sync_ != NULL);
    obsolete_wallet_sync_->::sync_pb::WalletSyncFlags::Clear();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear();
}

bool ExperimentsSpecifics::MergePartialFromCodedStream(
    ::google::protobuf::io::CodedInputStream* input) {
#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure
  ::google::protobuf::uint32 tag;
  ::google::protobuf::io::LazyStringOutputStream unknown_fields_string(
      ::google::protobuf::NewPermanentCallback(&_internal_metadata_,
          &::google::protobuf::internal::InternalMetadataWithArenaLite::
              mutable_unknown_fields));
  ::google::protobuf::io::CodedOutputStream unknown_fields_stream(
      &unknown_fields_string, false);
  // @@protoc_insertion_point(parse_start:sync_pb.ExperimentsSpecifics)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // optional .sync_pb.KeystoreEncryptionFlags keystore_encryption = 1;
      case 1: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(10u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_keystore_encryption()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.HistoryDeleteDirectives history_delete_directives = 2;
      case 2: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(18u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_history_delete_directives()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.AutofillCullingFlags autofill_culling = 3;
      case 3: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(26u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_autofill_culling()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.FaviconSyncFlags favicon_sync = 4;
      case 4: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(34u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_favicon_sync()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.PreCommitUpdateAvoidanceFlags pre_commit_update_avoidance = 5;
      case 5: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(42u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_pre_commit_update_avoidance()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.GcmChannelFlags gcm_channel = 6;
      case 6: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(50u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gcm_channel()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.EnhancedBookmarksFlags obsolete_enhanced_bookmarks = 7;
      case 7: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(58u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_obsolete_enhanced_bookmarks()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.GcmInvalidationsFlags gcm_invalidations = 8;
      case 8: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(66u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_gcm_invalidations()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      // optional .sync_pb.WalletSyncFlags obsolete_wallet_sync = 9;
      case 9: {
        if (static_cast< ::google::protobuf::uint8>(tag) ==
            static_cast< ::google::protobuf::uint8>(74u)) {
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
               input, mutable_obsolete_wallet_sync()));
        } else {
          goto handle_unusual;
        }
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormatLite::SkipField(
            input, tag, &unknown_fields_stream));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:sync_pb.ExperimentsSpecifics)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:sync_pb.ExperimentsSpecifics)
  return false;
#undef DO_
}

void ExperimentsSpecifics::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:sync_pb.ExperimentsSpecifics)
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .sync_pb.KeystoreEncryptionFlags keystore_encryption = 1;
  if (cached_has_bits & 0x00000001u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      1, *this->keystore_encryption_, output);
  }

  // optional .sync_pb.HistoryDeleteDirectives history_delete_directives = 2;
  if (cached_has_bits & 0x00000002u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      2, *this->history_delete_directives_, output);
  }

  // optional .sync_pb.AutofillCullingFlags autofill_culling = 3;
  if (cached_has_bits & 0x00000004u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      3, *this->autofill_culling_, output);
  }

  // optional .sync_pb.FaviconSyncFlags favicon_sync = 4;
  if (cached_has_bits & 0x00000008u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      4, *this->favicon_sync_, output);
  }

  // optional .sync_pb.PreCommitUpdateAvoidanceFlags pre_commit_update_avoidance = 5;
  if (cached_has_bits & 0x00000010u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      5, *this->pre_commit_update_avoidance_, output);
  }

  // optional .sync_pb.GcmChannelFlags gcm_channel = 6;
  if (cached_has_bits & 0x00000020u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      6, *this->gcm_channel_, output);
  }

  // optional .sync_pb.EnhancedBookmarksFlags obsolete_enhanced_bookmarks = 7;
  if (cached_has_bits & 0x00000040u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      7, *this->obsolete_enhanced_bookmarks_, output);
  }

  // optional .sync_pb.GcmInvalidationsFlags gcm_invalidations = 8;
  if (cached_has_bits & 0x00000080u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      8, *this->gcm_invalidations_, output);
  }

  // optional .sync_pb.WalletSyncFlags obsolete_wallet_sync = 9;
  if (cached_has_bits & 0x00000100u) {
    ::google::protobuf::internal::WireFormatLite::WriteMessage(
      9, *this->obsolete_wallet_sync_, output);
  }

  output->WriteRaw(unknown_fields().data(),
                   static_cast<int>(unknown_fields().size()));
  // @@protoc_insertion_point(serialize_end:sync_pb.ExperimentsSpecifics)
}

size_t ExperimentsSpecifics::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:sync_pb.ExperimentsSpecifics)
  size_t total_size = 0;

  total_size += unknown_fields().size();

  if (_has_bits_[0 / 32] & 255u) {
    // optional .sync_pb.KeystoreEncryptionFlags keystore_encryption = 1;
    if (has_keystore_encryption()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->keystore_encryption_);
    }

    // optional .sync_pb.HistoryDeleteDirectives history_delete_directives = 2;
    if (has_history_delete_directives()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->history_delete_directives_);
    }

    // optional .sync_pb.AutofillCullingFlags autofill_culling = 3;
    if (has_autofill_culling()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->autofill_culling_);
    }

    // optional .sync_pb.FaviconSyncFlags favicon_sync = 4;
    if (has_favicon_sync()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->favicon_sync_);
    }

    // optional .sync_pb.PreCommitUpdateAvoidanceFlags pre_commit_update_avoidance = 5;
    if (has_pre_commit_update_avoidance()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->pre_commit_update_avoidance_);
    }

    // optional .sync_pb.GcmChannelFlags gcm_channel = 6;
    if (has_gcm_channel()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->gcm_channel_);
    }

    // optional .sync_pb.EnhancedBookmarksFlags obsolete_enhanced_bookmarks = 7;
    if (has_obsolete_enhanced_bookmarks()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->obsolete_enhanced_bookmarks_);
    }

    // optional .sync_pb.GcmInvalidationsFlags gcm_invalidations = 8;
    if (has_gcm_invalidations()) {
      total_size += 1 +
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          *this->gcm_invalidations_);
    }

  }
  // optional .sync_pb.WalletSyncFlags obsolete_wallet_sync = 9;
  if (has_obsolete_wallet_sync()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
        *this->obsolete_wallet_sync_);
  }

  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ExperimentsSpecifics::CheckTypeAndMergeFrom(
    const ::google::protobuf::MessageLite& from) {
  MergeFrom(*::google::protobuf::down_cast<const ExperimentsSpecifics*>(&from));
}

void ExperimentsSpecifics::MergeFrom(const ExperimentsSpecifics& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:sync_pb.ExperimentsSpecifics)
  GOOGLE_DCHECK_NE(&from, this);
  _internal_metadata_.MergeFrom(from._internal_metadata_);
  ::google::protobuf::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 255u) {
    if (cached_has_bits & 0x00000001u) {
      mutable_keystore_encryption()->::sync_pb::KeystoreEncryptionFlags::MergeFrom(from.keystore_encryption());
    }
    if (cached_has_bits & 0x00000002u) {
      mutable_history_delete_directives()->::sync_pb::HistoryDeleteDirectives::MergeFrom(from.history_delete_directives());
    }
    if (cached_has_bits & 0x00000004u) {
      mutable_autofill_culling()->::sync_pb::AutofillCullingFlags::MergeFrom(from.autofill_culling());
    }
    if (cached_has_bits & 0x00000008u) {
      mutable_favicon_sync()->::sync_pb::FaviconSyncFlags::MergeFrom(from.favicon_sync());
    }
    if (cached_has_bits & 0x00000010u) {
      mutable_pre_commit_update_avoidance()->::sync_pb::PreCommitUpdateAvoidanceFlags::MergeFrom(from.pre_commit_update_avoidance());
    }
    if (cached_has_bits & 0x00000020u) {
      mutable_gcm_channel()->::sync_pb::GcmChannelFlags::MergeFrom(from.gcm_channel());
    }
    if (cached_has_bits & 0x00000040u) {
      mutable_obsolete_enhanced_bookmarks()->::sync_pb::EnhancedBookmarksFlags::MergeFrom(from.obsolete_enhanced_bookmarks());
    }
    if (cached_has_bits & 0x00000080u) {
      mutable_gcm_invalidations()->::sync_pb::GcmInvalidationsFlags::MergeFrom(from.gcm_invalidations());
    }
  }
  if (cached_has_bits & 0x00000100u) {
    mutable_obsolete_wallet_sync()->::sync_pb::WalletSyncFlags::MergeFrom(from.obsolete_wallet_sync());
  }
}

void ExperimentsSpecifics::CopyFrom(const ExperimentsSpecifics& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:sync_pb.ExperimentsSpecifics)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool ExperimentsSpecifics::IsInitialized() const {
  return true;
}

void ExperimentsSpecifics::Swap(ExperimentsSpecifics* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ExperimentsSpecifics::InternalSwap(ExperimentsSpecifics* other) {
  std::swap(keystore_encryption_, other->keystore_encryption_);
  std::swap(history_delete_directives_, other->history_delete_directives_);
  std::swap(autofill_culling_, other->autofill_culling_);
  std::swap(favicon_sync_, other->favicon_sync_);
  std::swap(pre_commit_update_avoidance_, other->pre_commit_update_avoidance_);
  std::swap(gcm_channel_, other->gcm_channel_);
  std::swap(obsolete_enhanced_bookmarks_, other->obsolete_enhanced_bookmarks_);
  std::swap(gcm_invalidations_, other->gcm_invalidations_);
  std::swap(obsolete_wallet_sync_, other->obsolete_wallet_sync_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::std::string ExperimentsSpecifics::GetTypeName() const {
  return "sync_pb.ExperimentsSpecifics";
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ExperimentsSpecifics

// optional .sync_pb.KeystoreEncryptionFlags keystore_encryption = 1;
bool ExperimentsSpecifics::has_keystore_encryption() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void ExperimentsSpecifics::set_has_keystore_encryption() {
  _has_bits_[0] |= 0x00000001u;
}
void ExperimentsSpecifics::clear_has_keystore_encryption() {
  _has_bits_[0] &= ~0x00000001u;
}
void ExperimentsSpecifics::clear_keystore_encryption() {
  if (keystore_encryption_ != NULL) keystore_encryption_->::sync_pb::KeystoreEncryptionFlags::Clear();
  clear_has_keystore_encryption();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_history_delete_directives() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void ExperimentsSpecifics::set_has_history_delete_directives() {
  _has_bits_[0] |= 0x00000002u;
}
void ExperimentsSpecifics::clear_has_history_delete_directives() {
  _has_bits_[0] &= ~0x00000002u;
}
void ExperimentsSpecifics::clear_history_delete_directives() {
  if (history_delete_directives_ != NULL) history_delete_directives_->::sync_pb::HistoryDeleteDirectives::Clear();
  clear_has_history_delete_directives();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_autofill_culling() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
void ExperimentsSpecifics::set_has_autofill_culling() {
  _has_bits_[0] |= 0x00000004u;
}
void ExperimentsSpecifics::clear_has_autofill_culling() {
  _has_bits_[0] &= ~0x00000004u;
}
void ExperimentsSpecifics::clear_autofill_culling() {
  if (autofill_culling_ != NULL) autofill_culling_->::sync_pb::AutofillCullingFlags::Clear();
  clear_has_autofill_culling();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_favicon_sync() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
void ExperimentsSpecifics::set_has_favicon_sync() {
  _has_bits_[0] |= 0x00000008u;
}
void ExperimentsSpecifics::clear_has_favicon_sync() {
  _has_bits_[0] &= ~0x00000008u;
}
void ExperimentsSpecifics::clear_favicon_sync() {
  if (favicon_sync_ != NULL) favicon_sync_->::sync_pb::FaviconSyncFlags::Clear();
  clear_has_favicon_sync();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_pre_commit_update_avoidance() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
void ExperimentsSpecifics::set_has_pre_commit_update_avoidance() {
  _has_bits_[0] |= 0x00000010u;
}
void ExperimentsSpecifics::clear_has_pre_commit_update_avoidance() {
  _has_bits_[0] &= ~0x00000010u;
}
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();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_gcm_channel() const {
  return (_has_bits_[0] & 0x00000020u) != 0;
}
void ExperimentsSpecifics::set_has_gcm_channel() {
  _has_bits_[0] |= 0x00000020u;
}
void ExperimentsSpecifics::clear_has_gcm_channel() {
  _has_bits_[0] &= ~0x00000020u;
}
void ExperimentsSpecifics::clear_gcm_channel() {
  if (gcm_channel_ != NULL) gcm_channel_->::sync_pb::GcmChannelFlags::Clear();
  clear_has_gcm_channel();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_obsolete_enhanced_bookmarks() const {
  return (_has_bits_[0] & 0x00000040u) != 0;
}
void ExperimentsSpecifics::set_has_obsolete_enhanced_bookmarks() {
  _has_bits_[0] |= 0x00000040u;
}
void ExperimentsSpecifics::clear_has_obsolete_enhanced_bookmarks() {
  _has_bits_[0] &= ~0x00000040u;
}
void ExperimentsSpecifics::clear_obsolete_enhanced_bookmarks() {
  if (obsolete_enhanced_bookmarks_ != NULL) obsolete_enhanced_bookmarks_->::sync_pb::EnhancedBookmarksFlags::Clear();
  clear_has_obsolete_enhanced_bookmarks();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_gcm_invalidations() const {
  return (_has_bits_[0] & 0x00000080u) != 0;
}
void ExperimentsSpecifics::set_has_gcm_invalidations() {
  _has_bits_[0] |= 0x00000080u;
}
void ExperimentsSpecifics::clear_has_gcm_invalidations() {
  _has_bits_[0] &= ~0x00000080u;
}
void ExperimentsSpecifics::clear_gcm_invalidations() {
  if (gcm_invalidations_ != NULL) gcm_invalidations_->::sync_pb::GcmInvalidationsFlags::Clear();
  clear_has_gcm_invalidations();
}
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();
}
::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_;
}
::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;
}
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;
bool ExperimentsSpecifics::has_obsolete_wallet_sync() const {
  return (_has_bits_[0] & 0x00000100u) != 0;
}
void ExperimentsSpecifics::set_has_obsolete_wallet_sync() {
  _has_bits_[0] |= 0x00000100u;
}
void ExperimentsSpecifics::clear_has_obsolete_wallet_sync() {
  _has_bits_[0] &= ~0x00000100u;
}
void ExperimentsSpecifics::clear_obsolete_wallet_sync() {
  if (obsolete_wallet_sync_ != NULL) obsolete_wallet_sync_->::sync_pb::WalletSyncFlags::Clear();
  clear_has_obsolete_wallet_sync();
}
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();
}
::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_;
}
::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;
}
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)