v8.pb.cc | Explore in Territory

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: protos/perfetto/trace/chrome/v8.proto

#include "protos/perfetto/trace/chrome/v8.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 perfetto {
namespace protos {
PROTOBUF_CONSTEXPR V8String::V8String(
    ::_pbi::ConstantInitialized): … { … }
struct V8StringDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8StringDefaultTypeInternal _V8String_default_instance_;
PROTOBUF_CONSTEXPR InternedV8String::InternedV8String(
    ::_pbi::ConstantInitialized): … { … }
struct InternedV8StringDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8StringDefaultTypeInternal _InternedV8String_default_instance_;
PROTOBUF_CONSTEXPR InternedV8JsScript::InternedV8JsScript(
    ::_pbi::ConstantInitialized): … { … }
struct InternedV8JsScriptDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8JsScriptDefaultTypeInternal _InternedV8JsScript_default_instance_;
PROTOBUF_CONSTEXPR InternedV8WasmScript::InternedV8WasmScript(
    ::_pbi::ConstantInitialized): … { … }
struct InternedV8WasmScriptDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8WasmScriptDefaultTypeInternal _InternedV8WasmScript_default_instance_;
PROTOBUF_CONSTEXPR InternedV8JsFunction::InternedV8JsFunction(
    ::_pbi::ConstantInitialized): … { … }
struct InternedV8JsFunctionDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8JsFunctionDefaultTypeInternal _InternedV8JsFunction_default_instance_;
PROTOBUF_CONSTEXPR InternedV8Isolate_CodeRange::InternedV8Isolate_CodeRange(
    ::_pbi::ConstantInitialized): … { … }
struct InternedV8Isolate_CodeRangeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8Isolate_CodeRangeDefaultTypeInternal _InternedV8Isolate_CodeRange_default_instance_;
PROTOBUF_CONSTEXPR InternedV8Isolate::InternedV8Isolate(
    ::_pbi::ConstantInitialized): … { … }
struct InternedV8IsolateDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InternedV8IsolateDefaultTypeInternal _InternedV8Isolate_default_instance_;
PROTOBUF_CONSTEXPR V8JsCode::V8JsCode(
    ::_pbi::ConstantInitialized): … { … }
struct V8JsCodeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8JsCodeDefaultTypeInternal _V8JsCode_default_instance_;
PROTOBUF_CONSTEXPR V8InternalCode::V8InternalCode(
    ::_pbi::ConstantInitialized): … { … }
struct V8InternalCodeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8InternalCodeDefaultTypeInternal _V8InternalCode_default_instance_;
PROTOBUF_CONSTEXPR V8WasmCode::V8WasmCode(
    ::_pbi::ConstantInitialized): … { … }
struct V8WasmCodeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8WasmCodeDefaultTypeInternal _V8WasmCode_default_instance_;
PROTOBUF_CONSTEXPR V8RegExpCode::V8RegExpCode(
    ::_pbi::ConstantInitialized): … { … }
struct V8RegExpCodeDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8RegExpCodeDefaultTypeInternal _V8RegExpCode_default_instance_;
PROTOBUF_CONSTEXPR V8CodeMove::V8CodeMove(
    ::_pbi::ConstantInitialized): … { … }
struct V8CodeMoveDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8CodeMoveDefaultTypeInternal _V8CodeMove_default_instance_;
PROTOBUF_CONSTEXPR V8CodeDefaults::V8CodeDefaults(
    ::_pbi::ConstantInitialized): … { … }
struct V8CodeDefaultsDefaultTypeInternal { … };
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 V8CodeDefaultsDefaultTypeInternal _V8CodeDefaults_default_instance_;
}  // namespace protos
}  // namespace perfetto
namespace perfetto {
namespace protos {
bool InternedV8JsScript_Type_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> InternedV8JsScript_Type_strings[7] = …;

static const char InternedV8JsScript_Type_names[] = …;

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

static const int InternedV8JsScript_Type_entries_by_number[] = …;

const std::string& InternedV8JsScript_Type_Name(
    InternedV8JsScript_Type value) { … }
bool InternedV8JsScript_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsScript_Type* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_UNKNOWN;
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_NORMAL;
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_EVAL;
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_MODULE;
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_NATIVE;
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_EXTENSION;
constexpr InternedV8JsScript_Type InternedV8JsScript::TYPE_INSPECTOR;
constexpr InternedV8JsScript_Type InternedV8JsScript::Type_MIN;
constexpr InternedV8JsScript_Type InternedV8JsScript::Type_MAX;
constexpr int InternedV8JsScript::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool InternedV8JsFunction_Kind_IsValid(int value) { … }

static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> InternedV8JsFunction_Kind_strings[28] = …;

static const char InternedV8JsFunction_Kind_names[] = …;

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

static const int InternedV8JsFunction_Kind_entries_by_number[] = …;

const std::string& InternedV8JsFunction_Kind_Name(
    InternedV8JsFunction_Kind value) { … }
bool InternedV8JsFunction_Kind_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsFunction_Kind* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_UNKNOWN;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_NORMAL_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_MODULE;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_MODULE;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_BASE_CONSTRUCTOR;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_DEFAULT_BASE_CONSTRUCTOR;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_DEFAULT_DERIVED_CONSTRUCTOR;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_DERIVED_CONSTRUCTOR;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_GETTER_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_GETTER_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_SETTER_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_SETTER_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ARROW_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_ARROW_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_CONCISE_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_ASYNC_CONCISE_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_CONCISE_GENERATOR_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_ASYNC_GENERATOR_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_GENERATOR_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CONCISE_GENERATOR_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_CONCISE_GENERATOR_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CONCISE_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_STATIC_CONCISE_METHOD;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_CLASS_STATIC_INITIALIZER_FUNCTION;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::KIND_INVALID;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::Kind_MIN;
constexpr InternedV8JsFunction_Kind InternedV8JsFunction::Kind_MAX;
constexpr int InternedV8JsFunction::Kind_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool V8JsCode_Tier_IsValid(int value) { … }

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

static const char V8JsCode_Tier_names[] = …;

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

static const int V8JsCode_Tier_entries_by_number[] = …;

const std::string& V8JsCode_Tier_Name(
    V8JsCode_Tier value) { … }
bool V8JsCode_Tier_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8JsCode_Tier* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr V8JsCode_Tier V8JsCode::TIER_UNKNOWN;
constexpr V8JsCode_Tier V8JsCode::TIER_IGNITION;
constexpr V8JsCode_Tier V8JsCode::TIER_SPARKPLUG;
constexpr V8JsCode_Tier V8JsCode::TIER_MAGLEV;
constexpr V8JsCode_Tier V8JsCode::TIER_TURBOSHAFT;
constexpr V8JsCode_Tier V8JsCode::TIER_TURBOFAN;
constexpr V8JsCode_Tier V8JsCode::Tier_MIN;
constexpr V8JsCode_Tier V8JsCode::Tier_MAX;
constexpr int V8JsCode::Tier_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool V8InternalCode_Type_IsValid(int value) { … }

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

static const char V8InternalCode_Type_names[] = …;

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

static const int V8InternalCode_Type_entries_by_number[] = …;

const std::string& V8InternalCode_Type_Name(
    V8InternalCode_Type value) { … }
bool V8InternalCode_Type_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8InternalCode_Type* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr V8InternalCode_Type V8InternalCode::TYPE_UNKNOWN;
constexpr V8InternalCode_Type V8InternalCode::TYPE_BYTECODE_HANDLER;
constexpr V8InternalCode_Type V8InternalCode::TYPE_FOR_TESTING;
constexpr V8InternalCode_Type V8InternalCode::TYPE_BUILTIN;
constexpr V8InternalCode_Type V8InternalCode::TYPE_WASM_FUNCTION;
constexpr V8InternalCode_Type V8InternalCode::TYPE_WASM_TO_CAPI_FUNCTION;
constexpr V8InternalCode_Type V8InternalCode::TYPE_WASM_TO_JS_FUNCTION;
constexpr V8InternalCode_Type V8InternalCode::TYPE_JS_TO_WASM_FUNCTION;
constexpr V8InternalCode_Type V8InternalCode::TYPE_JS_TO_JS_FUNCTION;
constexpr V8InternalCode_Type V8InternalCode::TYPE_C_WASM_ENTRY;
constexpr V8InternalCode_Type V8InternalCode::Type_MIN;
constexpr V8InternalCode_Type V8InternalCode::Type_MAX;
constexpr int V8InternalCode::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
bool V8WasmCode_Tier_IsValid(int value) { … }

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

static const char V8WasmCode_Tier_names[] = …;

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

static const int V8WasmCode_Tier_entries_by_number[] = …;

const std::string& V8WasmCode_Tier_Name(
    V8WasmCode_Tier value) { … }
bool V8WasmCode_Tier_Parse(
    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8WasmCode_Tier* value) { … }
#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
constexpr V8WasmCode_Tier V8WasmCode::TIER_UNKNOWN;
constexpr V8WasmCode_Tier V8WasmCode::TIER_LIFTOFF;
constexpr V8WasmCode_Tier V8WasmCode::TIER_TURBOFAN;
constexpr V8WasmCode_Tier V8WasmCode::Tier_MIN;
constexpr V8WasmCode_Tier V8WasmCode::Tier_MAX;
constexpr int V8WasmCode::Tier_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))

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

class V8String::_Internal { … };

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

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

V8String::~V8String() { … }

inline void V8String::SharedDtor() { … }

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

void V8String::clear_encoded_string() { … }


void V8String::Clear() { … }

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

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

size_t V8String::ByteSizeLong() const { … }

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

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

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

bool V8String::IsInitialized() const { … }

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

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


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

class InternedV8String::_Internal { … };

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

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

InternedV8String::~InternedV8String() { … }

inline void InternedV8String::SharedDtor() { … }

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

void InternedV8String::clear_encoded_string() { … }


void InternedV8String::Clear() { … }

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

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

size_t InternedV8String::ByteSizeLong() const { … }

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

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

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

bool InternedV8String::IsInitialized() const { … }

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

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


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

class InternedV8JsScript::_Internal { … };

const ::perfetto::protos::V8String&
InternedV8JsScript::_Internal::name(const InternedV8JsScript* msg) { … }
const ::perfetto::protos::V8String&
InternedV8JsScript::_Internal::source(const InternedV8JsScript* msg) { … }
InternedV8JsScript::InternedV8JsScript(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
InternedV8JsScript::InternedV8JsScript(const InternedV8JsScript& from)
  : … { … }

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

InternedV8JsScript::~InternedV8JsScript() { … }

inline void InternedV8JsScript::SharedDtor() { … }

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

void InternedV8JsScript::Clear() { … }

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

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

size_t InternedV8JsScript::ByteSizeLong() const { … }

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

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

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

bool InternedV8JsScript::IsInitialized() const { … }

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

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


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

class InternedV8WasmScript::_Internal { … };

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

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

InternedV8WasmScript::~InternedV8WasmScript() { … }

inline void InternedV8WasmScript::SharedDtor() { … }

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

void InternedV8WasmScript::Clear() { … }

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

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

size_t InternedV8WasmScript::ByteSizeLong() const { … }

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

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

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

bool InternedV8WasmScript::IsInitialized() const { … }

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

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


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

class InternedV8JsFunction::_Internal { … };

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

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

InternedV8JsFunction::~InternedV8JsFunction() { … }

inline void InternedV8JsFunction::SharedDtor() { … }

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

void InternedV8JsFunction::Clear() { … }

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

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

size_t InternedV8JsFunction::ByteSizeLong() const { … }

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

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

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

bool InternedV8JsFunction::IsInitialized() const { … }

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

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


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

class InternedV8Isolate_CodeRange::_Internal { … };

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

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

InternedV8Isolate_CodeRange::~InternedV8Isolate_CodeRange() { … }

inline void InternedV8Isolate_CodeRange::SharedDtor() { … }

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

void InternedV8Isolate_CodeRange::Clear() { … }

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

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

size_t InternedV8Isolate_CodeRange::ByteSizeLong() const { … }

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

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

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

bool InternedV8Isolate_CodeRange::IsInitialized() const { … }

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

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


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

class InternedV8Isolate::_Internal { … };

const ::perfetto::protos::InternedV8Isolate_CodeRange&
InternedV8Isolate::_Internal::code_range(const InternedV8Isolate* msg) { … }
InternedV8Isolate::InternedV8Isolate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
InternedV8Isolate::InternedV8Isolate(const InternedV8Isolate& from)
  : … { … }

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

InternedV8Isolate::~InternedV8Isolate() { … }

inline void InternedV8Isolate::SharedDtor() { … }

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

void InternedV8Isolate::Clear() { … }

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

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

size_t InternedV8Isolate::ByteSizeLong() const { … }

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

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

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

bool InternedV8Isolate::IsInitialized() const { … }

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

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


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

class V8JsCode::_Internal { … };

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

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

V8JsCode::~V8JsCode() { … }

inline void V8JsCode::SharedDtor() { … }

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

void V8JsCode::clear_instructions() { … }


void V8JsCode::Clear() { … }

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

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

size_t V8JsCode::ByteSizeLong() const { … }

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

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

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

bool V8JsCode::IsInitialized() const { … }

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

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


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

class V8InternalCode::_Internal { … };

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

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

V8InternalCode::~V8InternalCode() { … }

inline void V8InternalCode::SharedDtor() { … }

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

void V8InternalCode::Clear() { … }

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

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

size_t V8InternalCode::ByteSizeLong() const { … }

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

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

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

bool V8InternalCode::IsInitialized() const { … }

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

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


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

class V8WasmCode::_Internal { … };

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

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

V8WasmCode::~V8WasmCode() { … }

inline void V8WasmCode::SharedDtor() { … }

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

void V8WasmCode::Clear() { … }

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

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

size_t V8WasmCode::ByteSizeLong() const { … }

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

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

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

bool V8WasmCode::IsInitialized() const { … }

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

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


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

class V8RegExpCode::_Internal { … };

const ::perfetto::protos::V8String&
V8RegExpCode::_Internal::pattern(const V8RegExpCode* msg) { … }
V8RegExpCode::V8RegExpCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : … { … }
V8RegExpCode::V8RegExpCode(const V8RegExpCode& from)
  : … { … }

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

V8RegExpCode::~V8RegExpCode() { … }

inline void V8RegExpCode::SharedDtor() { … }

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

void V8RegExpCode::Clear() { … }

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

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

size_t V8RegExpCode::ByteSizeLong() const { … }

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

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

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

bool V8RegExpCode::IsInitialized() const { … }

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

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


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

class V8CodeMove::_Internal { … };

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

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

V8CodeMove::~V8CodeMove() { … }

inline void V8CodeMove::SharedDtor() { … }

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

void V8CodeMove::clear_to_instructions() { … }


void V8CodeMove::Clear() { … }

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

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

size_t V8CodeMove::ByteSizeLong() const { … }

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

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

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

bool V8CodeMove::IsInitialized() const { … }

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

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


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

class V8CodeDefaults::_Internal { … };

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

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

V8CodeDefaults::~V8CodeDefaults() { … }

inline void V8CodeDefaults::SharedDtor() { … }

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

void V8CodeDefaults::Clear() { … }

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

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

size_t V8CodeDefaults::ByteSizeLong() const { … }

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

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

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

bool V8CodeDefaults::IsInitialized() const { … }

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

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


// @@protoc_insertion_point(namespace_scope)
}  // namespace protos
}  // namespace perfetto
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8String*
Arena::CreateMaybeMessage< ::perfetto::protos::V8String >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8String*
Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8String >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8JsScript*
Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8JsScript >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8WasmScript*
Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8WasmScript >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8JsFunction*
Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8JsFunction >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8Isolate_CodeRange*
Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8Isolate_CodeRange >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::InternedV8Isolate*
Arena::CreateMaybeMessage< ::perfetto::protos::InternedV8Isolate >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8JsCode*
Arena::CreateMaybeMessage< ::perfetto::protos::V8JsCode >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8InternalCode*
Arena::CreateMaybeMessage< ::perfetto::protos::V8InternalCode >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8WasmCode*
Arena::CreateMaybeMessage< ::perfetto::protos::V8WasmCode >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8RegExpCode*
Arena::CreateMaybeMessage< ::perfetto::protos::V8RegExpCode >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8CodeMove*
Arena::CreateMaybeMessage< ::perfetto::protos::V8CodeMove >(Arena* arena) { … }
template<> PROTOBUF_NOINLINE ::perfetto::protos::V8CodeDefaults*
Arena::CreateMaybeMessage< ::perfetto::protos::V8CodeDefaults >(Arena* arena) { … }
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>
chromium/out/Default/gen/third_party/perfetto/protos/perfetto/trace/chrome/v8.pb.cc
