nigori_specifics.pb.cc | Explore in Territory

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

#include "components/sync/protocol/nigori_specifics.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 NigoriKey::NigoriKey(
    ::_pbi::ConstantInitialized): … { … }
struct NigoriKeyDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NigoriKeyDefaultTypeInternal _NigoriKey_default_instance_;
PROTOBUF_CONSTEXPR CrossUserSharingPrivateKey::CrossUserSharingPrivateKey(
    ::_pbi::ConstantInitialized): … { … }
struct CrossUserSharingPrivateKeyDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CrossUserSharingPrivateKeyDefaultTypeInternal _CrossUserSharingPrivateKey_default_instance_;
PROTOBUF_CONSTEXPR CrossUserSharingPublicKey::CrossUserSharingPublicKey(
    ::_pbi::ConstantInitialized): … { … }
struct CrossUserSharingPublicKeyDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CrossUserSharingPublicKeyDefaultTypeInternal _CrossUserSharingPublicKey_default_instance_;
PROTOBUF_CONSTEXPR EncryptionKeys::EncryptionKeys(
    ::_pbi::ConstantInitialized): … { … }
struct EncryptionKeysDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EncryptionKeysDefaultTypeInternal _EncryptionKeys_default_instance_;
PROTOBUF_CONSTEXPR NigoriKeyBag::NigoriKeyBag(
    ::_pbi::ConstantInitialized): … { … }
struct NigoriKeyBagDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NigoriKeyBagDefaultTypeInternal _NigoriKeyBag_default_instance_;
PROTOBUF_CONSTEXPR TrustedVaultAutoUpgradeExperimentGroup::TrustedVaultAutoUpgradeExperimentGroup(
    ::_pbi::ConstantInitialized): … { … }
struct TrustedVaultAutoUpgradeExperimentGroupDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrustedVaultAutoUpgradeExperimentGroupDefaultTypeInternal _TrustedVaultAutoUpgradeExperimentGroup_default_instance_;
PROTOBUF_CONSTEXPR NigoriSpecifics_TrustedVaultDebugInfo::NigoriSpecifics_TrustedVaultDebugInfo(
    ::_pbi::ConstantInitialized): … { … }
struct NigoriSpecifics_TrustedVaultDebugInfoDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NigoriSpecifics_TrustedVaultDebugInfoDefaultTypeInternal _NigoriSpecifics_TrustedVaultDebugInfo_default_instance_;
PROTOBUF_CONSTEXPR NigoriSpecifics::NigoriSpecifics(
    ::_pbi::ConstantInitialized): … { … }
struct NigoriSpecificsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NigoriSpecificsDefaultTypeInternal _NigoriSpecifics_default_instance_;
}  // namespace sync_pb
namespace sync_pb {
bool TrustedVaultAutoUpgradeExperimentGroup_Type_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> TrustedVaultAutoUpgradeExperimentGroup_Type_strings[4] = …;

static const char TrustedVaultAutoUpgradeExperimentGroup_Type_names[] = …;

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

static const int TrustedVaultAutoUpgradeExperimentGroup_Type_entries_by_number[] = …;

const std::string& TrustedVaultAutoUpgradeExperimentGroup_Type_Name(
    TrustedVaultAutoUpgradeExperimentGroup_Type value) { … }
bool TrustedVaultAutoUpgradeExperimentGroup_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TrustedVaultAutoUpgradeExperimentGroup_Type* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr TrustedVaultAutoUpgradeExperimentGroup_Type TrustedVaultAutoUpgradeExperimentGroup::TYPE_UNSPECIFIED;
constexpr TrustedVaultAutoUpgradeExperimentGroup_Type TrustedVaultAutoUpgradeExperimentGroup::TREATMENT;
constexpr TrustedVaultAutoUpgradeExperimentGroup_Type TrustedVaultAutoUpgradeExperimentGroup::CONTROL;
constexpr TrustedVaultAutoUpgradeExperimentGroup_Type TrustedVaultAutoUpgradeExperimentGroup::VALIDATION;
constexpr TrustedVaultAutoUpgradeExperimentGroup_Type TrustedVaultAutoUpgradeExperimentGroup::Type_MIN;
constexpr TrustedVaultAutoUpgradeExperimentGroup_Type TrustedVaultAutoUpgradeExperimentGroup::Type_MAX;
constexpr int TrustedVaultAutoUpgradeExperimentGroup::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool NigoriSpecifics_PassphraseType_IsValid(int value) { … }

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

static const char NigoriSpecifics_PassphraseType_names[] = …;

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

static const int NigoriSpecifics_PassphraseType_entries_by_number[] = …;

const std::string& NigoriSpecifics_PassphraseType_Name(
    NigoriSpecifics_PassphraseType value) { … }
bool NigoriSpecifics_PassphraseType_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NigoriSpecifics_PassphraseType* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::UNKNOWN;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::IMPLICIT_PASSPHRASE;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::KEYSTORE_PASSPHRASE;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::FROZEN_IMPLICIT_PASSPHRASE;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::CUSTOM_PASSPHRASE;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::TRUSTED_VAULT_PASSPHRASE;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::PassphraseType_MIN;
constexpr NigoriSpecifics_PassphraseType NigoriSpecifics::PassphraseType_MAX;
constexpr int NigoriSpecifics::PassphraseType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool NigoriSpecifics_KeyDerivationMethod_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> NigoriSpecifics_KeyDerivationMethod_strings[3] = …;

static const char NigoriSpecifics_KeyDerivationMethod_names[] = …;

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

static const int NigoriSpecifics_KeyDerivationMethod_entries_by_number[] = …;

const std::string& NigoriSpecifics_KeyDerivationMethod_Name(
    NigoriSpecifics_KeyDerivationMethod value) { … }
bool NigoriSpecifics_KeyDerivationMethod_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, NigoriSpecifics_KeyDerivationMethod* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr NigoriSpecifics_KeyDerivationMethod NigoriSpecifics::UNSPECIFIED;
constexpr NigoriSpecifics_KeyDerivationMethod NigoriSpecifics::PBKDF2_HMAC_SHA1_1003;
constexpr NigoriSpecifics_KeyDerivationMethod NigoriSpecifics::SCRYPT_8192_8_11;
constexpr NigoriSpecifics_KeyDerivationMethod NigoriSpecifics::KeyDerivationMethod_MIN;
constexpr NigoriSpecifics_KeyDerivationMethod NigoriSpecifics::KeyDerivationMethod_MAX;
constexpr int NigoriSpecifics::KeyDerivationMethod_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class NigoriKey::_Internal { … };

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

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

NigoriKey::~NigoriKey() { … }

inline void NigoriKey::SharedDtor() { … }

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

void NigoriKey::Clear() { … }

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

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

size_t NigoriKey::ByteSizeLong() const { … }

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

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

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

bool NigoriKey::IsInitialized() const { … }

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

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


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

class CrossUserSharingPrivateKey::_Internal { … };

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

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

CrossUserSharingPrivateKey::~CrossUserSharingPrivateKey() { … }

inline void CrossUserSharingPrivateKey::SharedDtor() { … }

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

void CrossUserSharingPrivateKey::Clear() { … }

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

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

size_t CrossUserSharingPrivateKey::ByteSizeLong() const { … }

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

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

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

bool CrossUserSharingPrivateKey::IsInitialized() const { … }

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

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


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

class CrossUserSharingPublicKey::_Internal { … };

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

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

CrossUserSharingPublicKey::~CrossUserSharingPublicKey() { … }

inline void CrossUserSharingPublicKey::SharedDtor() { … }

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

void CrossUserSharingPublicKey::Clear() { … }

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

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

size_t CrossUserSharingPublicKey::ByteSizeLong() const { … }

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

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

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

bool CrossUserSharingPublicKey::IsInitialized() const { … }

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

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


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

class EncryptionKeys::_Internal { … };

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

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

EncryptionKeys::~EncryptionKeys() { … }

inline void EncryptionKeys::SharedDtor() { … }

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

void EncryptionKeys::Clear() { … }

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

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

size_t EncryptionKeys::ByteSizeLong() const { … }

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

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

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

bool EncryptionKeys::IsInitialized() const { … }

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

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


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

class NigoriKeyBag::_Internal { … };

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

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

NigoriKeyBag::~NigoriKeyBag() { … }

inline void NigoriKeyBag::SharedDtor() { … }

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

void NigoriKeyBag::Clear() { … }

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

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

size_t NigoriKeyBag::ByteSizeLong() const { … }

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

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

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

bool NigoriKeyBag::IsInitialized() const { … }

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

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


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

class TrustedVaultAutoUpgradeExperimentGroup::_Internal { … };

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

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

TrustedVaultAutoUpgradeExperimentGroup::~TrustedVaultAutoUpgradeExperimentGroup() { … }

inline void TrustedVaultAutoUpgradeExperimentGroup::SharedDtor() { … }

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

void TrustedVaultAutoUpgradeExperimentGroup::Clear() { … }

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

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

size_t TrustedVaultAutoUpgradeExperimentGroup::ByteSizeLong() const { … }

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

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

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

bool TrustedVaultAutoUpgradeExperimentGroup::IsInitialized() const { … }

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

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


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

class NigoriSpecifics_TrustedVaultDebugInfo::_Internal { … };

const ::sync_pb::TrustedVaultAutoUpgradeExperimentGroup&
NigoriSpecifics_TrustedVaultDebugInfo::_Internal::auto_upgrade_experiment_group(const NigoriSpecifics_TrustedVaultDebugInfo* msg) { … }
NigoriSpecifics_TrustedVaultDebugInfo::NigoriSpecifics_TrustedVaultDebugInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
NigoriSpecifics_TrustedVaultDebugInfo::NigoriSpecifics_TrustedVaultDebugInfo(const NigoriSpecifics_TrustedVaultDebugInfo& from)
  : … { … }

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

NigoriSpecifics_TrustedVaultDebugInfo::~NigoriSpecifics_TrustedVaultDebugInfo() { … }

inline void NigoriSpecifics_TrustedVaultDebugInfo::SharedDtor() { … }

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

void NigoriSpecifics_TrustedVaultDebugInfo::Clear() { … }

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

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

size_t NigoriSpecifics_TrustedVaultDebugInfo::ByteSizeLong() const { … }

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

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

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

bool NigoriSpecifics_TrustedVaultDebugInfo::IsInitialized() const { … }

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

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


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

class NigoriSpecifics::_Internal { … };

const ::sync_pb::EncryptedData&
NigoriSpecifics::_Internal::encryption_keybag(const NigoriSpecifics* msg) { … }
const ::sync_pb::EncryptedData&
NigoriSpecifics::_Internal::keystore_decryptor_token(const NigoriSpecifics* msg) { … }
const ::sync_pb::NigoriSpecifics_TrustedVaultDebugInfo&
NigoriSpecifics::_Internal::trusted_vault_debug_info(const NigoriSpecifics* msg) { … }
const ::sync_pb::CrossUserSharingPublicKey&
NigoriSpecifics::_Internal::cross_user_sharing_public_key(const NigoriSpecifics* msg) { … }
void NigoriSpecifics::clear_encryption_keybag() { … }
void NigoriSpecifics::clear_keystore_decryptor_token() { … }
NigoriSpecifics::NigoriSpecifics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
NigoriSpecifics::NigoriSpecifics(const NigoriSpecifics& from)
  : … { … }

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

NigoriSpecifics::~NigoriSpecifics() { … }

inline void NigoriSpecifics::SharedDtor() { … }

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

void NigoriSpecifics::Clear() { … }

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

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

size_t NigoriSpecifics::ByteSizeLong() const { … }

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

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

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

bool NigoriSpecifics::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace sync_pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sync_pb::NigoriKey*
Arena::CreateMaybeMessage< ::sync_pb::NigoriKey >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::CrossUserSharingPrivateKey*
Arena::CreateMaybeMessage< ::sync_pb::CrossUserSharingPrivateKey >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::CrossUserSharingPublicKey*
Arena::CreateMaybeMessage< ::sync_pb::CrossUserSharingPublicKey >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::EncryptionKeys*
Arena::CreateMaybeMessage< ::sync_pb::EncryptionKeys >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::NigoriKeyBag*
Arena::CreateMaybeMessage< ::sync_pb::NigoriKeyBag >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::TrustedVaultAutoUpgradeExperimentGroup*
Arena::CreateMaybeMessage< ::sync_pb::TrustedVaultAutoUpgradeExperimentGroup >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::NigoriSpecifics_TrustedVaultDebugInfo*
Arena::CreateMaybeMessage< ::sync_pb::NigoriSpecifics_TrustedVaultDebugInfo >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::NigoriSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::NigoriSpecifics >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
chromium/out/Default/gen/components/sync/protocol/nigori_specifics.pb.cc
