chromium/out/Default/gen/components/sync/protocol/sync.pb.cc

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

#include "components/sync/protocol/sync.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG

_pb;
_pbi;

namespace sync_pb {
PROTOBUF_CONSTEXPR ChromiumExtensionsActivity::ChromiumExtensionsActivity(
    ::_pbi::ConstantInitialized): … { … }
struct ChromiumExtensionsActivityDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromiumExtensionsActivityDefaultTypeInternal _ChromiumExtensionsActivity_default_instance_;
PROTOBUF_CONSTEXPR ClientConfigParams::ClientConfigParams(
    ::_pbi::ConstantInitialized): … { … }
struct ClientConfigParamsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientConfigParamsDefaultTypeInternal _ClientConfigParams_default_instance_;
PROTOBUF_CONSTEXPR CommitMessage::CommitMessage(
    ::_pbi::ConstantInitialized): … { … }
struct CommitMessageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CommitMessageDefaultTypeInternal _CommitMessage_default_instance_;
PROTOBUF_CONSTEXPR GetUpdatesMessage::GetUpdatesMessage(
    ::_pbi::ConstantInitialized): … { … }
struct GetUpdatesMessageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetUpdatesMessageDefaultTypeInternal _GetUpdatesMessage_default_instance_;
PROTOBUF_CONSTEXPR ClearServerDataMessage::ClearServerDataMessage(
    ::_pbi::ConstantInitialized): … { … }
struct ClearServerDataMessageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClearServerDataMessageDefaultTypeInternal _ClearServerDataMessage_default_instance_;
PROTOBUF_CONSTEXPR ClearServerDataResponse::ClearServerDataResponse(
    ::_pbi::ConstantInitialized): … { … }
struct ClearServerDataResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClearServerDataResponseDefaultTypeInternal _ClearServerDataResponse_default_instance_;
PROTOBUF_CONSTEXPR ChipBag::ChipBag(
    ::_pbi::ConstantInitialized): … { … }
struct ChipBagDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChipBagDefaultTypeInternal _ChipBag_default_instance_;
PROTOBUF_CONSTEXPR ClientStatus::ClientStatus(
    ::_pbi::ConstantInitialized): … { … }
struct ClientStatusDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientStatusDefaultTypeInternal _ClientStatus_default_instance_;
PROTOBUF_CONSTEXPR ClientToServerMessage::ClientToServerMessage(
    ::_pbi::ConstantInitialized): … { … }
struct ClientToServerMessageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientToServerMessageDefaultTypeInternal _ClientToServerMessage_default_instance_;
PROTOBUF_CONSTEXPR CommitResponse_EntryResponse_DatatypeSpecificError::CommitResponse_EntryResponse_DatatypeSpecificError(
    ::_pbi::ConstantInitialized): … { … }
struct CommitResponse_EntryResponse_DatatypeSpecificErrorDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CommitResponse_EntryResponse_DatatypeSpecificErrorDefaultTypeInternal _CommitResponse_EntryResponse_DatatypeSpecificError_default_instance_;
PROTOBUF_CONSTEXPR CommitResponse_EntryResponse::CommitResponse_EntryResponse(
    ::_pbi::ConstantInitialized): … { … }
struct CommitResponse_EntryResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CommitResponse_EntryResponseDefaultTypeInternal _CommitResponse_EntryResponse_default_instance_;
PROTOBUF_CONSTEXPR CommitResponse::CommitResponse(
    ::_pbi::ConstantInitialized): … { … }
struct CommitResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CommitResponseDefaultTypeInternal _CommitResponse_default_instance_;
PROTOBUF_CONSTEXPR GetUpdatesResponse::GetUpdatesResponse(
    ::_pbi::ConstantInitialized): … { … }
struct GetUpdatesResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetUpdatesResponseDefaultTypeInternal _GetUpdatesResponse_default_instance_;
PROTOBUF_CONSTEXPR ClientToServerResponse_Error::ClientToServerResponse_Error(
    ::_pbi::ConstantInitialized): … { … }
struct ClientToServerResponse_ErrorDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientToServerResponse_ErrorDefaultTypeInternal _ClientToServerResponse_Error_default_instance_;
PROTOBUF_CONSTEXPR ClientToServerResponse::ClientToServerResponse(
    ::_pbi::ConstantInitialized): … { … }
struct ClientToServerResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientToServerResponseDefaultTypeInternal _ClientToServerResponse_default_instance_;
PROTOBUF_CONSTEXPR EventRequest::EventRequest(
    ::_pbi::ConstantInitialized): … { … }
struct EventRequestDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventRequestDefaultTypeInternal _EventRequest_default_instance_;
PROTOBUF_CONSTEXPR EventResponse::EventResponse(
    ::_pbi::ConstantInitialized): … { … }
struct EventResponseDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventResponseDefaultTypeInternal _EventResponse_default_instance_;
PROTOBUF_CONSTEXPR SyncDisabledEvent::SyncDisabledEvent(
    ::_pbi::ConstantInitialized): … { … }
struct SyncDisabledEventDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SyncDisabledEventDefaultTypeInternal _SyncDisabledEvent_default_instance_;
}  // namespace sync_pb
namespace sync_pb {
bool ClientToServerMessage_Contents_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ClientToServerMessage_Contents_strings[5] = …;

static const char ClientToServerMessage_Contents_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ClientToServerMessage_Contents_entries[] = …;

static const int ClientToServerMessage_Contents_entries_by_number[] = …;

const std::string& ClientToServerMessage_Contents_Name(
    ClientToServerMessage_Contents value) { … }
bool ClientToServerMessage_Contents_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientToServerMessage_Contents* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr ClientToServerMessage_Contents ClientToServerMessage::COMMIT;
constexpr ClientToServerMessage_Contents ClientToServerMessage::GET_UPDATES;
constexpr ClientToServerMessage_Contents ClientToServerMessage::DEPRECATED_3;
constexpr ClientToServerMessage_Contents ClientToServerMessage::DEPRECATED_4;
constexpr ClientToServerMessage_Contents ClientToServerMessage::CLEAR_SERVER_DATA;
constexpr ClientToServerMessage_Contents ClientToServerMessage::Contents_MIN;
constexpr ClientToServerMessage_Contents ClientToServerMessage::Contents_MAX;
constexpr int ClientToServerMessage::Contents_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool CommitResponse_ResponseType_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CommitResponse_ResponseType_strings[6] = …;

static const char CommitResponse_ResponseType_names[] = …;

static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CommitResponse_ResponseType_entries[] = …;

static const int CommitResponse_ResponseType_entries_by_number[] = …;

const std::string& CommitResponse_ResponseType_Name(
    CommitResponse_ResponseType value) { … }
bool CommitResponse_ResponseType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommitResponse_ResponseType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr CommitResponse_ResponseType CommitResponse::SUCCESS;
constexpr CommitResponse_ResponseType CommitResponse::CONFLICT;
constexpr CommitResponse_ResponseType CommitResponse::RETRY;
constexpr CommitResponse_ResponseType CommitResponse::INVALID_MESSAGE;
constexpr CommitResponse_ResponseType CommitResponse::OVER_QUOTA;
constexpr CommitResponse_ResponseType CommitResponse::TRANSIENT_ERROR;
constexpr CommitResponse_ResponseType CommitResponse::ResponseType_MIN;
constexpr CommitResponse_ResponseType CommitResponse::ResponseType_MAX;
constexpr int CommitResponse::ResponseType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class ChromiumExtensionsActivity::_Internal { … };

ChromiumExtensionsActivity::ChromiumExtensionsActivity(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ChromiumExtensionsActivity::ChromiumExtensionsActivity(const ChromiumExtensionsActivity& from)
  : … { … }

inline void ChromiumExtensionsActivity::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ChromiumExtensionsActivity::~ChromiumExtensionsActivity() { … }

inline void ChromiumExtensionsActivity::SharedDtor() { … }

void ChromiumExtensionsActivity::SetCachedSize(int size) const { … }

void ChromiumExtensionsActivity::Clear() { … }

const char* ChromiumExtensionsActivity::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ChromiumExtensionsActivity::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ChromiumExtensionsActivity::ByteSizeLong() const { … }

void ChromiumExtensionsActivity::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ChromiumExtensionsActivity::MergeFrom(const ChromiumExtensionsActivity& from) { … }

void ChromiumExtensionsActivity::CopyFrom(const ChromiumExtensionsActivity& from) { … }

bool ChromiumExtensionsActivity::IsInitialized() const { … }

void ChromiumExtensionsActivity::InternalSwap(ChromiumExtensionsActivity* other) { … }

std::string ChromiumExtensionsActivity::GetTypeName() const { … }


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

class ClientConfigParams::_Internal { … };

ClientConfigParams::ClientConfigParams(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClientConfigParams::ClientConfigParams(const ClientConfigParams& from)
  : … { … }

inline void ClientConfigParams::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClientConfigParams::~ClientConfigParams() { … }

inline void ClientConfigParams::SharedDtor() { … }

void ClientConfigParams::SetCachedSize(int size) const { … }

void ClientConfigParams::Clear() { … }

const char* ClientConfigParams::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClientConfigParams::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClientConfigParams::ByteSizeLong() const { … }

void ClientConfigParams::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClientConfigParams::MergeFrom(const ClientConfigParams& from) { … }

void ClientConfigParams::CopyFrom(const ClientConfigParams& from) { … }

bool ClientConfigParams::IsInitialized() const { … }

void ClientConfigParams::InternalSwap(ClientConfigParams* other) { … }

std::string ClientConfigParams::GetTypeName() const { … }


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

class CommitMessage::_Internal { … };

const ::sync_pb::ClientConfigParams&
CommitMessage::_Internal::config_params(const CommitMessage* msg) { … }
void CommitMessage::clear_entries() { … }
void CommitMessage::clear_client_contexts() { … }
CommitMessage::CommitMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CommitMessage::CommitMessage(const CommitMessage& from)
  : … { … }

inline void CommitMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CommitMessage::~CommitMessage() { … }

inline void CommitMessage::SharedDtor() { … }

void CommitMessage::SetCachedSize(int size) const { … }

void CommitMessage::Clear() { … }

const char* CommitMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CommitMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CommitMessage::ByteSizeLong() const { … }

void CommitMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CommitMessage::MergeFrom(const CommitMessage& from) { … }

void CommitMessage::CopyFrom(const CommitMessage& from) { … }

bool CommitMessage::IsInitialized() const { … }

void CommitMessage::InternalSwap(CommitMessage* other) { … }

std::string CommitMessage::GetTypeName() const { … }


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

class GetUpdatesMessage::_Internal { … };

const ::sync_pb::GetUpdatesCallerInfo&
GetUpdatesMessage::_Internal::caller_info(const GetUpdatesMessage* msg) { … }
void GetUpdatesMessage::clear_caller_info() { … }
void GetUpdatesMessage::clear_from_progress_marker() { … }
void GetUpdatesMessage::clear_client_contexts() { … }
GetUpdatesMessage::GetUpdatesMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
GetUpdatesMessage::GetUpdatesMessage(const GetUpdatesMessage& from)
  : … { … }

inline void GetUpdatesMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

GetUpdatesMessage::~GetUpdatesMessage() { … }

inline void GetUpdatesMessage::SharedDtor() { … }

void GetUpdatesMessage::SetCachedSize(int size) const { … }

void GetUpdatesMessage::Clear() { … }

const char* GetUpdatesMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* GetUpdatesMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t GetUpdatesMessage::ByteSizeLong() const { … }

void GetUpdatesMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void GetUpdatesMessage::MergeFrom(const GetUpdatesMessage& from) { … }

void GetUpdatesMessage::CopyFrom(const GetUpdatesMessage& from) { … }

bool GetUpdatesMessage::IsInitialized() const { … }

void GetUpdatesMessage::InternalSwap(GetUpdatesMessage* other) { … }

std::string GetUpdatesMessage::GetTypeName() const { … }


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

class ClearServerDataMessage::_Internal { … };

ClearServerDataMessage::ClearServerDataMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClearServerDataMessage::ClearServerDataMessage(const ClearServerDataMessage& from)
  : … { … }

inline void ClearServerDataMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClearServerDataMessage::~ClearServerDataMessage() { … }

inline void ClearServerDataMessage::SharedDtor() { … }

void ClearServerDataMessage::SetCachedSize(int size) const { … }

void ClearServerDataMessage::Clear() { … }

const char* ClearServerDataMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClearServerDataMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClearServerDataMessage::ByteSizeLong() const { … }

void ClearServerDataMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClearServerDataMessage::MergeFrom(const ClearServerDataMessage& from) { … }

void ClearServerDataMessage::CopyFrom(const ClearServerDataMessage& from) { … }

bool ClearServerDataMessage::IsInitialized() const { … }

void ClearServerDataMessage::InternalSwap(ClearServerDataMessage* other) { … }

std::string ClearServerDataMessage::GetTypeName() const { … }


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

class ClearServerDataResponse::_Internal { … };

ClearServerDataResponse::ClearServerDataResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClearServerDataResponse::ClearServerDataResponse(const ClearServerDataResponse& from)
  : … { … }

inline void ClearServerDataResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClearServerDataResponse::~ClearServerDataResponse() { … }

inline void ClearServerDataResponse::SharedDtor() { … }

void ClearServerDataResponse::SetCachedSize(int size) const { … }

void ClearServerDataResponse::Clear() { … }

const char* ClearServerDataResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClearServerDataResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClearServerDataResponse::ByteSizeLong() const { … }

void ClearServerDataResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClearServerDataResponse::MergeFrom(const ClearServerDataResponse& from) { … }

void ClearServerDataResponse::CopyFrom(const ClearServerDataResponse& from) { … }

bool ClearServerDataResponse::IsInitialized() const { … }

void ClearServerDataResponse::InternalSwap(ClearServerDataResponse* other) { … }

std::string ClearServerDataResponse::GetTypeName() const { … }


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

class ChipBag::_Internal { … };

ChipBag::ChipBag(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ChipBag::ChipBag(const ChipBag& from)
  : … { … }

inline void ChipBag::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ChipBag::~ChipBag() { … }

inline void ChipBag::SharedDtor() { … }

void ChipBag::SetCachedSize(int size) const { … }

void ChipBag::Clear() { … }

const char* ChipBag::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ChipBag::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ChipBag::ByteSizeLong() const { … }

void ChipBag::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ChipBag::MergeFrom(const ChipBag& from) { … }

void ChipBag::CopyFrom(const ChipBag& from) { … }

bool ChipBag::IsInitialized() const { … }

void ChipBag::InternalSwap(ChipBag* other) { … }

std::string ChipBag::GetTypeName() const { … }


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

class ClientStatus::_Internal { … };

ClientStatus::ClientStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClientStatus::ClientStatus(const ClientStatus& from)
  : … { … }

inline void ClientStatus::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClientStatus::~ClientStatus() { … }

inline void ClientStatus::SharedDtor() { … }

void ClientStatus::SetCachedSize(int size) const { … }

void ClientStatus::Clear() { … }

const char* ClientStatus::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClientStatus::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClientStatus::ByteSizeLong() const { … }

void ClientStatus::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClientStatus::MergeFrom(const ClientStatus& from) { … }

void ClientStatus::CopyFrom(const ClientStatus& from) { … }

bool ClientStatus::IsInitialized() const { … }

void ClientStatus::InternalSwap(ClientStatus* other) { … }

std::string ClientStatus::GetTypeName() const { … }


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

class ClientToServerMessage::_Internal { … };

const ::sync_pb::CommitMessage&
ClientToServerMessage::_Internal::commit(const ClientToServerMessage* msg) { … }
const ::sync_pb::GetUpdatesMessage&
ClientToServerMessage::_Internal::get_updates(const ClientToServerMessage* msg) { … }
const ::sync_pb::DebugInfo&
ClientToServerMessage::_Internal::debug_info(const ClientToServerMessage* msg) { … }
const ::sync_pb::ChipBag&
ClientToServerMessage::_Internal::bag_of_chips(const ClientToServerMessage* msg) { … }
const ::sync_pb::ClientStatus&
ClientToServerMessage::_Internal::client_status(const ClientToServerMessage* msg) { … }
const ::sync_pb::ClearServerDataMessage&
ClientToServerMessage::_Internal::clear_server_data(const ClientToServerMessage* msg) { … }
void ClientToServerMessage::clear_debug_info() { … }
ClientToServerMessage::ClientToServerMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClientToServerMessage::ClientToServerMessage(const ClientToServerMessage& from)
  : … { … }

inline void ClientToServerMessage::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClientToServerMessage::~ClientToServerMessage() { … }

inline void ClientToServerMessage::SharedDtor() { … }

void ClientToServerMessage::SetCachedSize(int size) const { … }

void ClientToServerMessage::Clear() { … }

const char* ClientToServerMessage::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClientToServerMessage::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClientToServerMessage::RequiredFieldsByteSizeFallback() const { … }
size_t ClientToServerMessage::ByteSizeLong() const { … }

void ClientToServerMessage::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClientToServerMessage::MergeFrom(const ClientToServerMessage& from) { … }

void ClientToServerMessage::CopyFrom(const ClientToServerMessage& from) { … }

bool ClientToServerMessage::IsInitialized() const { … }

void ClientToServerMessage::InternalSwap(ClientToServerMessage* other) { … }

std::string ClientToServerMessage::GetTypeName() const { … }


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

class CommitResponse_EntryResponse_DatatypeSpecificError::_Internal { … };

const ::sync_pb::SharingMessageCommitError&
CommitResponse_EntryResponse_DatatypeSpecificError::_Internal::sharing_message_error(const CommitResponse_EntryResponse_DatatypeSpecificError* msg) { … }
const ::sync_pb::OutgoingPasswordSharingInvitationCommitError&
CommitResponse_EntryResponse_DatatypeSpecificError::_Internal::outgoing_password_sharing_invitation_error(const CommitResponse_EntryResponse_DatatypeSpecificError* msg) { … }
void CommitResponse_EntryResponse_DatatypeSpecificError::set_allocated_sharing_message_error(::sync_pb::SharingMessageCommitError* sharing_message_error) { … }
void CommitResponse_EntryResponse_DatatypeSpecificError::clear_sharing_message_error() { … }
void CommitResponse_EntryResponse_DatatypeSpecificError::set_allocated_outgoing_password_sharing_invitation_error(::sync_pb::OutgoingPasswordSharingInvitationCommitError* outgoing_password_sharing_invitation_error) { … }
void CommitResponse_EntryResponse_DatatypeSpecificError::clear_outgoing_password_sharing_invitation_error() { … }
CommitResponse_EntryResponse_DatatypeSpecificError::CommitResponse_EntryResponse_DatatypeSpecificError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CommitResponse_EntryResponse_DatatypeSpecificError::CommitResponse_EntryResponse_DatatypeSpecificError(const CommitResponse_EntryResponse_DatatypeSpecificError& from)
  : … { … }

inline void CommitResponse_EntryResponse_DatatypeSpecificError::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CommitResponse_EntryResponse_DatatypeSpecificError::~CommitResponse_EntryResponse_DatatypeSpecificError() { … }

inline void CommitResponse_EntryResponse_DatatypeSpecificError::SharedDtor() { … }

void CommitResponse_EntryResponse_DatatypeSpecificError::SetCachedSize(int size) const { … }

void CommitResponse_EntryResponse_DatatypeSpecificError::clear_datatype_error() { … }


void CommitResponse_EntryResponse_DatatypeSpecificError::Clear() { … }

const char* CommitResponse_EntryResponse_DatatypeSpecificError::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CommitResponse_EntryResponse_DatatypeSpecificError::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CommitResponse_EntryResponse_DatatypeSpecificError::ByteSizeLong() const { … }

void CommitResponse_EntryResponse_DatatypeSpecificError::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CommitResponse_EntryResponse_DatatypeSpecificError::MergeFrom(const CommitResponse_EntryResponse_DatatypeSpecificError& from) { … }

void CommitResponse_EntryResponse_DatatypeSpecificError::CopyFrom(const CommitResponse_EntryResponse_DatatypeSpecificError& from) { … }

bool CommitResponse_EntryResponse_DatatypeSpecificError::IsInitialized() const { … }

void CommitResponse_EntryResponse_DatatypeSpecificError::InternalSwap(CommitResponse_EntryResponse_DatatypeSpecificError* other) { … }

std::string CommitResponse_EntryResponse_DatatypeSpecificError::GetTypeName() const { … }


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

class CommitResponse_EntryResponse::_Internal { … };

const ::sync_pb::CommitResponse_EntryResponse_DatatypeSpecificError&
CommitResponse_EntryResponse::_Internal::datatype_specific_error(const CommitResponse_EntryResponse* msg) { … }
CommitResponse_EntryResponse::CommitResponse_EntryResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CommitResponse_EntryResponse::CommitResponse_EntryResponse(const CommitResponse_EntryResponse& from)
  : … { … }

inline void CommitResponse_EntryResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CommitResponse_EntryResponse::~CommitResponse_EntryResponse() { … }

inline void CommitResponse_EntryResponse::SharedDtor() { … }

void CommitResponse_EntryResponse::SetCachedSize(int size) const { … }

void CommitResponse_EntryResponse::Clear() { … }

const char* CommitResponse_EntryResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CommitResponse_EntryResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CommitResponse_EntryResponse::ByteSizeLong() const { … }

void CommitResponse_EntryResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CommitResponse_EntryResponse::MergeFrom(const CommitResponse_EntryResponse& from) { … }

void CommitResponse_EntryResponse::CopyFrom(const CommitResponse_EntryResponse& from) { … }

bool CommitResponse_EntryResponse::IsInitialized() const { … }

void CommitResponse_EntryResponse::InternalSwap(CommitResponse_EntryResponse* other) { … }

std::string CommitResponse_EntryResponse::GetTypeName() const { … }


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

class CommitResponse::_Internal { … };

CommitResponse::CommitResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
CommitResponse::CommitResponse(const CommitResponse& from)
  : … { … }

inline void CommitResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

CommitResponse::~CommitResponse() { … }

inline void CommitResponse::SharedDtor() { … }

void CommitResponse::SetCachedSize(int size) const { … }

void CommitResponse::Clear() { … }

const char* CommitResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* CommitResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t CommitResponse::ByteSizeLong() const { … }

void CommitResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void CommitResponse::MergeFrom(const CommitResponse& from) { … }

void CommitResponse::CopyFrom(const CommitResponse& from) { … }

bool CommitResponse::IsInitialized() const { … }

void CommitResponse::InternalSwap(CommitResponse* other) { … }

std::string CommitResponse::GetTypeName() const { … }


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

class GetUpdatesResponse::_Internal { … };

void GetUpdatesResponse::clear_entries() { … }
void GetUpdatesResponse::clear_new_progress_marker() { … }
void GetUpdatesResponse::clear_context_mutations() { … }
GetUpdatesResponse::GetUpdatesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
GetUpdatesResponse::GetUpdatesResponse(const GetUpdatesResponse& from)
  : … { … }

inline void GetUpdatesResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

GetUpdatesResponse::~GetUpdatesResponse() { … }

inline void GetUpdatesResponse::SharedDtor() { … }

void GetUpdatesResponse::SetCachedSize(int size) const { … }

void GetUpdatesResponse::Clear() { … }

const char* GetUpdatesResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* GetUpdatesResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t GetUpdatesResponse::ByteSizeLong() const { … }

void GetUpdatesResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void GetUpdatesResponse::MergeFrom(const GetUpdatesResponse& from) { … }

void GetUpdatesResponse::CopyFrom(const GetUpdatesResponse& from) { … }

bool GetUpdatesResponse::IsInitialized() const { … }

void GetUpdatesResponse::InternalSwap(GetUpdatesResponse* other) { … }

std::string GetUpdatesResponse::GetTypeName() const { … }


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

class ClientToServerResponse_Error::_Internal { … };

ClientToServerResponse_Error::ClientToServerResponse_Error(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClientToServerResponse_Error::ClientToServerResponse_Error(const ClientToServerResponse_Error& from)
  : … { … }

inline void ClientToServerResponse_Error::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClientToServerResponse_Error::~ClientToServerResponse_Error() { … }

inline void ClientToServerResponse_Error::SharedDtor() { … }

void ClientToServerResponse_Error::SetCachedSize(int size) const { … }

void ClientToServerResponse_Error::Clear() { … }

const char* ClientToServerResponse_Error::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClientToServerResponse_Error::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClientToServerResponse_Error::ByteSizeLong() const { … }

void ClientToServerResponse_Error::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClientToServerResponse_Error::MergeFrom(const ClientToServerResponse_Error& from) { … }

void ClientToServerResponse_Error::CopyFrom(const ClientToServerResponse_Error& from) { … }

bool ClientToServerResponse_Error::IsInitialized() const { … }

void ClientToServerResponse_Error::InternalSwap(ClientToServerResponse_Error* other) { … }

std::string ClientToServerResponse_Error::GetTypeName() const { … }


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

class ClientToServerResponse::_Internal { … };

const ::sync_pb::CommitResponse&
ClientToServerResponse::_Internal::commit(const ClientToServerResponse* msg) { … }
const ::sync_pb::GetUpdatesResponse&
ClientToServerResponse::_Internal::get_updates(const ClientToServerResponse* msg) { … }
const ::sync_pb::ClientCommand&
ClientToServerResponse::_Internal::client_command(const ClientToServerResponse* msg) { … }
const ::sync_pb::ClientToServerResponse_Error&
ClientToServerResponse::_Internal::error(const ClientToServerResponse* msg) { … }
const ::sync_pb::ChipBag&
ClientToServerResponse::_Internal::new_bag_of_chips(const ClientToServerResponse* msg) { … }
const ::sync_pb::ClearServerDataResponse&
ClientToServerResponse::_Internal::clear_server_data(const ClientToServerResponse* msg) { … }
void ClientToServerResponse::clear_client_command() { … }
ClientToServerResponse::ClientToServerResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
ClientToServerResponse::ClientToServerResponse(const ClientToServerResponse& from)
  : … { … }

inline void ClientToServerResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

ClientToServerResponse::~ClientToServerResponse() { … }

inline void ClientToServerResponse::SharedDtor() { … }

void ClientToServerResponse::SetCachedSize(int size) const { … }

void ClientToServerResponse::Clear() { … }

const char* ClientToServerResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* ClientToServerResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t ClientToServerResponse::ByteSizeLong() const { … }

void ClientToServerResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void ClientToServerResponse::MergeFrom(const ClientToServerResponse& from) { … }

void ClientToServerResponse::CopyFrom(const ClientToServerResponse& from) { … }

bool ClientToServerResponse::IsInitialized() const { … }

void ClientToServerResponse::InternalSwap(ClientToServerResponse* other) { … }

std::string ClientToServerResponse::GetTypeName() const { … }


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

class EventRequest::_Internal { … };

const ::sync_pb::SyncDisabledEvent&
EventRequest::_Internal::sync_disabled(const EventRequest* msg) { … }
EventRequest::EventRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EventRequest::EventRequest(const EventRequest& from)
  : … { … }

inline void EventRequest::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

EventRequest::~EventRequest() { … }

inline void EventRequest::SharedDtor() { … }

void EventRequest::SetCachedSize(int size) const { … }

void EventRequest::Clear() { … }

const char* EventRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* EventRequest::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t EventRequest::ByteSizeLong() const { … }

void EventRequest::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void EventRequest::MergeFrom(const EventRequest& from) { … }

void EventRequest::CopyFrom(const EventRequest& from) { … }

bool EventRequest::IsInitialized() const { … }

void EventRequest::InternalSwap(EventRequest* other) { … }

std::string EventRequest::GetTypeName() const { … }


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

class EventResponse::_Internal { … };

EventResponse::EventResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
EventResponse::EventResponse(const EventResponse& from)
  : … { … }

inline void EventResponse::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

EventResponse::~EventResponse() { … }

inline void EventResponse::SharedDtor() { … }

void EventResponse::SetCachedSize(int size) const { … }

void EventResponse::Clear() { … }

const char* EventResponse::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* EventResponse::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t EventResponse::ByteSizeLong() const { … }

void EventResponse::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void EventResponse::MergeFrom(const EventResponse& from) { … }

void EventResponse::CopyFrom(const EventResponse& from) { … }

bool EventResponse::IsInitialized() const { … }

void EventResponse::InternalSwap(EventResponse* other) { … }

std::string EventResponse::GetTypeName() const { … }


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

class SyncDisabledEvent::_Internal { … };

SyncDisabledEvent::SyncDisabledEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
SyncDisabledEvent::SyncDisabledEvent(const SyncDisabledEvent& from)
  : … { … }

inline void SyncDisabledEvent::SharedCtor(
    ::_pb::Arena* arena, bool is_message_owned) { … }

SyncDisabledEvent::~SyncDisabledEvent() { … }

inline void SyncDisabledEvent::SharedDtor() { … }

void SyncDisabledEvent::SetCachedSize(int size) const { … }

void SyncDisabledEvent::Clear() { … }

const char* SyncDisabledEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { … }

uint8_t* SyncDisabledEvent::_InternalSerialize(
    uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { … }

size_t SyncDisabledEvent::ByteSizeLong() const { … }

void SyncDisabledEvent::CheckTypeAndMergeFrom(
    const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) { … }

void SyncDisabledEvent::MergeFrom(const SyncDisabledEvent& from) { … }

void SyncDisabledEvent::CopyFrom(const SyncDisabledEvent& from) { … }

bool SyncDisabledEvent::IsInitialized() const { … }

void SyncDisabledEvent::InternalSwap(SyncDisabledEvent* other) { … }

std::string SyncDisabledEvent::GetTypeName() const { … }


// @@protoc_insertion_point(namespace_scope)
}  // namespace sync_pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sync_pb::ChromiumExtensionsActivity*
Arena::CreateMaybeMessage< ::sync_pb::ChromiumExtensionsActivity >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClientConfigParams*
Arena::CreateMaybeMessage< ::sync_pb::ClientConfigParams >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::CommitMessage*
Arena::CreateMaybeMessage< ::sync_pb::CommitMessage >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::GetUpdatesMessage*
Arena::CreateMaybeMessage< ::sync_pb::GetUpdatesMessage >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClearServerDataMessage*
Arena::CreateMaybeMessage< ::sync_pb::ClearServerDataMessage >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClearServerDataResponse*
Arena::CreateMaybeMessage< ::sync_pb::ClearServerDataResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ChipBag*
Arena::CreateMaybeMessage< ::sync_pb::ChipBag >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClientStatus*
Arena::CreateMaybeMessage< ::sync_pb::ClientStatus >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClientToServerMessage*
Arena::CreateMaybeMessage< ::sync_pb::ClientToServerMessage >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::CommitResponse_EntryResponse_DatatypeSpecificError*
Arena::CreateMaybeMessage< ::sync_pb::CommitResponse_EntryResponse_DatatypeSpecificError >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::CommitResponse_EntryResponse*
Arena::CreateMaybeMessage< ::sync_pb::CommitResponse_EntryResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::CommitResponse*
Arena::CreateMaybeMessage< ::sync_pb::CommitResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::GetUpdatesResponse*
Arena::CreateMaybeMessage< ::sync_pb::GetUpdatesResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClientToServerResponse_Error*
Arena::CreateMaybeMessage< ::sync_pb::ClientToServerResponse_Error >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::ClientToServerResponse*
Arena::CreateMaybeMessage< ::sync_pb::ClientToServerResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::EventRequest*
Arena::CreateMaybeMessage< ::sync_pb::EventRequest >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::EventResponse*
Arena::CreateMaybeMessage< ::sync_pb::EventResponse >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::SyncDisabledEvent*
Arena::CreateMaybeMessage< ::sync_pb::SyncDisabledEvent >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>