user_event_specifics.pb.cc | Explore in Territory

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

#include "components/sync/protocol/user_event_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 UserEventSpecifics_Test::UserEventSpecifics_Test(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecifics_TestDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecifics_TestDefaultTypeInternal _UserEventSpecifics_Test_default_instance_;
PROTOBUF_CONSTEXPR UserEventSpecifics_LanguageDetection_Language::UserEventSpecifics_LanguageDetection_Language(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecifics_LanguageDetection_LanguageDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecifics_LanguageDetection_LanguageDefaultTypeInternal _UserEventSpecifics_LanguageDetection_Language_default_instance_;
PROTOBUF_CONSTEXPR UserEventSpecifics_LanguageDetection::UserEventSpecifics_LanguageDetection(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecifics_LanguageDetectionDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecifics_LanguageDetectionDefaultTypeInternal _UserEventSpecifics_LanguageDetection_default_instance_;
PROTOBUF_CONSTEXPR UserEventSpecifics_Translation::UserEventSpecifics_Translation(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecifics_TranslationDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecifics_TranslationDefaultTypeInternal _UserEventSpecifics_Translation_default_instance_;
PROTOBUF_CONSTEXPR UserEventSpecifics_GaiaPasswordCaptured::UserEventSpecifics_GaiaPasswordCaptured(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecifics_GaiaPasswordCapturedDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecifics_GaiaPasswordCapturedDefaultTypeInternal _UserEventSpecifics_GaiaPasswordCaptured_default_instance_;
PROTOBUF_CONSTEXPR UserEventSpecifics_FlocIdComputed::UserEventSpecifics_FlocIdComputed(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecifics_FlocIdComputedDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecifics_FlocIdComputedDefaultTypeInternal _UserEventSpecifics_FlocIdComputed_default_instance_;
PROTOBUF_CONSTEXPR UserEventSpecifics::UserEventSpecifics(
    ::_pbi::ConstantInitialized): … { … }
struct UserEventSpecificsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UserEventSpecificsDefaultTypeInternal _UserEventSpecifics_default_instance_;
}  // namespace sync_pb
namespace sync_pb {
bool UserEventSpecifics_Translation_Interaction_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> UserEventSpecifics_Translation_Interaction_strings[10] = …;

static const char UserEventSpecifics_Translation_Interaction_names[] = …;

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

static const int UserEventSpecifics_Translation_Interaction_entries_by_number[] = …;

const std::string& UserEventSpecifics_Translation_Interaction_Name(
    UserEventSpecifics_Translation_Interaction value) { … }
bool UserEventSpecifics_Translation_Interaction_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UserEventSpecifics_Translation_Interaction* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::UNKNOWN;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::ACCEPT;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::DECLINE;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::IGNORED;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::DISMISSED;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::MANUAL;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::TRANSLATION_REVERTED;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::AUTO_TRANSLATION_BY_PREF;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::AUTO_TRANSLATION_BY_LINK;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::INITIALIZATION_ERROR;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::Interaction_MIN;
constexpr UserEventSpecifics_Translation_Interaction UserEventSpecifics_Translation::Interaction_MAX;
constexpr int UserEventSpecifics_Translation::Interaction_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool UserEventSpecifics_GaiaPasswordCaptured_EventTrigger_IsValid(int value) { … }

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

static const char UserEventSpecifics_GaiaPasswordCaptured_EventTrigger_names[] = …;

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

static const int UserEventSpecifics_GaiaPasswordCaptured_EventTrigger_entries_by_number[] = …;

const std::string& UserEventSpecifics_GaiaPasswordCaptured_EventTrigger_Name(
    UserEventSpecifics_GaiaPasswordCaptured_EventTrigger value) { … }
bool UserEventSpecifics_GaiaPasswordCaptured_EventTrigger_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UserEventSpecifics_GaiaPasswordCaptured_EventTrigger* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr UserEventSpecifics_GaiaPasswordCaptured_EventTrigger UserEventSpecifics_GaiaPasswordCaptured::UNSPECIFIED;
constexpr UserEventSpecifics_GaiaPasswordCaptured_EventTrigger UserEventSpecifics_GaiaPasswordCaptured::USER_LOGGED_IN;
constexpr UserEventSpecifics_GaiaPasswordCaptured_EventTrigger UserEventSpecifics_GaiaPasswordCaptured::EXPIRED_28D_TIMER;
constexpr UserEventSpecifics_GaiaPasswordCaptured_EventTrigger UserEventSpecifics_GaiaPasswordCaptured::EventTrigger_MIN;
constexpr UserEventSpecifics_GaiaPasswordCaptured_EventTrigger UserEventSpecifics_GaiaPasswordCaptured::EventTrigger_MAX;
constexpr int UserEventSpecifics_GaiaPasswordCaptured::EventTrigger_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool UserEventSpecifics_FlocIdComputed_EventTrigger_IsValid(int value) { … }

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

static const char UserEventSpecifics_FlocIdComputed_EventTrigger_names[] = …;

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

static const int UserEventSpecifics_FlocIdComputed_EventTrigger_entries_by_number[] = …;

const std::string& UserEventSpecifics_FlocIdComputed_EventTrigger_Name(
    UserEventSpecifics_FlocIdComputed_EventTrigger value) { … }
bool UserEventSpecifics_FlocIdComputed_EventTrigger_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, UserEventSpecifics_FlocIdComputed_EventTrigger* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr UserEventSpecifics_FlocIdComputed_EventTrigger UserEventSpecifics_FlocIdComputed::UNSPECIFIED;
constexpr UserEventSpecifics_FlocIdComputed_EventTrigger UserEventSpecifics_FlocIdComputed::NEW;
constexpr UserEventSpecifics_FlocIdComputed_EventTrigger UserEventSpecifics_FlocIdComputed::REFRESHED;
constexpr UserEventSpecifics_FlocIdComputed_EventTrigger UserEventSpecifics_FlocIdComputed::HISTORY_DELETE;
constexpr UserEventSpecifics_FlocIdComputed_EventTrigger UserEventSpecifics_FlocIdComputed::EventTrigger_MIN;
constexpr UserEventSpecifics_FlocIdComputed_EventTrigger UserEventSpecifics_FlocIdComputed::EventTrigger_MAX;
constexpr int UserEventSpecifics_FlocIdComputed::EventTrigger_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class UserEventSpecifics_Test::_Internal { … };

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

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

UserEventSpecifics_Test::~UserEventSpecifics_Test() { … }

inline void UserEventSpecifics_Test::SharedDtor() { … }

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

void UserEventSpecifics_Test::Clear() { … }

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

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

size_t UserEventSpecifics_Test::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics_Test::IsInitialized() const { … }

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

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


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

class UserEventSpecifics_LanguageDetection_Language::_Internal { … };

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

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

UserEventSpecifics_LanguageDetection_Language::~UserEventSpecifics_LanguageDetection_Language() { … }

inline void UserEventSpecifics_LanguageDetection_Language::SharedDtor() { … }

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

void UserEventSpecifics_LanguageDetection_Language::Clear() { … }

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

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

size_t UserEventSpecifics_LanguageDetection_Language::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics_LanguageDetection_Language::IsInitialized() const { … }

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

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


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

class UserEventSpecifics_LanguageDetection::_Internal { … };

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

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

UserEventSpecifics_LanguageDetection::~UserEventSpecifics_LanguageDetection() { … }

inline void UserEventSpecifics_LanguageDetection::SharedDtor() { … }

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

void UserEventSpecifics_LanguageDetection::Clear() { … }

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

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

size_t UserEventSpecifics_LanguageDetection::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics_LanguageDetection::IsInitialized() const { … }

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

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


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

class UserEventSpecifics_Translation::_Internal { … };

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

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

UserEventSpecifics_Translation::~UserEventSpecifics_Translation() { … }

inline void UserEventSpecifics_Translation::SharedDtor() { … }

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

void UserEventSpecifics_Translation::Clear() { … }

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

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

size_t UserEventSpecifics_Translation::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics_Translation::IsInitialized() const { … }

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

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


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

class UserEventSpecifics_GaiaPasswordCaptured::_Internal { … };

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

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

UserEventSpecifics_GaiaPasswordCaptured::~UserEventSpecifics_GaiaPasswordCaptured() { … }

inline void UserEventSpecifics_GaiaPasswordCaptured::SharedDtor() { … }

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

void UserEventSpecifics_GaiaPasswordCaptured::Clear() { … }

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

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

size_t UserEventSpecifics_GaiaPasswordCaptured::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics_GaiaPasswordCaptured::IsInitialized() const { … }

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

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


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

class UserEventSpecifics_FlocIdComputed::_Internal { … };

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

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

UserEventSpecifics_FlocIdComputed::~UserEventSpecifics_FlocIdComputed() { … }

inline void UserEventSpecifics_FlocIdComputed::SharedDtor() { … }

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

void UserEventSpecifics_FlocIdComputed::Clear() { … }

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

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

size_t UserEventSpecifics_FlocIdComputed::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics_FlocIdComputed::IsInitialized() const { … }

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

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


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

class UserEventSpecifics::_Internal { … };

const ::sync_pb::UserEventSpecifics_Test&
UserEventSpecifics::_Internal::test_event(const UserEventSpecifics* msg) { … }
const ::sync_pb::UserEventSpecifics_LanguageDetection&
UserEventSpecifics::_Internal::language_detection_event(const UserEventSpecifics* msg) { … }
const ::sync_pb::UserEventSpecifics_Translation&
UserEventSpecifics::_Internal::translation_event(const UserEventSpecifics* msg) { … }
const ::sync_pb::GaiaPasswordReuse&
UserEventSpecifics::_Internal::gaia_password_reuse_event(const UserEventSpecifics* msg) { … }
const ::sync_pb::UserEventSpecifics_GaiaPasswordCaptured&
UserEventSpecifics::_Internal::gaia_password_captured_event(const UserEventSpecifics* msg) { … }
const ::sync_pb::UserEventSpecifics_FlocIdComputed&
UserEventSpecifics::_Internal::floc_id_computed_event(const UserEventSpecifics* msg) { … }
void UserEventSpecifics::set_allocated_test_event(::sync_pb::UserEventSpecifics_Test* test_event) { … }
void UserEventSpecifics::set_allocated_language_detection_event(::sync_pb::UserEventSpecifics_LanguageDetection* language_detection_event) { … }
void UserEventSpecifics::set_allocated_translation_event(::sync_pb::UserEventSpecifics_Translation* translation_event) { … }
void UserEventSpecifics::set_allocated_gaia_password_reuse_event(::sync_pb::GaiaPasswordReuse* gaia_password_reuse_event) { … }
void UserEventSpecifics::clear_gaia_password_reuse_event() { … }
void UserEventSpecifics::set_allocated_gaia_password_captured_event(::sync_pb::UserEventSpecifics_GaiaPasswordCaptured* gaia_password_captured_event) { … }
void UserEventSpecifics::set_allocated_floc_id_computed_event(::sync_pb::UserEventSpecifics_FlocIdComputed* floc_id_computed_event) { … }
UserEventSpecifics::UserEventSpecifics(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
UserEventSpecifics::UserEventSpecifics(const UserEventSpecifics& from)
  : … { … }

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

UserEventSpecifics::~UserEventSpecifics() { … }

inline void UserEventSpecifics::SharedDtor() { … }

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

void UserEventSpecifics::clear_event() { … }


void UserEventSpecifics::Clear() { … }

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

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

size_t UserEventSpecifics::ByteSizeLong() const { … }

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

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

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

bool UserEventSpecifics::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace sync_pb
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics_Test*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics_Test >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics_LanguageDetection_Language*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics_LanguageDetection_Language >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics_LanguageDetection*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics_LanguageDetection >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics_Translation*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics_Translation >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics_GaiaPasswordCaptured*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics_GaiaPasswordCaptured >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics_FlocIdComputed*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics_FlocIdComputed >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::sync_pb::UserEventSpecifics*
Arena::CreateMaybeMessage< ::sync_pb::UserEventSpecifics >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

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