1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/chrome/v8.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/generated_enum_util.h>
33 // @@protoc_insertion_point(includes)
34 #include <google/protobuf/port_def.inc>
35 #define PROTOBUF_INTERNAL_EXPORT_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto
36 PROTOBUF_NAMESPACE_OPEN
37 namespace internal {
38 class AnyMetadata;
39 } // namespace internal
40 PROTOBUF_NAMESPACE_CLOSE
41
42 // Internal implementation detail -- do not use these members.
43 struct TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto {
44 static const ::uint32_t offsets[];
45 };
46 namespace perfetto {
47 namespace protos {
48 class InternedV8Isolate;
49 struct InternedV8IsolateDefaultTypeInternal;
50 extern InternedV8IsolateDefaultTypeInternal _InternedV8Isolate_default_instance_;
51 class InternedV8Isolate_CodeRange;
52 struct InternedV8Isolate_CodeRangeDefaultTypeInternal;
53 extern InternedV8Isolate_CodeRangeDefaultTypeInternal _InternedV8Isolate_CodeRange_default_instance_;
54 class InternedV8JsFunction;
55 struct InternedV8JsFunctionDefaultTypeInternal;
56 extern InternedV8JsFunctionDefaultTypeInternal _InternedV8JsFunction_default_instance_;
57 class InternedV8JsScript;
58 struct InternedV8JsScriptDefaultTypeInternal;
59 extern InternedV8JsScriptDefaultTypeInternal _InternedV8JsScript_default_instance_;
60 class InternedV8String;
61 struct InternedV8StringDefaultTypeInternal;
62 extern InternedV8StringDefaultTypeInternal _InternedV8String_default_instance_;
63 class InternedV8WasmScript;
64 struct InternedV8WasmScriptDefaultTypeInternal;
65 extern InternedV8WasmScriptDefaultTypeInternal _InternedV8WasmScript_default_instance_;
66 class V8CodeDefaults;
67 struct V8CodeDefaultsDefaultTypeInternal;
68 extern V8CodeDefaultsDefaultTypeInternal _V8CodeDefaults_default_instance_;
69 class V8CodeMove;
70 struct V8CodeMoveDefaultTypeInternal;
71 extern V8CodeMoveDefaultTypeInternal _V8CodeMove_default_instance_;
72 class V8InternalCode;
73 struct V8InternalCodeDefaultTypeInternal;
74 extern V8InternalCodeDefaultTypeInternal _V8InternalCode_default_instance_;
75 class V8JsCode;
76 struct V8JsCodeDefaultTypeInternal;
77 extern V8JsCodeDefaultTypeInternal _V8JsCode_default_instance_;
78 class V8RegExpCode;
79 struct V8RegExpCodeDefaultTypeInternal;
80 extern V8RegExpCodeDefaultTypeInternal _V8RegExpCode_default_instance_;
81 class V8String;
82 struct V8StringDefaultTypeInternal;
83 extern V8StringDefaultTypeInternal _V8String_default_instance_;
84 class V8WasmCode;
85 struct V8WasmCodeDefaultTypeInternal;
86 extern V8WasmCodeDefaultTypeInternal _V8WasmCode_default_instance_;
87 } // namespace protos
88 } // namespace perfetto
89 PROTOBUF_NAMESPACE_OPEN
90 template<> ::perfetto::protos::InternedV8Isolate* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8Isolate>(Arena*);
91 template<> ::perfetto::protos::InternedV8Isolate_CodeRange* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8Isolate_CodeRange>(Arena*);
92 template<> ::perfetto::protos::InternedV8JsFunction* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8JsFunction>(Arena*);
93 template<> ::perfetto::protos::InternedV8JsScript* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8JsScript>(Arena*);
94 template<> ::perfetto::protos::InternedV8String* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8String>(Arena*);
95 template<> ::perfetto::protos::InternedV8WasmScript* Arena::CreateMaybeMessage<::perfetto::protos::InternedV8WasmScript>(Arena*);
96 template<> ::perfetto::protos::V8CodeDefaults* Arena::CreateMaybeMessage<::perfetto::protos::V8CodeDefaults>(Arena*);
97 template<> ::perfetto::protos::V8CodeMove* Arena::CreateMaybeMessage<::perfetto::protos::V8CodeMove>(Arena*);
98 template<> ::perfetto::protos::V8InternalCode* Arena::CreateMaybeMessage<::perfetto::protos::V8InternalCode>(Arena*);
99 template<> ::perfetto::protos::V8JsCode* Arena::CreateMaybeMessage<::perfetto::protos::V8JsCode>(Arena*);
100 template<> ::perfetto::protos::V8RegExpCode* Arena::CreateMaybeMessage<::perfetto::protos::V8RegExpCode>(Arena*);
101 template<> ::perfetto::protos::V8String* Arena::CreateMaybeMessage<::perfetto::protos::V8String>(Arena*);
102 template<> ::perfetto::protos::V8WasmCode* Arena::CreateMaybeMessage<::perfetto::protos::V8WasmCode>(Arena*);
103 PROTOBUF_NAMESPACE_CLOSE
104 namespace perfetto {
105 namespace protos {
106
107 enum InternedV8JsScript_Type : int {
108 InternedV8JsScript_Type_TYPE_UNKNOWN = 0,
109 InternedV8JsScript_Type_TYPE_NORMAL = 1,
110 InternedV8JsScript_Type_TYPE_EVAL = 2,
111 InternedV8JsScript_Type_TYPE_MODULE = 3,
112 InternedV8JsScript_Type_TYPE_NATIVE = 4,
113 InternedV8JsScript_Type_TYPE_EXTENSION = 5,
114 InternedV8JsScript_Type_TYPE_INSPECTOR = 6
115 };
116 bool InternedV8JsScript_Type_IsValid(int value);
117 constexpr InternedV8JsScript_Type InternedV8JsScript_Type_Type_MIN = InternedV8JsScript_Type_TYPE_UNKNOWN;
118 constexpr InternedV8JsScript_Type InternedV8JsScript_Type_Type_MAX = InternedV8JsScript_Type_TYPE_INSPECTOR;
119 constexpr int InternedV8JsScript_Type_Type_ARRAYSIZE = InternedV8JsScript_Type_Type_MAX + 1;
120
121 const std::string& InternedV8JsScript_Type_Name(InternedV8JsScript_Type value);
122 template<typename T>
InternedV8JsScript_Type_Name(T enum_t_value)123 inline const std::string& InternedV8JsScript_Type_Name(T enum_t_value) {
124 static_assert(::std::is_same<T, InternedV8JsScript_Type>::value ||
125 ::std::is_integral<T>::value,
126 "Incorrect type passed to function InternedV8JsScript_Type_Name.");
127 return InternedV8JsScript_Type_Name(static_cast<InternedV8JsScript_Type>(enum_t_value));
128 }
129 bool InternedV8JsScript_Type_Parse(
130 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsScript_Type* value);
131 enum InternedV8JsFunction_Kind : int {
132 InternedV8JsFunction_Kind_KIND_UNKNOWN = 0,
133 InternedV8JsFunction_Kind_KIND_NORMAL_FUNCTION = 1,
134 InternedV8JsFunction_Kind_KIND_MODULE = 2,
135 InternedV8JsFunction_Kind_KIND_ASYNC_MODULE = 3,
136 InternedV8JsFunction_Kind_KIND_BASE_CONSTRUCTOR = 4,
137 InternedV8JsFunction_Kind_KIND_DEFAULT_BASE_CONSTRUCTOR = 5,
138 InternedV8JsFunction_Kind_KIND_DEFAULT_DERIVED_CONSTRUCTOR = 6,
139 InternedV8JsFunction_Kind_KIND_DERIVED_CONSTRUCTOR = 7,
140 InternedV8JsFunction_Kind_KIND_GETTER_FUNCTION = 8,
141 InternedV8JsFunction_Kind_KIND_STATIC_GETTER_FUNCTION = 9,
142 InternedV8JsFunction_Kind_KIND_SETTER_FUNCTION = 10,
143 InternedV8JsFunction_Kind_KIND_STATIC_SETTER_FUNCTION = 11,
144 InternedV8JsFunction_Kind_KIND_ARROW_FUNCTION = 12,
145 InternedV8JsFunction_Kind_KIND_ASYNC_ARROW_FUNCTION = 13,
146 InternedV8JsFunction_Kind_KIND_ASYNC_FUNCTION = 14,
147 InternedV8JsFunction_Kind_KIND_ASYNC_CONCISE_METHOD = 15,
148 InternedV8JsFunction_Kind_KIND_STATIC_ASYNC_CONCISE_METHOD = 16,
149 InternedV8JsFunction_Kind_KIND_ASYNC_CONCISE_GENERATOR_METHOD = 17,
150 InternedV8JsFunction_Kind_KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD = 18,
151 InternedV8JsFunction_Kind_KIND_ASYNC_GENERATOR_FUNCTION = 19,
152 InternedV8JsFunction_Kind_KIND_GENERATOR_FUNCTION = 20,
153 InternedV8JsFunction_Kind_KIND_CONCISE_GENERATOR_METHOD = 21,
154 InternedV8JsFunction_Kind_KIND_STATIC_CONCISE_GENERATOR_METHOD = 22,
155 InternedV8JsFunction_Kind_KIND_CONCISE_METHOD = 23,
156 InternedV8JsFunction_Kind_KIND_STATIC_CONCISE_METHOD = 24,
157 InternedV8JsFunction_Kind_KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION = 25,
158 InternedV8JsFunction_Kind_KIND_CLASS_STATIC_INITIALIZER_FUNCTION = 26,
159 InternedV8JsFunction_Kind_KIND_INVALID = 27
160 };
161 bool InternedV8JsFunction_Kind_IsValid(int value);
162 constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_Kind_MIN = InternedV8JsFunction_Kind_KIND_UNKNOWN;
163 constexpr InternedV8JsFunction_Kind InternedV8JsFunction_Kind_Kind_MAX = InternedV8JsFunction_Kind_KIND_INVALID;
164 constexpr int InternedV8JsFunction_Kind_Kind_ARRAYSIZE = InternedV8JsFunction_Kind_Kind_MAX + 1;
165
166 const std::string& InternedV8JsFunction_Kind_Name(InternedV8JsFunction_Kind value);
167 template<typename T>
InternedV8JsFunction_Kind_Name(T enum_t_value)168 inline const std::string& InternedV8JsFunction_Kind_Name(T enum_t_value) {
169 static_assert(::std::is_same<T, InternedV8JsFunction_Kind>::value ||
170 ::std::is_integral<T>::value,
171 "Incorrect type passed to function InternedV8JsFunction_Kind_Name.");
172 return InternedV8JsFunction_Kind_Name(static_cast<InternedV8JsFunction_Kind>(enum_t_value));
173 }
174 bool InternedV8JsFunction_Kind_Parse(
175 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, InternedV8JsFunction_Kind* value);
176 enum V8JsCode_Tier : int {
177 V8JsCode_Tier_TIER_UNKNOWN = 0,
178 V8JsCode_Tier_TIER_IGNITION = 1,
179 V8JsCode_Tier_TIER_SPARKPLUG = 2,
180 V8JsCode_Tier_TIER_MAGLEV = 3,
181 V8JsCode_Tier_TIER_TURBOSHAFT = 4,
182 V8JsCode_Tier_TIER_TURBOFAN = 5
183 };
184 bool V8JsCode_Tier_IsValid(int value);
185 constexpr V8JsCode_Tier V8JsCode_Tier_Tier_MIN = V8JsCode_Tier_TIER_UNKNOWN;
186 constexpr V8JsCode_Tier V8JsCode_Tier_Tier_MAX = V8JsCode_Tier_TIER_TURBOFAN;
187 constexpr int V8JsCode_Tier_Tier_ARRAYSIZE = V8JsCode_Tier_Tier_MAX + 1;
188
189 const std::string& V8JsCode_Tier_Name(V8JsCode_Tier value);
190 template<typename T>
V8JsCode_Tier_Name(T enum_t_value)191 inline const std::string& V8JsCode_Tier_Name(T enum_t_value) {
192 static_assert(::std::is_same<T, V8JsCode_Tier>::value ||
193 ::std::is_integral<T>::value,
194 "Incorrect type passed to function V8JsCode_Tier_Name.");
195 return V8JsCode_Tier_Name(static_cast<V8JsCode_Tier>(enum_t_value));
196 }
197 bool V8JsCode_Tier_Parse(
198 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8JsCode_Tier* value);
199 enum V8InternalCode_Type : int {
200 V8InternalCode_Type_TYPE_UNKNOWN = 0,
201 V8InternalCode_Type_TYPE_BYTECODE_HANDLER = 1,
202 V8InternalCode_Type_TYPE_FOR_TESTING = 2,
203 V8InternalCode_Type_TYPE_BUILTIN = 3,
204 V8InternalCode_Type_TYPE_WASM_FUNCTION = 4,
205 V8InternalCode_Type_TYPE_WASM_TO_CAPI_FUNCTION = 5,
206 V8InternalCode_Type_TYPE_WASM_TO_JS_FUNCTION = 6,
207 V8InternalCode_Type_TYPE_JS_TO_WASM_FUNCTION = 7,
208 V8InternalCode_Type_TYPE_JS_TO_JS_FUNCTION = 8,
209 V8InternalCode_Type_TYPE_C_WASM_ENTRY = 9
210 };
211 bool V8InternalCode_Type_IsValid(int value);
212 constexpr V8InternalCode_Type V8InternalCode_Type_Type_MIN = V8InternalCode_Type_TYPE_UNKNOWN;
213 constexpr V8InternalCode_Type V8InternalCode_Type_Type_MAX = V8InternalCode_Type_TYPE_C_WASM_ENTRY;
214 constexpr int V8InternalCode_Type_Type_ARRAYSIZE = V8InternalCode_Type_Type_MAX + 1;
215
216 const std::string& V8InternalCode_Type_Name(V8InternalCode_Type value);
217 template<typename T>
V8InternalCode_Type_Name(T enum_t_value)218 inline const std::string& V8InternalCode_Type_Name(T enum_t_value) {
219 static_assert(::std::is_same<T, V8InternalCode_Type>::value ||
220 ::std::is_integral<T>::value,
221 "Incorrect type passed to function V8InternalCode_Type_Name.");
222 return V8InternalCode_Type_Name(static_cast<V8InternalCode_Type>(enum_t_value));
223 }
224 bool V8InternalCode_Type_Parse(
225 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8InternalCode_Type* value);
226 enum V8WasmCode_Tier : int {
227 V8WasmCode_Tier_TIER_UNKNOWN = 0,
228 V8WasmCode_Tier_TIER_LIFTOFF = 1,
229 V8WasmCode_Tier_TIER_TURBOFAN = 2
230 };
231 bool V8WasmCode_Tier_IsValid(int value);
232 constexpr V8WasmCode_Tier V8WasmCode_Tier_Tier_MIN = V8WasmCode_Tier_TIER_UNKNOWN;
233 constexpr V8WasmCode_Tier V8WasmCode_Tier_Tier_MAX = V8WasmCode_Tier_TIER_TURBOFAN;
234 constexpr int V8WasmCode_Tier_Tier_ARRAYSIZE = V8WasmCode_Tier_Tier_MAX + 1;
235
236 const std::string& V8WasmCode_Tier_Name(V8WasmCode_Tier value);
237 template<typename T>
V8WasmCode_Tier_Name(T enum_t_value)238 inline const std::string& V8WasmCode_Tier_Name(T enum_t_value) {
239 static_assert(::std::is_same<T, V8WasmCode_Tier>::value ||
240 ::std::is_integral<T>::value,
241 "Incorrect type passed to function V8WasmCode_Tier_Name.");
242 return V8WasmCode_Tier_Name(static_cast<V8WasmCode_Tier>(enum_t_value));
243 }
244 bool V8WasmCode_Tier_Parse(
245 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, V8WasmCode_Tier* value);
246 // ===================================================================
247
248 class V8String final :
249 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8String) */ {
250 public:
V8String()251 inline V8String() : V8String(nullptr) {}
252 ~V8String() override;
253 explicit PROTOBUF_CONSTEXPR V8String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
254
255 V8String(const V8String& from);
V8String(V8String && from)256 V8String(V8String&& from) noexcept
257 : V8String() {
258 *this = ::std::move(from);
259 }
260
261 inline V8String& operator=(const V8String& from) {
262 if (this == &from) return *this;
263 CopyFrom(from);
264 return *this;
265 }
266 inline V8String& operator=(V8String&& from) noexcept {
267 if (this == &from) return *this;
268 if (GetOwningArena() == from.GetOwningArena()
269 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
270 && GetOwningArena() != nullptr
271 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
272 ) {
273 InternalSwap(&from);
274 } else {
275 CopyFrom(from);
276 }
277 return *this;
278 }
279
unknown_fields()280 inline const std::string& unknown_fields() const {
281 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
282 }
mutable_unknown_fields()283 inline std::string* mutable_unknown_fields() {
284 return _internal_metadata_.mutable_unknown_fields<std::string>();
285 }
286
default_instance()287 static const V8String& default_instance() {
288 return *internal_default_instance();
289 }
290 enum EncodedStringCase {
291 kLatin1 = 1,
292 kUtf16Le = 2,
293 kUtf16Be = 3,
294 ENCODED_STRING_NOT_SET = 0,
295 };
296
internal_default_instance()297 static inline const V8String* internal_default_instance() {
298 return reinterpret_cast<const V8String*>(
299 &_V8String_default_instance_);
300 }
301 static constexpr int kIndexInFileMessages =
302 0;
303
swap(V8String & a,V8String & b)304 friend void swap(V8String& a, V8String& b) {
305 a.Swap(&b);
306 }
Swap(V8String * other)307 inline void Swap(V8String* other) {
308 if (other == this) return;
309 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
310 if (GetOwningArena() != nullptr &&
311 GetOwningArena() == other->GetOwningArena()) {
312 #else // PROTOBUF_FORCE_COPY_IN_SWAP
313 if (GetOwningArena() == other->GetOwningArena()) {
314 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
315 InternalSwap(other);
316 } else {
317 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
318 }
319 }
320 void UnsafeArenaSwap(V8String* other) {
321 if (other == this) return;
322 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
323 InternalSwap(other);
324 }
325
326 // implements Message ----------------------------------------------
327
328 V8String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
329 return CreateMaybeMessage<V8String>(arena);
330 }
331 V8String* New() const {
332 return New(nullptr);
333 }
334 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
335 void CopyFrom(const V8String& from);
336 void MergeFrom(const V8String& from);
337 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
338 bool IsInitialized() const final;
339
340 size_t ByteSizeLong() const final;
341 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
342 ::uint8_t* _InternalSerialize(
343 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
344 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
345
346 private:
347 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
348 void SharedDtor();
349 void SetCachedSize(int size) const;
350 void InternalSwap(V8String* other);
351
352 private:
353 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
354 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
355 return "perfetto.protos.V8String";
356 }
357 protected:
358 explicit V8String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
359 bool is_message_owned = false);
360 public:
361
362 std::string GetTypeName() const final;
363
364 // nested types ----------------------------------------------------
365
366 // accessors -------------------------------------------------------
367
368 enum : int {
369 kLatin1FieldNumber = 1,
370 kUtf16LeFieldNumber = 2,
371 kUtf16BeFieldNumber = 3,
372 };
373 // bytes latin1 = 1;
374 bool has_latin1() const;
375 private:
376 bool _internal_has_latin1() const;
377 public:
378 void clear_latin1();
379 const std::string& latin1() const;
380 template <typename ArgT0 = const std::string&, typename... ArgT>
381 void set_latin1(ArgT0&& arg0, ArgT... args);
382 std::string* mutable_latin1();
383 PROTOBUF_NODISCARD std::string* release_latin1();
384 void set_allocated_latin1(std::string* latin1);
385 private:
386 const std::string& _internal_latin1() const;
387 inline PROTOBUF_ALWAYS_INLINE void _internal_set_latin1(const std::string& value);
388 std::string* _internal_mutable_latin1();
389 public:
390
391 // bytes utf16_le = 2;
392 bool has_utf16_le() const;
393 private:
394 bool _internal_has_utf16_le() const;
395 public:
396 void clear_utf16_le();
397 const std::string& utf16_le() const;
398 template <typename ArgT0 = const std::string&, typename... ArgT>
399 void set_utf16_le(ArgT0&& arg0, ArgT... args);
400 std::string* mutable_utf16_le();
401 PROTOBUF_NODISCARD std::string* release_utf16_le();
402 void set_allocated_utf16_le(std::string* utf16_le);
403 private:
404 const std::string& _internal_utf16_le() const;
405 inline PROTOBUF_ALWAYS_INLINE void _internal_set_utf16_le(const std::string& value);
406 std::string* _internal_mutable_utf16_le();
407 public:
408
409 // bytes utf16_be = 3;
410 bool has_utf16_be() const;
411 private:
412 bool _internal_has_utf16_be() const;
413 public:
414 void clear_utf16_be();
415 const std::string& utf16_be() const;
416 template <typename ArgT0 = const std::string&, typename... ArgT>
417 void set_utf16_be(ArgT0&& arg0, ArgT... args);
418 std::string* mutable_utf16_be();
419 PROTOBUF_NODISCARD std::string* release_utf16_be();
420 void set_allocated_utf16_be(std::string* utf16_be);
421 private:
422 const std::string& _internal_utf16_be() const;
423 inline PROTOBUF_ALWAYS_INLINE void _internal_set_utf16_be(const std::string& value);
424 std::string* _internal_mutable_utf16_be();
425 public:
426
427 void clear_encoded_string();
428 EncodedStringCase encoded_string_case() const;
429 // @@protoc_insertion_point(class_scope:perfetto.protos.V8String)
430 private:
431 class _Internal;
432 void set_has_latin1();
433 void set_has_utf16_le();
434 void set_has_utf16_be();
435
436 inline bool has_encoded_string() const;
437 inline void clear_has_encoded_string();
438
439 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
440 typedef void InternalArenaConstructable_;
441 typedef void DestructorSkippable_;
442 struct Impl_ {
443 union EncodedStringUnion {
444 constexpr EncodedStringUnion() : _constinit_{} {}
445 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
446 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr latin1_;
447 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr utf16_le_;
448 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr utf16_be_;
449 } encoded_string_;
450 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
451 ::uint32_t _oneof_case_[1];
452
453 };
454 union { Impl_ _impl_; };
455 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
456 };
457 // -------------------------------------------------------------------
458
459 class InternedV8String final :
460 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.InternedV8String) */ {
461 public:
InternedV8String()462 inline InternedV8String() : InternedV8String(nullptr) {}
463 ~InternedV8String() override;
464 explicit PROTOBUF_CONSTEXPR InternedV8String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
465
466 InternedV8String(const InternedV8String& from);
InternedV8String(InternedV8String && from)467 InternedV8String(InternedV8String&& from) noexcept
468 : InternedV8String() {
469 *this = ::std::move(from);
470 }
471
472 inline InternedV8String& operator=(const InternedV8String& from) {
473 if (this == &from) return *this;
474 CopyFrom(from);
475 return *this;
476 }
477 inline InternedV8String& operator=(InternedV8String&& from) noexcept {
478 if (this == &from) return *this;
479 if (GetOwningArena() == from.GetOwningArena()
480 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
481 && GetOwningArena() != nullptr
482 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
483 ) {
484 InternalSwap(&from);
485 } else {
486 CopyFrom(from);
487 }
488 return *this;
489 }
490
unknown_fields()491 inline const std::string& unknown_fields() const {
492 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
493 }
mutable_unknown_fields()494 inline std::string* mutable_unknown_fields() {
495 return _internal_metadata_.mutable_unknown_fields<std::string>();
496 }
497
default_instance()498 static const InternedV8String& default_instance() {
499 return *internal_default_instance();
500 }
501 enum EncodedStringCase {
502 kLatin1 = 2,
503 kUtf16Le = 3,
504 kUtf16Be = 4,
505 ENCODED_STRING_NOT_SET = 0,
506 };
507
internal_default_instance()508 static inline const InternedV8String* internal_default_instance() {
509 return reinterpret_cast<const InternedV8String*>(
510 &_InternedV8String_default_instance_);
511 }
512 static constexpr int kIndexInFileMessages =
513 1;
514
swap(InternedV8String & a,InternedV8String & b)515 friend void swap(InternedV8String& a, InternedV8String& b) {
516 a.Swap(&b);
517 }
Swap(InternedV8String * other)518 inline void Swap(InternedV8String* other) {
519 if (other == this) return;
520 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
521 if (GetOwningArena() != nullptr &&
522 GetOwningArena() == other->GetOwningArena()) {
523 #else // PROTOBUF_FORCE_COPY_IN_SWAP
524 if (GetOwningArena() == other->GetOwningArena()) {
525 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
526 InternalSwap(other);
527 } else {
528 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
529 }
530 }
531 void UnsafeArenaSwap(InternedV8String* other) {
532 if (other == this) return;
533 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
534 InternalSwap(other);
535 }
536
537 // implements Message ----------------------------------------------
538
539 InternedV8String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
540 return CreateMaybeMessage<InternedV8String>(arena);
541 }
542 InternedV8String* New() const {
543 return New(nullptr);
544 }
545 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
546 void CopyFrom(const InternedV8String& from);
547 void MergeFrom(const InternedV8String& from);
548 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
549 bool IsInitialized() const final;
550
551 size_t ByteSizeLong() const final;
552 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
553 ::uint8_t* _InternalSerialize(
554 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
555 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
556
557 private:
558 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
559 void SharedDtor();
560 void SetCachedSize(int size) const;
561 void InternalSwap(InternedV8String* other);
562
563 private:
564 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
565 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
566 return "perfetto.protos.InternedV8String";
567 }
568 protected:
569 explicit InternedV8String(::PROTOBUF_NAMESPACE_ID::Arena* arena,
570 bool is_message_owned = false);
571 public:
572
573 std::string GetTypeName() const final;
574
575 // nested types ----------------------------------------------------
576
577 // accessors -------------------------------------------------------
578
579 enum : int {
580 kIidFieldNumber = 1,
581 kLatin1FieldNumber = 2,
582 kUtf16LeFieldNumber = 3,
583 kUtf16BeFieldNumber = 4,
584 };
585 // optional uint64 iid = 1;
586 bool has_iid() const;
587 private:
588 bool _internal_has_iid() const;
589 public:
590 void clear_iid();
591 ::uint64_t iid() const;
592 void set_iid(::uint64_t value);
593 private:
594 ::uint64_t _internal_iid() const;
595 void _internal_set_iid(::uint64_t value);
596 public:
597
598 // bytes latin1 = 2;
599 bool has_latin1() const;
600 private:
601 bool _internal_has_latin1() const;
602 public:
603 void clear_latin1();
604 const std::string& latin1() const;
605 template <typename ArgT0 = const std::string&, typename... ArgT>
606 void set_latin1(ArgT0&& arg0, ArgT... args);
607 std::string* mutable_latin1();
608 PROTOBUF_NODISCARD std::string* release_latin1();
609 void set_allocated_latin1(std::string* latin1);
610 private:
611 const std::string& _internal_latin1() const;
612 inline PROTOBUF_ALWAYS_INLINE void _internal_set_latin1(const std::string& value);
613 std::string* _internal_mutable_latin1();
614 public:
615
616 // bytes utf16_le = 3;
617 bool has_utf16_le() const;
618 private:
619 bool _internal_has_utf16_le() const;
620 public:
621 void clear_utf16_le();
622 const std::string& utf16_le() const;
623 template <typename ArgT0 = const std::string&, typename... ArgT>
624 void set_utf16_le(ArgT0&& arg0, ArgT... args);
625 std::string* mutable_utf16_le();
626 PROTOBUF_NODISCARD std::string* release_utf16_le();
627 void set_allocated_utf16_le(std::string* utf16_le);
628 private:
629 const std::string& _internal_utf16_le() const;
630 inline PROTOBUF_ALWAYS_INLINE void _internal_set_utf16_le(const std::string& value);
631 std::string* _internal_mutable_utf16_le();
632 public:
633
634 // bytes utf16_be = 4;
635 bool has_utf16_be() const;
636 private:
637 bool _internal_has_utf16_be() const;
638 public:
639 void clear_utf16_be();
640 const std::string& utf16_be() const;
641 template <typename ArgT0 = const std::string&, typename... ArgT>
642 void set_utf16_be(ArgT0&& arg0, ArgT... args);
643 std::string* mutable_utf16_be();
644 PROTOBUF_NODISCARD std::string* release_utf16_be();
645 void set_allocated_utf16_be(std::string* utf16_be);
646 private:
647 const std::string& _internal_utf16_be() const;
648 inline PROTOBUF_ALWAYS_INLINE void _internal_set_utf16_be(const std::string& value);
649 std::string* _internal_mutable_utf16_be();
650 public:
651
652 void clear_encoded_string();
653 EncodedStringCase encoded_string_case() const;
654 // @@protoc_insertion_point(class_scope:perfetto.protos.InternedV8String)
655 private:
656 class _Internal;
657 void set_has_latin1();
658 void set_has_utf16_le();
659 void set_has_utf16_be();
660
661 inline bool has_encoded_string() const;
662 inline void clear_has_encoded_string();
663
664 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
665 typedef void InternalArenaConstructable_;
666 typedef void DestructorSkippable_;
667 struct Impl_ {
668 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
669 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
670 ::uint64_t iid_;
671 union EncodedStringUnion {
672 constexpr EncodedStringUnion() : _constinit_{} {}
673 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
674 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr latin1_;
675 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr utf16_le_;
676 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr utf16_be_;
677 } encoded_string_;
678 ::uint32_t _oneof_case_[1];
679
680 };
681 union { Impl_ _impl_; };
682 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
683 };
684 // -------------------------------------------------------------------
685
686 class InternedV8JsScript final :
687 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.InternedV8JsScript) */ {
688 public:
InternedV8JsScript()689 inline InternedV8JsScript() : InternedV8JsScript(nullptr) {}
690 ~InternedV8JsScript() override;
691 explicit PROTOBUF_CONSTEXPR InternedV8JsScript(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
692
693 InternedV8JsScript(const InternedV8JsScript& from);
InternedV8JsScript(InternedV8JsScript && from)694 InternedV8JsScript(InternedV8JsScript&& from) noexcept
695 : InternedV8JsScript() {
696 *this = ::std::move(from);
697 }
698
699 inline InternedV8JsScript& operator=(const InternedV8JsScript& from) {
700 if (this == &from) return *this;
701 CopyFrom(from);
702 return *this;
703 }
704 inline InternedV8JsScript& operator=(InternedV8JsScript&& from) noexcept {
705 if (this == &from) return *this;
706 if (GetOwningArena() == from.GetOwningArena()
707 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
708 && GetOwningArena() != nullptr
709 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
710 ) {
711 InternalSwap(&from);
712 } else {
713 CopyFrom(from);
714 }
715 return *this;
716 }
717
unknown_fields()718 inline const std::string& unknown_fields() const {
719 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
720 }
mutable_unknown_fields()721 inline std::string* mutable_unknown_fields() {
722 return _internal_metadata_.mutable_unknown_fields<std::string>();
723 }
724
default_instance()725 static const InternedV8JsScript& default_instance() {
726 return *internal_default_instance();
727 }
internal_default_instance()728 static inline const InternedV8JsScript* internal_default_instance() {
729 return reinterpret_cast<const InternedV8JsScript*>(
730 &_InternedV8JsScript_default_instance_);
731 }
732 static constexpr int kIndexInFileMessages =
733 2;
734
swap(InternedV8JsScript & a,InternedV8JsScript & b)735 friend void swap(InternedV8JsScript& a, InternedV8JsScript& b) {
736 a.Swap(&b);
737 }
Swap(InternedV8JsScript * other)738 inline void Swap(InternedV8JsScript* other) {
739 if (other == this) return;
740 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
741 if (GetOwningArena() != nullptr &&
742 GetOwningArena() == other->GetOwningArena()) {
743 #else // PROTOBUF_FORCE_COPY_IN_SWAP
744 if (GetOwningArena() == other->GetOwningArena()) {
745 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
746 InternalSwap(other);
747 } else {
748 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
749 }
750 }
751 void UnsafeArenaSwap(InternedV8JsScript* other) {
752 if (other == this) return;
753 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
754 InternalSwap(other);
755 }
756
757 // implements Message ----------------------------------------------
758
759 InternedV8JsScript* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
760 return CreateMaybeMessage<InternedV8JsScript>(arena);
761 }
762 InternedV8JsScript* New() const {
763 return New(nullptr);
764 }
765 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
766 void CopyFrom(const InternedV8JsScript& from);
767 void MergeFrom(const InternedV8JsScript& from);
768 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
769 bool IsInitialized() const final;
770
771 size_t ByteSizeLong() const final;
772 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
773 ::uint8_t* _InternalSerialize(
774 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
775 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
776
777 private:
778 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
779 void SharedDtor();
780 void SetCachedSize(int size) const;
781 void InternalSwap(InternedV8JsScript* other);
782
783 private:
784 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
785 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
786 return "perfetto.protos.InternedV8JsScript";
787 }
788 protected:
789 explicit InternedV8JsScript(::PROTOBUF_NAMESPACE_ID::Arena* arena,
790 bool is_message_owned = false);
791 public:
792
793 std::string GetTypeName() const final;
794
795 // nested types ----------------------------------------------------
796
797 typedef InternedV8JsScript_Type Type;
798 static constexpr Type TYPE_UNKNOWN =
799 InternedV8JsScript_Type_TYPE_UNKNOWN;
800 static constexpr Type TYPE_NORMAL =
801 InternedV8JsScript_Type_TYPE_NORMAL;
802 static constexpr Type TYPE_EVAL =
803 InternedV8JsScript_Type_TYPE_EVAL;
804 static constexpr Type TYPE_MODULE =
805 InternedV8JsScript_Type_TYPE_MODULE;
806 static constexpr Type TYPE_NATIVE =
807 InternedV8JsScript_Type_TYPE_NATIVE;
808 static constexpr Type TYPE_EXTENSION =
809 InternedV8JsScript_Type_TYPE_EXTENSION;
810 static constexpr Type TYPE_INSPECTOR =
811 InternedV8JsScript_Type_TYPE_INSPECTOR;
812 static inline bool Type_IsValid(int value) {
813 return InternedV8JsScript_Type_IsValid(value);
814 }
815 static constexpr Type Type_MIN =
816 InternedV8JsScript_Type_Type_MIN;
817 static constexpr Type Type_MAX =
818 InternedV8JsScript_Type_Type_MAX;
819 static constexpr int Type_ARRAYSIZE =
820 InternedV8JsScript_Type_Type_ARRAYSIZE;
821 template<typename T>
822 static inline const std::string& Type_Name(T enum_t_value) {
823 static_assert(::std::is_same<T, Type>::value ||
824 ::std::is_integral<T>::value,
825 "Incorrect type passed to function Type_Name.");
826 return InternedV8JsScript_Type_Name(enum_t_value);
827 }
828 static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
829 Type* value) {
830 return InternedV8JsScript_Type_Parse(name, value);
831 }
832
833 // accessors -------------------------------------------------------
834
835 enum : int {
836 kNameFieldNumber = 4,
837 kSourceFieldNumber = 5,
838 kIidFieldNumber = 1,
839 kScriptIdFieldNumber = 2,
840 kTypeFieldNumber = 3,
841 };
842 // optional .perfetto.protos.V8String name = 4;
843 bool has_name() const;
844 private:
845 bool _internal_has_name() const;
846 public:
847 void clear_name();
848 const ::perfetto::protos::V8String& name() const;
849 PROTOBUF_NODISCARD ::perfetto::protos::V8String* release_name();
850 ::perfetto::protos::V8String* mutable_name();
851 void set_allocated_name(::perfetto::protos::V8String* name);
852 private:
853 const ::perfetto::protos::V8String& _internal_name() const;
854 ::perfetto::protos::V8String* _internal_mutable_name();
855 public:
856 void unsafe_arena_set_allocated_name(
857 ::perfetto::protos::V8String* name);
858 ::perfetto::protos::V8String* unsafe_arena_release_name();
859
860 // optional .perfetto.protos.V8String source = 5;
861 bool has_source() const;
862 private:
863 bool _internal_has_source() const;
864 public:
865 void clear_source();
866 const ::perfetto::protos::V8String& source() const;
867 PROTOBUF_NODISCARD ::perfetto::protos::V8String* release_source();
868 ::perfetto::protos::V8String* mutable_source();
869 void set_allocated_source(::perfetto::protos::V8String* source);
870 private:
871 const ::perfetto::protos::V8String& _internal_source() const;
872 ::perfetto::protos::V8String* _internal_mutable_source();
873 public:
874 void unsafe_arena_set_allocated_source(
875 ::perfetto::protos::V8String* source);
876 ::perfetto::protos::V8String* unsafe_arena_release_source();
877
878 // optional uint64 iid = 1;
879 bool has_iid() const;
880 private:
881 bool _internal_has_iid() const;
882 public:
883 void clear_iid();
884 ::uint64_t iid() const;
885 void set_iid(::uint64_t value);
886 private:
887 ::uint64_t _internal_iid() const;
888 void _internal_set_iid(::uint64_t value);
889 public:
890
891 // optional int32 script_id = 2;
892 bool has_script_id() const;
893 private:
894 bool _internal_has_script_id() const;
895 public:
896 void clear_script_id();
897 ::int32_t script_id() const;
898 void set_script_id(::int32_t value);
899 private:
900 ::int32_t _internal_script_id() const;
901 void _internal_set_script_id(::int32_t value);
902 public:
903
904 // optional .perfetto.protos.InternedV8JsScript.Type type = 3;
905 bool has_type() const;
906 private:
907 bool _internal_has_type() const;
908 public:
909 void clear_type();
910 ::perfetto::protos::InternedV8JsScript_Type type() const;
911 void set_type(::perfetto::protos::InternedV8JsScript_Type value);
912 private:
913 ::perfetto::protos::InternedV8JsScript_Type _internal_type() const;
914 void _internal_set_type(::perfetto::protos::InternedV8JsScript_Type value);
915 public:
916
917 // @@protoc_insertion_point(class_scope:perfetto.protos.InternedV8JsScript)
918 private:
919 class _Internal;
920
921 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
922 typedef void InternalArenaConstructable_;
923 typedef void DestructorSkippable_;
924 struct Impl_ {
925 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
926 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
927 ::perfetto::protos::V8String* name_;
928 ::perfetto::protos::V8String* source_;
929 ::uint64_t iid_;
930 ::int32_t script_id_;
931 int type_;
932 };
933 union { Impl_ _impl_; };
934 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
935 };
936 // -------------------------------------------------------------------
937
938 class InternedV8WasmScript final :
939 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.InternedV8WasmScript) */ {
940 public:
InternedV8WasmScript()941 inline InternedV8WasmScript() : InternedV8WasmScript(nullptr) {}
942 ~InternedV8WasmScript() override;
943 explicit PROTOBUF_CONSTEXPR InternedV8WasmScript(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
944
945 InternedV8WasmScript(const InternedV8WasmScript& from);
InternedV8WasmScript(InternedV8WasmScript && from)946 InternedV8WasmScript(InternedV8WasmScript&& from) noexcept
947 : InternedV8WasmScript() {
948 *this = ::std::move(from);
949 }
950
951 inline InternedV8WasmScript& operator=(const InternedV8WasmScript& from) {
952 if (this == &from) return *this;
953 CopyFrom(from);
954 return *this;
955 }
956 inline InternedV8WasmScript& operator=(InternedV8WasmScript&& from) noexcept {
957 if (this == &from) return *this;
958 if (GetOwningArena() == from.GetOwningArena()
959 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
960 && GetOwningArena() != nullptr
961 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
962 ) {
963 InternalSwap(&from);
964 } else {
965 CopyFrom(from);
966 }
967 return *this;
968 }
969
unknown_fields()970 inline const std::string& unknown_fields() const {
971 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
972 }
mutable_unknown_fields()973 inline std::string* mutable_unknown_fields() {
974 return _internal_metadata_.mutable_unknown_fields<std::string>();
975 }
976
default_instance()977 static const InternedV8WasmScript& default_instance() {
978 return *internal_default_instance();
979 }
internal_default_instance()980 static inline const InternedV8WasmScript* internal_default_instance() {
981 return reinterpret_cast<const InternedV8WasmScript*>(
982 &_InternedV8WasmScript_default_instance_);
983 }
984 static constexpr int kIndexInFileMessages =
985 3;
986
swap(InternedV8WasmScript & a,InternedV8WasmScript & b)987 friend void swap(InternedV8WasmScript& a, InternedV8WasmScript& b) {
988 a.Swap(&b);
989 }
Swap(InternedV8WasmScript * other)990 inline void Swap(InternedV8WasmScript* other) {
991 if (other == this) return;
992 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
993 if (GetOwningArena() != nullptr &&
994 GetOwningArena() == other->GetOwningArena()) {
995 #else // PROTOBUF_FORCE_COPY_IN_SWAP
996 if (GetOwningArena() == other->GetOwningArena()) {
997 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
998 InternalSwap(other);
999 } else {
1000 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1001 }
1002 }
1003 void UnsafeArenaSwap(InternedV8WasmScript* other) {
1004 if (other == this) return;
1005 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1006 InternalSwap(other);
1007 }
1008
1009 // implements Message ----------------------------------------------
1010
1011 InternedV8WasmScript* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1012 return CreateMaybeMessage<InternedV8WasmScript>(arena);
1013 }
1014 InternedV8WasmScript* New() const {
1015 return New(nullptr);
1016 }
1017 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1018 void CopyFrom(const InternedV8WasmScript& from);
1019 void MergeFrom(const InternedV8WasmScript& from);
1020 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1021 bool IsInitialized() const final;
1022
1023 size_t ByteSizeLong() const final;
1024 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1025 ::uint8_t* _InternalSerialize(
1026 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1027 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1028
1029 private:
1030 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1031 void SharedDtor();
1032 void SetCachedSize(int size) const;
1033 void InternalSwap(InternedV8WasmScript* other);
1034
1035 private:
1036 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1037 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1038 return "perfetto.protos.InternedV8WasmScript";
1039 }
1040 protected:
1041 explicit InternedV8WasmScript(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1042 bool is_message_owned = false);
1043 public:
1044
1045 std::string GetTypeName() const final;
1046
1047 // nested types ----------------------------------------------------
1048
1049 // accessors -------------------------------------------------------
1050
1051 enum : int {
1052 kUrlFieldNumber = 3,
1053 kIidFieldNumber = 1,
1054 kScriptIdFieldNumber = 2,
1055 };
1056 // optional string url = 3;
1057 bool has_url() const;
1058 private:
1059 bool _internal_has_url() const;
1060 public:
1061 void clear_url();
1062 const std::string& url() const;
1063 template <typename ArgT0 = const std::string&, typename... ArgT>
1064 void set_url(ArgT0&& arg0, ArgT... args);
1065 std::string* mutable_url();
1066 PROTOBUF_NODISCARD std::string* release_url();
1067 void set_allocated_url(std::string* url);
1068 private:
1069 const std::string& _internal_url() const;
1070 inline PROTOBUF_ALWAYS_INLINE void _internal_set_url(const std::string& value);
1071 std::string* _internal_mutable_url();
1072 public:
1073
1074 // optional uint64 iid = 1;
1075 bool has_iid() const;
1076 private:
1077 bool _internal_has_iid() const;
1078 public:
1079 void clear_iid();
1080 ::uint64_t iid() const;
1081 void set_iid(::uint64_t value);
1082 private:
1083 ::uint64_t _internal_iid() const;
1084 void _internal_set_iid(::uint64_t value);
1085 public:
1086
1087 // optional int32 script_id = 2;
1088 bool has_script_id() const;
1089 private:
1090 bool _internal_has_script_id() const;
1091 public:
1092 void clear_script_id();
1093 ::int32_t script_id() const;
1094 void set_script_id(::int32_t value);
1095 private:
1096 ::int32_t _internal_script_id() const;
1097 void _internal_set_script_id(::int32_t value);
1098 public:
1099
1100 // @@protoc_insertion_point(class_scope:perfetto.protos.InternedV8WasmScript)
1101 private:
1102 class _Internal;
1103
1104 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1105 typedef void InternalArenaConstructable_;
1106 typedef void DestructorSkippable_;
1107 struct Impl_ {
1108 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1109 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1110 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr url_;
1111 ::uint64_t iid_;
1112 ::int32_t script_id_;
1113 };
1114 union { Impl_ _impl_; };
1115 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
1116 };
1117 // -------------------------------------------------------------------
1118
1119 class InternedV8JsFunction final :
1120 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.InternedV8JsFunction) */ {
1121 public:
InternedV8JsFunction()1122 inline InternedV8JsFunction() : InternedV8JsFunction(nullptr) {}
1123 ~InternedV8JsFunction() override;
1124 explicit PROTOBUF_CONSTEXPR InternedV8JsFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1125
1126 InternedV8JsFunction(const InternedV8JsFunction& from);
InternedV8JsFunction(InternedV8JsFunction && from)1127 InternedV8JsFunction(InternedV8JsFunction&& from) noexcept
1128 : InternedV8JsFunction() {
1129 *this = ::std::move(from);
1130 }
1131
1132 inline InternedV8JsFunction& operator=(const InternedV8JsFunction& from) {
1133 if (this == &from) return *this;
1134 CopyFrom(from);
1135 return *this;
1136 }
1137 inline InternedV8JsFunction& operator=(InternedV8JsFunction&& from) noexcept {
1138 if (this == &from) return *this;
1139 if (GetOwningArena() == from.GetOwningArena()
1140 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1141 && GetOwningArena() != nullptr
1142 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1143 ) {
1144 InternalSwap(&from);
1145 } else {
1146 CopyFrom(from);
1147 }
1148 return *this;
1149 }
1150
unknown_fields()1151 inline const std::string& unknown_fields() const {
1152 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1153 }
mutable_unknown_fields()1154 inline std::string* mutable_unknown_fields() {
1155 return _internal_metadata_.mutable_unknown_fields<std::string>();
1156 }
1157
default_instance()1158 static const InternedV8JsFunction& default_instance() {
1159 return *internal_default_instance();
1160 }
internal_default_instance()1161 static inline const InternedV8JsFunction* internal_default_instance() {
1162 return reinterpret_cast<const InternedV8JsFunction*>(
1163 &_InternedV8JsFunction_default_instance_);
1164 }
1165 static constexpr int kIndexInFileMessages =
1166 4;
1167
swap(InternedV8JsFunction & a,InternedV8JsFunction & b)1168 friend void swap(InternedV8JsFunction& a, InternedV8JsFunction& b) {
1169 a.Swap(&b);
1170 }
Swap(InternedV8JsFunction * other)1171 inline void Swap(InternedV8JsFunction* other) {
1172 if (other == this) return;
1173 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1174 if (GetOwningArena() != nullptr &&
1175 GetOwningArena() == other->GetOwningArena()) {
1176 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1177 if (GetOwningArena() == other->GetOwningArena()) {
1178 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1179 InternalSwap(other);
1180 } else {
1181 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1182 }
1183 }
1184 void UnsafeArenaSwap(InternedV8JsFunction* other) {
1185 if (other == this) return;
1186 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1187 InternalSwap(other);
1188 }
1189
1190 // implements Message ----------------------------------------------
1191
1192 InternedV8JsFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1193 return CreateMaybeMessage<InternedV8JsFunction>(arena);
1194 }
1195 InternedV8JsFunction* New() const {
1196 return New(nullptr);
1197 }
1198 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1199 void CopyFrom(const InternedV8JsFunction& from);
1200 void MergeFrom(const InternedV8JsFunction& from);
1201 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1202 bool IsInitialized() const final;
1203
1204 size_t ByteSizeLong() const final;
1205 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1206 ::uint8_t* _InternalSerialize(
1207 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1208 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1209
1210 private:
1211 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1212 void SharedDtor();
1213 void SetCachedSize(int size) const;
1214 void InternalSwap(InternedV8JsFunction* other);
1215
1216 private:
1217 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1218 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1219 return "perfetto.protos.InternedV8JsFunction";
1220 }
1221 protected:
1222 explicit InternedV8JsFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1223 bool is_message_owned = false);
1224 public:
1225
1226 std::string GetTypeName() const final;
1227
1228 // nested types ----------------------------------------------------
1229
1230 typedef InternedV8JsFunction_Kind Kind;
1231 static constexpr Kind KIND_UNKNOWN =
1232 InternedV8JsFunction_Kind_KIND_UNKNOWN;
1233 static constexpr Kind KIND_NORMAL_FUNCTION =
1234 InternedV8JsFunction_Kind_KIND_NORMAL_FUNCTION;
1235 static constexpr Kind KIND_MODULE =
1236 InternedV8JsFunction_Kind_KIND_MODULE;
1237 static constexpr Kind KIND_ASYNC_MODULE =
1238 InternedV8JsFunction_Kind_KIND_ASYNC_MODULE;
1239 static constexpr Kind KIND_BASE_CONSTRUCTOR =
1240 InternedV8JsFunction_Kind_KIND_BASE_CONSTRUCTOR;
1241 static constexpr Kind KIND_DEFAULT_BASE_CONSTRUCTOR =
1242 InternedV8JsFunction_Kind_KIND_DEFAULT_BASE_CONSTRUCTOR;
1243 static constexpr Kind KIND_DEFAULT_DERIVED_CONSTRUCTOR =
1244 InternedV8JsFunction_Kind_KIND_DEFAULT_DERIVED_CONSTRUCTOR;
1245 static constexpr Kind KIND_DERIVED_CONSTRUCTOR =
1246 InternedV8JsFunction_Kind_KIND_DERIVED_CONSTRUCTOR;
1247 static constexpr Kind KIND_GETTER_FUNCTION =
1248 InternedV8JsFunction_Kind_KIND_GETTER_FUNCTION;
1249 static constexpr Kind KIND_STATIC_GETTER_FUNCTION =
1250 InternedV8JsFunction_Kind_KIND_STATIC_GETTER_FUNCTION;
1251 static constexpr Kind KIND_SETTER_FUNCTION =
1252 InternedV8JsFunction_Kind_KIND_SETTER_FUNCTION;
1253 static constexpr Kind KIND_STATIC_SETTER_FUNCTION =
1254 InternedV8JsFunction_Kind_KIND_STATIC_SETTER_FUNCTION;
1255 static constexpr Kind KIND_ARROW_FUNCTION =
1256 InternedV8JsFunction_Kind_KIND_ARROW_FUNCTION;
1257 static constexpr Kind KIND_ASYNC_ARROW_FUNCTION =
1258 InternedV8JsFunction_Kind_KIND_ASYNC_ARROW_FUNCTION;
1259 static constexpr Kind KIND_ASYNC_FUNCTION =
1260 InternedV8JsFunction_Kind_KIND_ASYNC_FUNCTION;
1261 static constexpr Kind KIND_ASYNC_CONCISE_METHOD =
1262 InternedV8JsFunction_Kind_KIND_ASYNC_CONCISE_METHOD;
1263 static constexpr Kind KIND_STATIC_ASYNC_CONCISE_METHOD =
1264 InternedV8JsFunction_Kind_KIND_STATIC_ASYNC_CONCISE_METHOD;
1265 static constexpr Kind KIND_ASYNC_CONCISE_GENERATOR_METHOD =
1266 InternedV8JsFunction_Kind_KIND_ASYNC_CONCISE_GENERATOR_METHOD;
1267 static constexpr Kind KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD =
1268 InternedV8JsFunction_Kind_KIND_STATIC_ASYNC_CONCISE_GENERATOR_METHOD;
1269 static constexpr Kind KIND_ASYNC_GENERATOR_FUNCTION =
1270 InternedV8JsFunction_Kind_KIND_ASYNC_GENERATOR_FUNCTION;
1271 static constexpr Kind KIND_GENERATOR_FUNCTION =
1272 InternedV8JsFunction_Kind_KIND_GENERATOR_FUNCTION;
1273 static constexpr Kind KIND_CONCISE_GENERATOR_METHOD =
1274 InternedV8JsFunction_Kind_KIND_CONCISE_GENERATOR_METHOD;
1275 static constexpr Kind KIND_STATIC_CONCISE_GENERATOR_METHOD =
1276 InternedV8JsFunction_Kind_KIND_STATIC_CONCISE_GENERATOR_METHOD;
1277 static constexpr Kind KIND_CONCISE_METHOD =
1278 InternedV8JsFunction_Kind_KIND_CONCISE_METHOD;
1279 static constexpr Kind KIND_STATIC_CONCISE_METHOD =
1280 InternedV8JsFunction_Kind_KIND_STATIC_CONCISE_METHOD;
1281 static constexpr Kind KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION =
1282 InternedV8JsFunction_Kind_KIND_CLASS_MEMBERS_INITIALIZER_FUNCTION;
1283 static constexpr Kind KIND_CLASS_STATIC_INITIALIZER_FUNCTION =
1284 InternedV8JsFunction_Kind_KIND_CLASS_STATIC_INITIALIZER_FUNCTION;
1285 static constexpr Kind KIND_INVALID =
1286 InternedV8JsFunction_Kind_KIND_INVALID;
1287 static inline bool Kind_IsValid(int value) {
1288 return InternedV8JsFunction_Kind_IsValid(value);
1289 }
1290 static constexpr Kind Kind_MIN =
1291 InternedV8JsFunction_Kind_Kind_MIN;
1292 static constexpr Kind Kind_MAX =
1293 InternedV8JsFunction_Kind_Kind_MAX;
1294 static constexpr int Kind_ARRAYSIZE =
1295 InternedV8JsFunction_Kind_Kind_ARRAYSIZE;
1296 template<typename T>
1297 static inline const std::string& Kind_Name(T enum_t_value) {
1298 static_assert(::std::is_same<T, Kind>::value ||
1299 ::std::is_integral<T>::value,
1300 "Incorrect type passed to function Kind_Name.");
1301 return InternedV8JsFunction_Kind_Name(enum_t_value);
1302 }
1303 static inline bool Kind_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1304 Kind* value) {
1305 return InternedV8JsFunction_Kind_Parse(name, value);
1306 }
1307
1308 // accessors -------------------------------------------------------
1309
1310 enum : int {
1311 kIidFieldNumber = 1,
1312 kV8JsFunctionNameIidFieldNumber = 2,
1313 kV8JsScriptIidFieldNumber = 3,
1314 kIsToplevelFieldNumber = 4,
1315 kKindFieldNumber = 5,
1316 kByteOffsetFieldNumber = 6,
1317 };
1318 // optional uint64 iid = 1;
1319 bool has_iid() const;
1320 private:
1321 bool _internal_has_iid() const;
1322 public:
1323 void clear_iid();
1324 ::uint64_t iid() const;
1325 void set_iid(::uint64_t value);
1326 private:
1327 ::uint64_t _internal_iid() const;
1328 void _internal_set_iid(::uint64_t value);
1329 public:
1330
1331 // optional uint64 v8_js_function_name_iid = 2;
1332 bool has_v8_js_function_name_iid() const;
1333 private:
1334 bool _internal_has_v8_js_function_name_iid() const;
1335 public:
1336 void clear_v8_js_function_name_iid();
1337 ::uint64_t v8_js_function_name_iid() const;
1338 void set_v8_js_function_name_iid(::uint64_t value);
1339 private:
1340 ::uint64_t _internal_v8_js_function_name_iid() const;
1341 void _internal_set_v8_js_function_name_iid(::uint64_t value);
1342 public:
1343
1344 // optional uint64 v8_js_script_iid = 3;
1345 bool has_v8_js_script_iid() const;
1346 private:
1347 bool _internal_has_v8_js_script_iid() const;
1348 public:
1349 void clear_v8_js_script_iid();
1350 ::uint64_t v8_js_script_iid() const;
1351 void set_v8_js_script_iid(::uint64_t value);
1352 private:
1353 ::uint64_t _internal_v8_js_script_iid() const;
1354 void _internal_set_v8_js_script_iid(::uint64_t value);
1355 public:
1356
1357 // optional bool is_toplevel = 4;
1358 bool has_is_toplevel() const;
1359 private:
1360 bool _internal_has_is_toplevel() const;
1361 public:
1362 void clear_is_toplevel();
1363 bool is_toplevel() const;
1364 void set_is_toplevel(bool value);
1365 private:
1366 bool _internal_is_toplevel() const;
1367 void _internal_set_is_toplevel(bool value);
1368 public:
1369
1370 // optional .perfetto.protos.InternedV8JsFunction.Kind kind = 5;
1371 bool has_kind() const;
1372 private:
1373 bool _internal_has_kind() const;
1374 public:
1375 void clear_kind();
1376 ::perfetto::protos::InternedV8JsFunction_Kind kind() const;
1377 void set_kind(::perfetto::protos::InternedV8JsFunction_Kind value);
1378 private:
1379 ::perfetto::protos::InternedV8JsFunction_Kind _internal_kind() const;
1380 void _internal_set_kind(::perfetto::protos::InternedV8JsFunction_Kind value);
1381 public:
1382
1383 // optional uint32 byte_offset = 6;
1384 bool has_byte_offset() const;
1385 private:
1386 bool _internal_has_byte_offset() const;
1387 public:
1388 void clear_byte_offset();
1389 ::uint32_t byte_offset() const;
1390 void set_byte_offset(::uint32_t value);
1391 private:
1392 ::uint32_t _internal_byte_offset() const;
1393 void _internal_set_byte_offset(::uint32_t value);
1394 public:
1395
1396 // @@protoc_insertion_point(class_scope:perfetto.protos.InternedV8JsFunction)
1397 private:
1398 class _Internal;
1399
1400 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1401 typedef void InternalArenaConstructable_;
1402 typedef void DestructorSkippable_;
1403 struct Impl_ {
1404 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1405 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1406 ::uint64_t iid_;
1407 ::uint64_t v8_js_function_name_iid_;
1408 ::uint64_t v8_js_script_iid_;
1409 bool is_toplevel_;
1410 int kind_;
1411 ::uint32_t byte_offset_;
1412 };
1413 union { Impl_ _impl_; };
1414 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
1415 };
1416 // -------------------------------------------------------------------
1417
1418 class InternedV8Isolate_CodeRange final :
1419 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.InternedV8Isolate.CodeRange) */ {
1420 public:
InternedV8Isolate_CodeRange()1421 inline InternedV8Isolate_CodeRange() : InternedV8Isolate_CodeRange(nullptr) {}
1422 ~InternedV8Isolate_CodeRange() override;
1423 explicit PROTOBUF_CONSTEXPR InternedV8Isolate_CodeRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1424
1425 InternedV8Isolate_CodeRange(const InternedV8Isolate_CodeRange& from);
InternedV8Isolate_CodeRange(InternedV8Isolate_CodeRange && from)1426 InternedV8Isolate_CodeRange(InternedV8Isolate_CodeRange&& from) noexcept
1427 : InternedV8Isolate_CodeRange() {
1428 *this = ::std::move(from);
1429 }
1430
1431 inline InternedV8Isolate_CodeRange& operator=(const InternedV8Isolate_CodeRange& from) {
1432 if (this == &from) return *this;
1433 CopyFrom(from);
1434 return *this;
1435 }
1436 inline InternedV8Isolate_CodeRange& operator=(InternedV8Isolate_CodeRange&& from) noexcept {
1437 if (this == &from) return *this;
1438 if (GetOwningArena() == from.GetOwningArena()
1439 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1440 && GetOwningArena() != nullptr
1441 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1442 ) {
1443 InternalSwap(&from);
1444 } else {
1445 CopyFrom(from);
1446 }
1447 return *this;
1448 }
1449
unknown_fields()1450 inline const std::string& unknown_fields() const {
1451 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1452 }
mutable_unknown_fields()1453 inline std::string* mutable_unknown_fields() {
1454 return _internal_metadata_.mutable_unknown_fields<std::string>();
1455 }
1456
default_instance()1457 static const InternedV8Isolate_CodeRange& default_instance() {
1458 return *internal_default_instance();
1459 }
internal_default_instance()1460 static inline const InternedV8Isolate_CodeRange* internal_default_instance() {
1461 return reinterpret_cast<const InternedV8Isolate_CodeRange*>(
1462 &_InternedV8Isolate_CodeRange_default_instance_);
1463 }
1464 static constexpr int kIndexInFileMessages =
1465 5;
1466
swap(InternedV8Isolate_CodeRange & a,InternedV8Isolate_CodeRange & b)1467 friend void swap(InternedV8Isolate_CodeRange& a, InternedV8Isolate_CodeRange& b) {
1468 a.Swap(&b);
1469 }
Swap(InternedV8Isolate_CodeRange * other)1470 inline void Swap(InternedV8Isolate_CodeRange* other) {
1471 if (other == this) return;
1472 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1473 if (GetOwningArena() != nullptr &&
1474 GetOwningArena() == other->GetOwningArena()) {
1475 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1476 if (GetOwningArena() == other->GetOwningArena()) {
1477 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1478 InternalSwap(other);
1479 } else {
1480 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1481 }
1482 }
1483 void UnsafeArenaSwap(InternedV8Isolate_CodeRange* other) {
1484 if (other == this) return;
1485 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1486 InternalSwap(other);
1487 }
1488
1489 // implements Message ----------------------------------------------
1490
1491 InternedV8Isolate_CodeRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1492 return CreateMaybeMessage<InternedV8Isolate_CodeRange>(arena);
1493 }
1494 InternedV8Isolate_CodeRange* New() const {
1495 return New(nullptr);
1496 }
1497 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1498 void CopyFrom(const InternedV8Isolate_CodeRange& from);
1499 void MergeFrom(const InternedV8Isolate_CodeRange& from);
1500 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1501 bool IsInitialized() const final;
1502
1503 size_t ByteSizeLong() const final;
1504 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1505 ::uint8_t* _InternalSerialize(
1506 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1507 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1508
1509 private:
1510 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1511 void SharedDtor();
1512 void SetCachedSize(int size) const;
1513 void InternalSwap(InternedV8Isolate_CodeRange* other);
1514
1515 private:
1516 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1517 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1518 return "perfetto.protos.InternedV8Isolate.CodeRange";
1519 }
1520 protected:
1521 explicit InternedV8Isolate_CodeRange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1522 bool is_message_owned = false);
1523 public:
1524
1525 std::string GetTypeName() const final;
1526
1527 // nested types ----------------------------------------------------
1528
1529 // accessors -------------------------------------------------------
1530
1531 enum : int {
1532 kBaseAddressFieldNumber = 1,
1533 kSizeFieldNumber = 2,
1534 kEmbeddedBlobCodeCopyStartAddressFieldNumber = 3,
1535 kIsProcessWideFieldNumber = 4,
1536 };
1537 // optional uint64 base_address = 1;
1538 bool has_base_address() const;
1539 private:
1540 bool _internal_has_base_address() const;
1541 public:
1542 void clear_base_address();
1543 ::uint64_t base_address() const;
1544 void set_base_address(::uint64_t value);
1545 private:
1546 ::uint64_t _internal_base_address() const;
1547 void _internal_set_base_address(::uint64_t value);
1548 public:
1549
1550 // optional uint64 size = 2;
1551 bool has_size() const;
1552 private:
1553 bool _internal_has_size() const;
1554 public:
1555 void clear_size();
1556 ::uint64_t size() const;
1557 void set_size(::uint64_t value);
1558 private:
1559 ::uint64_t _internal_size() const;
1560 void _internal_set_size(::uint64_t value);
1561 public:
1562
1563 // optional uint64 embedded_blob_code_copy_start_address = 3;
1564 bool has_embedded_blob_code_copy_start_address() const;
1565 private:
1566 bool _internal_has_embedded_blob_code_copy_start_address() const;
1567 public:
1568 void clear_embedded_blob_code_copy_start_address();
1569 ::uint64_t embedded_blob_code_copy_start_address() const;
1570 void set_embedded_blob_code_copy_start_address(::uint64_t value);
1571 private:
1572 ::uint64_t _internal_embedded_blob_code_copy_start_address() const;
1573 void _internal_set_embedded_blob_code_copy_start_address(::uint64_t value);
1574 public:
1575
1576 // optional bool is_process_wide = 4;
1577 bool has_is_process_wide() const;
1578 private:
1579 bool _internal_has_is_process_wide() const;
1580 public:
1581 void clear_is_process_wide();
1582 bool is_process_wide() const;
1583 void set_is_process_wide(bool value);
1584 private:
1585 bool _internal_is_process_wide() const;
1586 void _internal_set_is_process_wide(bool value);
1587 public:
1588
1589 // @@protoc_insertion_point(class_scope:perfetto.protos.InternedV8Isolate.CodeRange)
1590 private:
1591 class _Internal;
1592
1593 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1594 typedef void InternalArenaConstructable_;
1595 typedef void DestructorSkippable_;
1596 struct Impl_ {
1597 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1598 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1599 ::uint64_t base_address_;
1600 ::uint64_t size_;
1601 ::uint64_t embedded_blob_code_copy_start_address_;
1602 bool is_process_wide_;
1603 };
1604 union { Impl_ _impl_; };
1605 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
1606 };
1607 // -------------------------------------------------------------------
1608
1609 class InternedV8Isolate final :
1610 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.InternedV8Isolate) */ {
1611 public:
InternedV8Isolate()1612 inline InternedV8Isolate() : InternedV8Isolate(nullptr) {}
1613 ~InternedV8Isolate() override;
1614 explicit PROTOBUF_CONSTEXPR InternedV8Isolate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1615
1616 InternedV8Isolate(const InternedV8Isolate& from);
InternedV8Isolate(InternedV8Isolate && from)1617 InternedV8Isolate(InternedV8Isolate&& from) noexcept
1618 : InternedV8Isolate() {
1619 *this = ::std::move(from);
1620 }
1621
1622 inline InternedV8Isolate& operator=(const InternedV8Isolate& from) {
1623 if (this == &from) return *this;
1624 CopyFrom(from);
1625 return *this;
1626 }
1627 inline InternedV8Isolate& operator=(InternedV8Isolate&& from) noexcept {
1628 if (this == &from) return *this;
1629 if (GetOwningArena() == from.GetOwningArena()
1630 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1631 && GetOwningArena() != nullptr
1632 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1633 ) {
1634 InternalSwap(&from);
1635 } else {
1636 CopyFrom(from);
1637 }
1638 return *this;
1639 }
1640
unknown_fields()1641 inline const std::string& unknown_fields() const {
1642 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1643 }
mutable_unknown_fields()1644 inline std::string* mutable_unknown_fields() {
1645 return _internal_metadata_.mutable_unknown_fields<std::string>();
1646 }
1647
default_instance()1648 static const InternedV8Isolate& default_instance() {
1649 return *internal_default_instance();
1650 }
internal_default_instance()1651 static inline const InternedV8Isolate* internal_default_instance() {
1652 return reinterpret_cast<const InternedV8Isolate*>(
1653 &_InternedV8Isolate_default_instance_);
1654 }
1655 static constexpr int kIndexInFileMessages =
1656 6;
1657
swap(InternedV8Isolate & a,InternedV8Isolate & b)1658 friend void swap(InternedV8Isolate& a, InternedV8Isolate& b) {
1659 a.Swap(&b);
1660 }
Swap(InternedV8Isolate * other)1661 inline void Swap(InternedV8Isolate* other) {
1662 if (other == this) return;
1663 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1664 if (GetOwningArena() != nullptr &&
1665 GetOwningArena() == other->GetOwningArena()) {
1666 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1667 if (GetOwningArena() == other->GetOwningArena()) {
1668 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1669 InternalSwap(other);
1670 } else {
1671 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1672 }
1673 }
1674 void UnsafeArenaSwap(InternedV8Isolate* other) {
1675 if (other == this) return;
1676 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1677 InternalSwap(other);
1678 }
1679
1680 // implements Message ----------------------------------------------
1681
1682 InternedV8Isolate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1683 return CreateMaybeMessage<InternedV8Isolate>(arena);
1684 }
1685 InternedV8Isolate* New() const {
1686 return New(nullptr);
1687 }
1688 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1689 void CopyFrom(const InternedV8Isolate& from);
1690 void MergeFrom(const InternedV8Isolate& from);
1691 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1692 bool IsInitialized() const final;
1693
1694 size_t ByteSizeLong() const final;
1695 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1696 ::uint8_t* _InternalSerialize(
1697 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1698 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1699
1700 private:
1701 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1702 void SharedDtor();
1703 void SetCachedSize(int size) const;
1704 void InternalSwap(InternedV8Isolate* other);
1705
1706 private:
1707 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1708 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1709 return "perfetto.protos.InternedV8Isolate";
1710 }
1711 protected:
1712 explicit InternedV8Isolate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1713 bool is_message_owned = false);
1714 public:
1715
1716 std::string GetTypeName() const final;
1717
1718 // nested types ----------------------------------------------------
1719
1720 typedef InternedV8Isolate_CodeRange CodeRange;
1721
1722 // accessors -------------------------------------------------------
1723
1724 enum : int {
1725 kCodeRangeFieldNumber = 4,
1726 kIidFieldNumber = 1,
1727 kPidFieldNumber = 2,
1728 kIsolateIdFieldNumber = 3,
1729 kEmbeddedBlobCodeStartAddressFieldNumber = 5,
1730 kEmbeddedBlobCodeSizeFieldNumber = 6,
1731 };
1732 // optional .perfetto.protos.InternedV8Isolate.CodeRange code_range = 4;
1733 bool has_code_range() const;
1734 private:
1735 bool _internal_has_code_range() const;
1736 public:
1737 void clear_code_range();
1738 const ::perfetto::protos::InternedV8Isolate_CodeRange& code_range() const;
1739 PROTOBUF_NODISCARD ::perfetto::protos::InternedV8Isolate_CodeRange* release_code_range();
1740 ::perfetto::protos::InternedV8Isolate_CodeRange* mutable_code_range();
1741 void set_allocated_code_range(::perfetto::protos::InternedV8Isolate_CodeRange* code_range);
1742 private:
1743 const ::perfetto::protos::InternedV8Isolate_CodeRange& _internal_code_range() const;
1744 ::perfetto::protos::InternedV8Isolate_CodeRange* _internal_mutable_code_range();
1745 public:
1746 void unsafe_arena_set_allocated_code_range(
1747 ::perfetto::protos::InternedV8Isolate_CodeRange* code_range);
1748 ::perfetto::protos::InternedV8Isolate_CodeRange* unsafe_arena_release_code_range();
1749
1750 // optional uint64 iid = 1;
1751 bool has_iid() const;
1752 private:
1753 bool _internal_has_iid() const;
1754 public:
1755 void clear_iid();
1756 ::uint64_t iid() const;
1757 void set_iid(::uint64_t value);
1758 private:
1759 ::uint64_t _internal_iid() const;
1760 void _internal_set_iid(::uint64_t value);
1761 public:
1762
1763 // optional uint32 pid = 2;
1764 bool has_pid() const;
1765 private:
1766 bool _internal_has_pid() const;
1767 public:
1768 void clear_pid();
1769 ::uint32_t pid() const;
1770 void set_pid(::uint32_t value);
1771 private:
1772 ::uint32_t _internal_pid() const;
1773 void _internal_set_pid(::uint32_t value);
1774 public:
1775
1776 // optional int32 isolate_id = 3;
1777 bool has_isolate_id() const;
1778 private:
1779 bool _internal_has_isolate_id() const;
1780 public:
1781 void clear_isolate_id();
1782 ::int32_t isolate_id() const;
1783 void set_isolate_id(::int32_t value);
1784 private:
1785 ::int32_t _internal_isolate_id() const;
1786 void _internal_set_isolate_id(::int32_t value);
1787 public:
1788
1789 // optional uint64 embedded_blob_code_start_address = 5;
1790 bool has_embedded_blob_code_start_address() const;
1791 private:
1792 bool _internal_has_embedded_blob_code_start_address() const;
1793 public:
1794 void clear_embedded_blob_code_start_address();
1795 ::uint64_t embedded_blob_code_start_address() const;
1796 void set_embedded_blob_code_start_address(::uint64_t value);
1797 private:
1798 ::uint64_t _internal_embedded_blob_code_start_address() const;
1799 void _internal_set_embedded_blob_code_start_address(::uint64_t value);
1800 public:
1801
1802 // optional uint64 embedded_blob_code_size = 6;
1803 bool has_embedded_blob_code_size() const;
1804 private:
1805 bool _internal_has_embedded_blob_code_size() const;
1806 public:
1807 void clear_embedded_blob_code_size();
1808 ::uint64_t embedded_blob_code_size() const;
1809 void set_embedded_blob_code_size(::uint64_t value);
1810 private:
1811 ::uint64_t _internal_embedded_blob_code_size() const;
1812 void _internal_set_embedded_blob_code_size(::uint64_t value);
1813 public:
1814
1815 // @@protoc_insertion_point(class_scope:perfetto.protos.InternedV8Isolate)
1816 private:
1817 class _Internal;
1818
1819 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1820 typedef void InternalArenaConstructable_;
1821 typedef void DestructorSkippable_;
1822 struct Impl_ {
1823 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1824 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1825 ::perfetto::protos::InternedV8Isolate_CodeRange* code_range_;
1826 ::uint64_t iid_;
1827 ::uint32_t pid_;
1828 ::int32_t isolate_id_;
1829 ::uint64_t embedded_blob_code_start_address_;
1830 ::uint64_t embedded_blob_code_size_;
1831 };
1832 union { Impl_ _impl_; };
1833 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
1834 };
1835 // -------------------------------------------------------------------
1836
1837 class V8JsCode final :
1838 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8JsCode) */ {
1839 public:
V8JsCode()1840 inline V8JsCode() : V8JsCode(nullptr) {}
1841 ~V8JsCode() override;
1842 explicit PROTOBUF_CONSTEXPR V8JsCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1843
1844 V8JsCode(const V8JsCode& from);
V8JsCode(V8JsCode && from)1845 V8JsCode(V8JsCode&& from) noexcept
1846 : V8JsCode() {
1847 *this = ::std::move(from);
1848 }
1849
1850 inline V8JsCode& operator=(const V8JsCode& from) {
1851 if (this == &from) return *this;
1852 CopyFrom(from);
1853 return *this;
1854 }
1855 inline V8JsCode& operator=(V8JsCode&& from) noexcept {
1856 if (this == &from) return *this;
1857 if (GetOwningArena() == from.GetOwningArena()
1858 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1859 && GetOwningArena() != nullptr
1860 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1861 ) {
1862 InternalSwap(&from);
1863 } else {
1864 CopyFrom(from);
1865 }
1866 return *this;
1867 }
1868
unknown_fields()1869 inline const std::string& unknown_fields() const {
1870 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1871 }
mutable_unknown_fields()1872 inline std::string* mutable_unknown_fields() {
1873 return _internal_metadata_.mutable_unknown_fields<std::string>();
1874 }
1875
default_instance()1876 static const V8JsCode& default_instance() {
1877 return *internal_default_instance();
1878 }
1879 enum InstructionsCase {
1880 kMachineCode = 7,
1881 kBytecode = 8,
1882 INSTRUCTIONS_NOT_SET = 0,
1883 };
1884
internal_default_instance()1885 static inline const V8JsCode* internal_default_instance() {
1886 return reinterpret_cast<const V8JsCode*>(
1887 &_V8JsCode_default_instance_);
1888 }
1889 static constexpr int kIndexInFileMessages =
1890 7;
1891
swap(V8JsCode & a,V8JsCode & b)1892 friend void swap(V8JsCode& a, V8JsCode& b) {
1893 a.Swap(&b);
1894 }
Swap(V8JsCode * other)1895 inline void Swap(V8JsCode* other) {
1896 if (other == this) return;
1897 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1898 if (GetOwningArena() != nullptr &&
1899 GetOwningArena() == other->GetOwningArena()) {
1900 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1901 if (GetOwningArena() == other->GetOwningArena()) {
1902 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1903 InternalSwap(other);
1904 } else {
1905 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1906 }
1907 }
1908 void UnsafeArenaSwap(V8JsCode* other) {
1909 if (other == this) return;
1910 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1911 InternalSwap(other);
1912 }
1913
1914 // implements Message ----------------------------------------------
1915
1916 V8JsCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1917 return CreateMaybeMessage<V8JsCode>(arena);
1918 }
1919 V8JsCode* New() const {
1920 return New(nullptr);
1921 }
1922 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1923 void CopyFrom(const V8JsCode& from);
1924 void MergeFrom(const V8JsCode& from);
1925 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1926 bool IsInitialized() const final;
1927
1928 size_t ByteSizeLong() const final;
1929 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1930 ::uint8_t* _InternalSerialize(
1931 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1932 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1933
1934 private:
1935 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1936 void SharedDtor();
1937 void SetCachedSize(int size) const;
1938 void InternalSwap(V8JsCode* other);
1939
1940 private:
1941 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1942 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1943 return "perfetto.protos.V8JsCode";
1944 }
1945 protected:
1946 explicit V8JsCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1947 bool is_message_owned = false);
1948 public:
1949
1950 std::string GetTypeName() const final;
1951
1952 // nested types ----------------------------------------------------
1953
1954 typedef V8JsCode_Tier Tier;
1955 static constexpr Tier TIER_UNKNOWN =
1956 V8JsCode_Tier_TIER_UNKNOWN;
1957 static constexpr Tier TIER_IGNITION =
1958 V8JsCode_Tier_TIER_IGNITION;
1959 static constexpr Tier TIER_SPARKPLUG =
1960 V8JsCode_Tier_TIER_SPARKPLUG;
1961 static constexpr Tier TIER_MAGLEV =
1962 V8JsCode_Tier_TIER_MAGLEV;
1963 static constexpr Tier TIER_TURBOSHAFT =
1964 V8JsCode_Tier_TIER_TURBOSHAFT;
1965 static constexpr Tier TIER_TURBOFAN =
1966 V8JsCode_Tier_TIER_TURBOFAN;
1967 static inline bool Tier_IsValid(int value) {
1968 return V8JsCode_Tier_IsValid(value);
1969 }
1970 static constexpr Tier Tier_MIN =
1971 V8JsCode_Tier_Tier_MIN;
1972 static constexpr Tier Tier_MAX =
1973 V8JsCode_Tier_Tier_MAX;
1974 static constexpr int Tier_ARRAYSIZE =
1975 V8JsCode_Tier_Tier_ARRAYSIZE;
1976 template<typename T>
1977 static inline const std::string& Tier_Name(T enum_t_value) {
1978 static_assert(::std::is_same<T, Tier>::value ||
1979 ::std::is_integral<T>::value,
1980 "Incorrect type passed to function Tier_Name.");
1981 return V8JsCode_Tier_Name(enum_t_value);
1982 }
1983 static inline bool Tier_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1984 Tier* value) {
1985 return V8JsCode_Tier_Parse(name, value);
1986 }
1987
1988 // accessors -------------------------------------------------------
1989
1990 enum : int {
1991 kV8IsolateIidFieldNumber = 1,
1992 kV8JsFunctionIidFieldNumber = 3,
1993 kTidFieldNumber = 2,
1994 kTierFieldNumber = 4,
1995 kInstructionStartFieldNumber = 5,
1996 kInstructionSizeBytesFieldNumber = 6,
1997 kMachineCodeFieldNumber = 7,
1998 kBytecodeFieldNumber = 8,
1999 };
2000 // optional uint64 v8_isolate_iid = 1;
2001 bool has_v8_isolate_iid() const;
2002 private:
2003 bool _internal_has_v8_isolate_iid() const;
2004 public:
2005 void clear_v8_isolate_iid();
2006 ::uint64_t v8_isolate_iid() const;
2007 void set_v8_isolate_iid(::uint64_t value);
2008 private:
2009 ::uint64_t _internal_v8_isolate_iid() const;
2010 void _internal_set_v8_isolate_iid(::uint64_t value);
2011 public:
2012
2013 // optional uint64 v8_js_function_iid = 3;
2014 bool has_v8_js_function_iid() const;
2015 private:
2016 bool _internal_has_v8_js_function_iid() const;
2017 public:
2018 void clear_v8_js_function_iid();
2019 ::uint64_t v8_js_function_iid() const;
2020 void set_v8_js_function_iid(::uint64_t value);
2021 private:
2022 ::uint64_t _internal_v8_js_function_iid() const;
2023 void _internal_set_v8_js_function_iid(::uint64_t value);
2024 public:
2025
2026 // optional uint32 tid = 2;
2027 bool has_tid() const;
2028 private:
2029 bool _internal_has_tid() const;
2030 public:
2031 void clear_tid();
2032 ::uint32_t tid() const;
2033 void set_tid(::uint32_t value);
2034 private:
2035 ::uint32_t _internal_tid() const;
2036 void _internal_set_tid(::uint32_t value);
2037 public:
2038
2039 // optional .perfetto.protos.V8JsCode.Tier tier = 4;
2040 bool has_tier() const;
2041 private:
2042 bool _internal_has_tier() const;
2043 public:
2044 void clear_tier();
2045 ::perfetto::protos::V8JsCode_Tier tier() const;
2046 void set_tier(::perfetto::protos::V8JsCode_Tier value);
2047 private:
2048 ::perfetto::protos::V8JsCode_Tier _internal_tier() const;
2049 void _internal_set_tier(::perfetto::protos::V8JsCode_Tier value);
2050 public:
2051
2052 // optional uint64 instruction_start = 5;
2053 bool has_instruction_start() const;
2054 private:
2055 bool _internal_has_instruction_start() const;
2056 public:
2057 void clear_instruction_start();
2058 ::uint64_t instruction_start() const;
2059 void set_instruction_start(::uint64_t value);
2060 private:
2061 ::uint64_t _internal_instruction_start() const;
2062 void _internal_set_instruction_start(::uint64_t value);
2063 public:
2064
2065 // optional uint64 instruction_size_bytes = 6;
2066 bool has_instruction_size_bytes() const;
2067 private:
2068 bool _internal_has_instruction_size_bytes() const;
2069 public:
2070 void clear_instruction_size_bytes();
2071 ::uint64_t instruction_size_bytes() const;
2072 void set_instruction_size_bytes(::uint64_t value);
2073 private:
2074 ::uint64_t _internal_instruction_size_bytes() const;
2075 void _internal_set_instruction_size_bytes(::uint64_t value);
2076 public:
2077
2078 // bytes machine_code = 7;
2079 bool has_machine_code() const;
2080 private:
2081 bool _internal_has_machine_code() const;
2082 public:
2083 void clear_machine_code();
2084 const std::string& machine_code() const;
2085 template <typename ArgT0 = const std::string&, typename... ArgT>
2086 void set_machine_code(ArgT0&& arg0, ArgT... args);
2087 std::string* mutable_machine_code();
2088 PROTOBUF_NODISCARD std::string* release_machine_code();
2089 void set_allocated_machine_code(std::string* machine_code);
2090 private:
2091 const std::string& _internal_machine_code() const;
2092 inline PROTOBUF_ALWAYS_INLINE void _internal_set_machine_code(const std::string& value);
2093 std::string* _internal_mutable_machine_code();
2094 public:
2095
2096 // bytes bytecode = 8;
2097 bool has_bytecode() const;
2098 private:
2099 bool _internal_has_bytecode() const;
2100 public:
2101 void clear_bytecode();
2102 const std::string& bytecode() const;
2103 template <typename ArgT0 = const std::string&, typename... ArgT>
2104 void set_bytecode(ArgT0&& arg0, ArgT... args);
2105 std::string* mutable_bytecode();
2106 PROTOBUF_NODISCARD std::string* release_bytecode();
2107 void set_allocated_bytecode(std::string* bytecode);
2108 private:
2109 const std::string& _internal_bytecode() const;
2110 inline PROTOBUF_ALWAYS_INLINE void _internal_set_bytecode(const std::string& value);
2111 std::string* _internal_mutable_bytecode();
2112 public:
2113
2114 void clear_instructions();
2115 InstructionsCase instructions_case() const;
2116 // @@protoc_insertion_point(class_scope:perfetto.protos.V8JsCode)
2117 private:
2118 class _Internal;
2119 void set_has_machine_code();
2120 void set_has_bytecode();
2121
2122 inline bool has_instructions() const;
2123 inline void clear_has_instructions();
2124
2125 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2126 typedef void InternalArenaConstructable_;
2127 typedef void DestructorSkippable_;
2128 struct Impl_ {
2129 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2130 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2131 ::uint64_t v8_isolate_iid_;
2132 ::uint64_t v8_js_function_iid_;
2133 ::uint32_t tid_;
2134 int tier_;
2135 ::uint64_t instruction_start_;
2136 ::uint64_t instruction_size_bytes_;
2137 union InstructionsUnion {
2138 constexpr InstructionsUnion() : _constinit_{} {}
2139 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2140 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_code_;
2141 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr bytecode_;
2142 } instructions_;
2143 ::uint32_t _oneof_case_[1];
2144
2145 };
2146 union { Impl_ _impl_; };
2147 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
2148 };
2149 // -------------------------------------------------------------------
2150
2151 class V8InternalCode final :
2152 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8InternalCode) */ {
2153 public:
V8InternalCode()2154 inline V8InternalCode() : V8InternalCode(nullptr) {}
2155 ~V8InternalCode() override;
2156 explicit PROTOBUF_CONSTEXPR V8InternalCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2157
2158 V8InternalCode(const V8InternalCode& from);
V8InternalCode(V8InternalCode && from)2159 V8InternalCode(V8InternalCode&& from) noexcept
2160 : V8InternalCode() {
2161 *this = ::std::move(from);
2162 }
2163
2164 inline V8InternalCode& operator=(const V8InternalCode& from) {
2165 if (this == &from) return *this;
2166 CopyFrom(from);
2167 return *this;
2168 }
2169 inline V8InternalCode& operator=(V8InternalCode&& from) noexcept {
2170 if (this == &from) return *this;
2171 if (GetOwningArena() == from.GetOwningArena()
2172 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2173 && GetOwningArena() != nullptr
2174 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2175 ) {
2176 InternalSwap(&from);
2177 } else {
2178 CopyFrom(from);
2179 }
2180 return *this;
2181 }
2182
unknown_fields()2183 inline const std::string& unknown_fields() const {
2184 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2185 }
mutable_unknown_fields()2186 inline std::string* mutable_unknown_fields() {
2187 return _internal_metadata_.mutable_unknown_fields<std::string>();
2188 }
2189
default_instance()2190 static const V8InternalCode& default_instance() {
2191 return *internal_default_instance();
2192 }
internal_default_instance()2193 static inline const V8InternalCode* internal_default_instance() {
2194 return reinterpret_cast<const V8InternalCode*>(
2195 &_V8InternalCode_default_instance_);
2196 }
2197 static constexpr int kIndexInFileMessages =
2198 8;
2199
swap(V8InternalCode & a,V8InternalCode & b)2200 friend void swap(V8InternalCode& a, V8InternalCode& b) {
2201 a.Swap(&b);
2202 }
Swap(V8InternalCode * other)2203 inline void Swap(V8InternalCode* other) {
2204 if (other == this) return;
2205 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2206 if (GetOwningArena() != nullptr &&
2207 GetOwningArena() == other->GetOwningArena()) {
2208 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2209 if (GetOwningArena() == other->GetOwningArena()) {
2210 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2211 InternalSwap(other);
2212 } else {
2213 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2214 }
2215 }
2216 void UnsafeArenaSwap(V8InternalCode* other) {
2217 if (other == this) return;
2218 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2219 InternalSwap(other);
2220 }
2221
2222 // implements Message ----------------------------------------------
2223
2224 V8InternalCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2225 return CreateMaybeMessage<V8InternalCode>(arena);
2226 }
2227 V8InternalCode* New() const {
2228 return New(nullptr);
2229 }
2230 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2231 void CopyFrom(const V8InternalCode& from);
2232 void MergeFrom(const V8InternalCode& from);
2233 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2234 bool IsInitialized() const final;
2235
2236 size_t ByteSizeLong() const final;
2237 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2238 ::uint8_t* _InternalSerialize(
2239 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2240 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2241
2242 private:
2243 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2244 void SharedDtor();
2245 void SetCachedSize(int size) const;
2246 void InternalSwap(V8InternalCode* other);
2247
2248 private:
2249 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2250 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2251 return "perfetto.protos.V8InternalCode";
2252 }
2253 protected:
2254 explicit V8InternalCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2255 bool is_message_owned = false);
2256 public:
2257
2258 std::string GetTypeName() const final;
2259
2260 // nested types ----------------------------------------------------
2261
2262 typedef V8InternalCode_Type Type;
2263 static constexpr Type TYPE_UNKNOWN =
2264 V8InternalCode_Type_TYPE_UNKNOWN;
2265 static constexpr Type TYPE_BYTECODE_HANDLER =
2266 V8InternalCode_Type_TYPE_BYTECODE_HANDLER;
2267 static constexpr Type TYPE_FOR_TESTING =
2268 V8InternalCode_Type_TYPE_FOR_TESTING;
2269 static constexpr Type TYPE_BUILTIN =
2270 V8InternalCode_Type_TYPE_BUILTIN;
2271 static constexpr Type TYPE_WASM_FUNCTION =
2272 V8InternalCode_Type_TYPE_WASM_FUNCTION;
2273 static constexpr Type TYPE_WASM_TO_CAPI_FUNCTION =
2274 V8InternalCode_Type_TYPE_WASM_TO_CAPI_FUNCTION;
2275 static constexpr Type TYPE_WASM_TO_JS_FUNCTION =
2276 V8InternalCode_Type_TYPE_WASM_TO_JS_FUNCTION;
2277 static constexpr Type TYPE_JS_TO_WASM_FUNCTION =
2278 V8InternalCode_Type_TYPE_JS_TO_WASM_FUNCTION;
2279 static constexpr Type TYPE_JS_TO_JS_FUNCTION =
2280 V8InternalCode_Type_TYPE_JS_TO_JS_FUNCTION;
2281 static constexpr Type TYPE_C_WASM_ENTRY =
2282 V8InternalCode_Type_TYPE_C_WASM_ENTRY;
2283 static inline bool Type_IsValid(int value) {
2284 return V8InternalCode_Type_IsValid(value);
2285 }
2286 static constexpr Type Type_MIN =
2287 V8InternalCode_Type_Type_MIN;
2288 static constexpr Type Type_MAX =
2289 V8InternalCode_Type_Type_MAX;
2290 static constexpr int Type_ARRAYSIZE =
2291 V8InternalCode_Type_Type_ARRAYSIZE;
2292 template<typename T>
2293 static inline const std::string& Type_Name(T enum_t_value) {
2294 static_assert(::std::is_same<T, Type>::value ||
2295 ::std::is_integral<T>::value,
2296 "Incorrect type passed to function Type_Name.");
2297 return V8InternalCode_Type_Name(enum_t_value);
2298 }
2299 static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2300 Type* value) {
2301 return V8InternalCode_Type_Parse(name, value);
2302 }
2303
2304 // accessors -------------------------------------------------------
2305
2306 enum : int {
2307 kNameFieldNumber = 3,
2308 kMachineCodeFieldNumber = 8,
2309 kV8IsolateIidFieldNumber = 1,
2310 kTidFieldNumber = 2,
2311 kTypeFieldNumber = 4,
2312 kInstructionStartFieldNumber = 6,
2313 kInstructionSizeBytesFieldNumber = 7,
2314 kBuiltinIdFieldNumber = 5,
2315 };
2316 // optional string name = 3;
2317 bool has_name() const;
2318 private:
2319 bool _internal_has_name() const;
2320 public:
2321 void clear_name();
2322 const std::string& name() const;
2323 template <typename ArgT0 = const std::string&, typename... ArgT>
2324 void set_name(ArgT0&& arg0, ArgT... args);
2325 std::string* mutable_name();
2326 PROTOBUF_NODISCARD std::string* release_name();
2327 void set_allocated_name(std::string* name);
2328 private:
2329 const std::string& _internal_name() const;
2330 inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
2331 std::string* _internal_mutable_name();
2332 public:
2333
2334 // optional bytes machine_code = 8;
2335 bool has_machine_code() const;
2336 private:
2337 bool _internal_has_machine_code() const;
2338 public:
2339 void clear_machine_code();
2340 const std::string& machine_code() const;
2341 template <typename ArgT0 = const std::string&, typename... ArgT>
2342 void set_machine_code(ArgT0&& arg0, ArgT... args);
2343 std::string* mutable_machine_code();
2344 PROTOBUF_NODISCARD std::string* release_machine_code();
2345 void set_allocated_machine_code(std::string* machine_code);
2346 private:
2347 const std::string& _internal_machine_code() const;
2348 inline PROTOBUF_ALWAYS_INLINE void _internal_set_machine_code(const std::string& value);
2349 std::string* _internal_mutable_machine_code();
2350 public:
2351
2352 // optional uint64 v8_isolate_iid = 1;
2353 bool has_v8_isolate_iid() const;
2354 private:
2355 bool _internal_has_v8_isolate_iid() const;
2356 public:
2357 void clear_v8_isolate_iid();
2358 ::uint64_t v8_isolate_iid() const;
2359 void set_v8_isolate_iid(::uint64_t value);
2360 private:
2361 ::uint64_t _internal_v8_isolate_iid() const;
2362 void _internal_set_v8_isolate_iid(::uint64_t value);
2363 public:
2364
2365 // optional uint32 tid = 2;
2366 bool has_tid() const;
2367 private:
2368 bool _internal_has_tid() const;
2369 public:
2370 void clear_tid();
2371 ::uint32_t tid() const;
2372 void set_tid(::uint32_t value);
2373 private:
2374 ::uint32_t _internal_tid() const;
2375 void _internal_set_tid(::uint32_t value);
2376 public:
2377
2378 // optional .perfetto.protos.V8InternalCode.Type type = 4;
2379 bool has_type() const;
2380 private:
2381 bool _internal_has_type() const;
2382 public:
2383 void clear_type();
2384 ::perfetto::protos::V8InternalCode_Type type() const;
2385 void set_type(::perfetto::protos::V8InternalCode_Type value);
2386 private:
2387 ::perfetto::protos::V8InternalCode_Type _internal_type() const;
2388 void _internal_set_type(::perfetto::protos::V8InternalCode_Type value);
2389 public:
2390
2391 // optional uint64 instruction_start = 6;
2392 bool has_instruction_start() const;
2393 private:
2394 bool _internal_has_instruction_start() const;
2395 public:
2396 void clear_instruction_start();
2397 ::uint64_t instruction_start() const;
2398 void set_instruction_start(::uint64_t value);
2399 private:
2400 ::uint64_t _internal_instruction_start() const;
2401 void _internal_set_instruction_start(::uint64_t value);
2402 public:
2403
2404 // optional uint64 instruction_size_bytes = 7;
2405 bool has_instruction_size_bytes() const;
2406 private:
2407 bool _internal_has_instruction_size_bytes() const;
2408 public:
2409 void clear_instruction_size_bytes();
2410 ::uint64_t instruction_size_bytes() const;
2411 void set_instruction_size_bytes(::uint64_t value);
2412 private:
2413 ::uint64_t _internal_instruction_size_bytes() const;
2414 void _internal_set_instruction_size_bytes(::uint64_t value);
2415 public:
2416
2417 // optional int32 builtin_id = 5;
2418 bool has_builtin_id() const;
2419 private:
2420 bool _internal_has_builtin_id() const;
2421 public:
2422 void clear_builtin_id();
2423 ::int32_t builtin_id() const;
2424 void set_builtin_id(::int32_t value);
2425 private:
2426 ::int32_t _internal_builtin_id() const;
2427 void _internal_set_builtin_id(::int32_t value);
2428 public:
2429
2430 // @@protoc_insertion_point(class_scope:perfetto.protos.V8InternalCode)
2431 private:
2432 class _Internal;
2433
2434 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2435 typedef void InternalArenaConstructable_;
2436 typedef void DestructorSkippable_;
2437 struct Impl_ {
2438 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2439 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2440 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
2441 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_code_;
2442 ::uint64_t v8_isolate_iid_;
2443 ::uint32_t tid_;
2444 int type_;
2445 ::uint64_t instruction_start_;
2446 ::uint64_t instruction_size_bytes_;
2447 ::int32_t builtin_id_;
2448 };
2449 union { Impl_ _impl_; };
2450 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
2451 };
2452 // -------------------------------------------------------------------
2453
2454 class V8WasmCode final :
2455 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8WasmCode) */ {
2456 public:
V8WasmCode()2457 inline V8WasmCode() : V8WasmCode(nullptr) {}
2458 ~V8WasmCode() override;
2459 explicit PROTOBUF_CONSTEXPR V8WasmCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2460
2461 V8WasmCode(const V8WasmCode& from);
V8WasmCode(V8WasmCode && from)2462 V8WasmCode(V8WasmCode&& from) noexcept
2463 : V8WasmCode() {
2464 *this = ::std::move(from);
2465 }
2466
2467 inline V8WasmCode& operator=(const V8WasmCode& from) {
2468 if (this == &from) return *this;
2469 CopyFrom(from);
2470 return *this;
2471 }
2472 inline V8WasmCode& operator=(V8WasmCode&& from) noexcept {
2473 if (this == &from) return *this;
2474 if (GetOwningArena() == from.GetOwningArena()
2475 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2476 && GetOwningArena() != nullptr
2477 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2478 ) {
2479 InternalSwap(&from);
2480 } else {
2481 CopyFrom(from);
2482 }
2483 return *this;
2484 }
2485
unknown_fields()2486 inline const std::string& unknown_fields() const {
2487 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2488 }
mutable_unknown_fields()2489 inline std::string* mutable_unknown_fields() {
2490 return _internal_metadata_.mutable_unknown_fields<std::string>();
2491 }
2492
default_instance()2493 static const V8WasmCode& default_instance() {
2494 return *internal_default_instance();
2495 }
internal_default_instance()2496 static inline const V8WasmCode* internal_default_instance() {
2497 return reinterpret_cast<const V8WasmCode*>(
2498 &_V8WasmCode_default_instance_);
2499 }
2500 static constexpr int kIndexInFileMessages =
2501 9;
2502
swap(V8WasmCode & a,V8WasmCode & b)2503 friend void swap(V8WasmCode& a, V8WasmCode& b) {
2504 a.Swap(&b);
2505 }
Swap(V8WasmCode * other)2506 inline void Swap(V8WasmCode* other) {
2507 if (other == this) return;
2508 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2509 if (GetOwningArena() != nullptr &&
2510 GetOwningArena() == other->GetOwningArena()) {
2511 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2512 if (GetOwningArena() == other->GetOwningArena()) {
2513 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2514 InternalSwap(other);
2515 } else {
2516 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2517 }
2518 }
2519 void UnsafeArenaSwap(V8WasmCode* other) {
2520 if (other == this) return;
2521 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2522 InternalSwap(other);
2523 }
2524
2525 // implements Message ----------------------------------------------
2526
2527 V8WasmCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2528 return CreateMaybeMessage<V8WasmCode>(arena);
2529 }
2530 V8WasmCode* New() const {
2531 return New(nullptr);
2532 }
2533 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2534 void CopyFrom(const V8WasmCode& from);
2535 void MergeFrom(const V8WasmCode& from);
2536 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2537 bool IsInitialized() const final;
2538
2539 size_t ByteSizeLong() const final;
2540 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2541 ::uint8_t* _InternalSerialize(
2542 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2543 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2544
2545 private:
2546 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2547 void SharedDtor();
2548 void SetCachedSize(int size) const;
2549 void InternalSwap(V8WasmCode* other);
2550
2551 private:
2552 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2553 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2554 return "perfetto.protos.V8WasmCode";
2555 }
2556 protected:
2557 explicit V8WasmCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2558 bool is_message_owned = false);
2559 public:
2560
2561 std::string GetTypeName() const final;
2562
2563 // nested types ----------------------------------------------------
2564
2565 typedef V8WasmCode_Tier Tier;
2566 static constexpr Tier TIER_UNKNOWN =
2567 V8WasmCode_Tier_TIER_UNKNOWN;
2568 static constexpr Tier TIER_LIFTOFF =
2569 V8WasmCode_Tier_TIER_LIFTOFF;
2570 static constexpr Tier TIER_TURBOFAN =
2571 V8WasmCode_Tier_TIER_TURBOFAN;
2572 static inline bool Tier_IsValid(int value) {
2573 return V8WasmCode_Tier_IsValid(value);
2574 }
2575 static constexpr Tier Tier_MIN =
2576 V8WasmCode_Tier_Tier_MIN;
2577 static constexpr Tier Tier_MAX =
2578 V8WasmCode_Tier_Tier_MAX;
2579 static constexpr int Tier_ARRAYSIZE =
2580 V8WasmCode_Tier_Tier_ARRAYSIZE;
2581 template<typename T>
2582 static inline const std::string& Tier_Name(T enum_t_value) {
2583 static_assert(::std::is_same<T, Tier>::value ||
2584 ::std::is_integral<T>::value,
2585 "Incorrect type passed to function Tier_Name.");
2586 return V8WasmCode_Tier_Name(enum_t_value);
2587 }
2588 static inline bool Tier_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
2589 Tier* value) {
2590 return V8WasmCode_Tier_Parse(name, value);
2591 }
2592
2593 // accessors -------------------------------------------------------
2594
2595 enum : int {
2596 kFunctionNameFieldNumber = 4,
2597 kMachineCodeFieldNumber = 9,
2598 kV8IsolateIidFieldNumber = 1,
2599 kV8WasmScriptIidFieldNumber = 3,
2600 kTidFieldNumber = 2,
2601 kTierFieldNumber = 5,
2602 kInstructionStartFieldNumber = 7,
2603 kInstructionSizeBytesFieldNumber = 8,
2604 kCodeOffsetInModuleFieldNumber = 6,
2605 };
2606 // optional string function_name = 4;
2607 bool has_function_name() const;
2608 private:
2609 bool _internal_has_function_name() const;
2610 public:
2611 void clear_function_name();
2612 const std::string& function_name() const;
2613 template <typename ArgT0 = const std::string&, typename... ArgT>
2614 void set_function_name(ArgT0&& arg0, ArgT... args);
2615 std::string* mutable_function_name();
2616 PROTOBUF_NODISCARD std::string* release_function_name();
2617 void set_allocated_function_name(std::string* function_name);
2618 private:
2619 const std::string& _internal_function_name() const;
2620 inline PROTOBUF_ALWAYS_INLINE void _internal_set_function_name(const std::string& value);
2621 std::string* _internal_mutable_function_name();
2622 public:
2623
2624 // optional bytes machine_code = 9;
2625 bool has_machine_code() const;
2626 private:
2627 bool _internal_has_machine_code() const;
2628 public:
2629 void clear_machine_code();
2630 const std::string& machine_code() const;
2631 template <typename ArgT0 = const std::string&, typename... ArgT>
2632 void set_machine_code(ArgT0&& arg0, ArgT... args);
2633 std::string* mutable_machine_code();
2634 PROTOBUF_NODISCARD std::string* release_machine_code();
2635 void set_allocated_machine_code(std::string* machine_code);
2636 private:
2637 const std::string& _internal_machine_code() const;
2638 inline PROTOBUF_ALWAYS_INLINE void _internal_set_machine_code(const std::string& value);
2639 std::string* _internal_mutable_machine_code();
2640 public:
2641
2642 // optional uint64 v8_isolate_iid = 1;
2643 bool has_v8_isolate_iid() const;
2644 private:
2645 bool _internal_has_v8_isolate_iid() const;
2646 public:
2647 void clear_v8_isolate_iid();
2648 ::uint64_t v8_isolate_iid() const;
2649 void set_v8_isolate_iid(::uint64_t value);
2650 private:
2651 ::uint64_t _internal_v8_isolate_iid() const;
2652 void _internal_set_v8_isolate_iid(::uint64_t value);
2653 public:
2654
2655 // optional uint64 v8_wasm_script_iid = 3;
2656 bool has_v8_wasm_script_iid() const;
2657 private:
2658 bool _internal_has_v8_wasm_script_iid() const;
2659 public:
2660 void clear_v8_wasm_script_iid();
2661 ::uint64_t v8_wasm_script_iid() const;
2662 void set_v8_wasm_script_iid(::uint64_t value);
2663 private:
2664 ::uint64_t _internal_v8_wasm_script_iid() const;
2665 void _internal_set_v8_wasm_script_iid(::uint64_t value);
2666 public:
2667
2668 // optional uint32 tid = 2;
2669 bool has_tid() const;
2670 private:
2671 bool _internal_has_tid() const;
2672 public:
2673 void clear_tid();
2674 ::uint32_t tid() const;
2675 void set_tid(::uint32_t value);
2676 private:
2677 ::uint32_t _internal_tid() const;
2678 void _internal_set_tid(::uint32_t value);
2679 public:
2680
2681 // optional .perfetto.protos.V8WasmCode.Tier tier = 5;
2682 bool has_tier() const;
2683 private:
2684 bool _internal_has_tier() const;
2685 public:
2686 void clear_tier();
2687 ::perfetto::protos::V8WasmCode_Tier tier() const;
2688 void set_tier(::perfetto::protos::V8WasmCode_Tier value);
2689 private:
2690 ::perfetto::protos::V8WasmCode_Tier _internal_tier() const;
2691 void _internal_set_tier(::perfetto::protos::V8WasmCode_Tier value);
2692 public:
2693
2694 // optional uint64 instruction_start = 7;
2695 bool has_instruction_start() const;
2696 private:
2697 bool _internal_has_instruction_start() const;
2698 public:
2699 void clear_instruction_start();
2700 ::uint64_t instruction_start() const;
2701 void set_instruction_start(::uint64_t value);
2702 private:
2703 ::uint64_t _internal_instruction_start() const;
2704 void _internal_set_instruction_start(::uint64_t value);
2705 public:
2706
2707 // optional uint64 instruction_size_bytes = 8;
2708 bool has_instruction_size_bytes() const;
2709 private:
2710 bool _internal_has_instruction_size_bytes() const;
2711 public:
2712 void clear_instruction_size_bytes();
2713 ::uint64_t instruction_size_bytes() const;
2714 void set_instruction_size_bytes(::uint64_t value);
2715 private:
2716 ::uint64_t _internal_instruction_size_bytes() const;
2717 void _internal_set_instruction_size_bytes(::uint64_t value);
2718 public:
2719
2720 // optional int32 code_offset_in_module = 6;
2721 bool has_code_offset_in_module() const;
2722 private:
2723 bool _internal_has_code_offset_in_module() const;
2724 public:
2725 void clear_code_offset_in_module();
2726 ::int32_t code_offset_in_module() const;
2727 void set_code_offset_in_module(::int32_t value);
2728 private:
2729 ::int32_t _internal_code_offset_in_module() const;
2730 void _internal_set_code_offset_in_module(::int32_t value);
2731 public:
2732
2733 // @@protoc_insertion_point(class_scope:perfetto.protos.V8WasmCode)
2734 private:
2735 class _Internal;
2736
2737 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2738 typedef void InternalArenaConstructable_;
2739 typedef void DestructorSkippable_;
2740 struct Impl_ {
2741 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2742 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2743 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_name_;
2744 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_code_;
2745 ::uint64_t v8_isolate_iid_;
2746 ::uint64_t v8_wasm_script_iid_;
2747 ::uint32_t tid_;
2748 int tier_;
2749 ::uint64_t instruction_start_;
2750 ::uint64_t instruction_size_bytes_;
2751 ::int32_t code_offset_in_module_;
2752 };
2753 union { Impl_ _impl_; };
2754 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
2755 };
2756 // -------------------------------------------------------------------
2757
2758 class V8RegExpCode final :
2759 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8RegExpCode) */ {
2760 public:
V8RegExpCode()2761 inline V8RegExpCode() : V8RegExpCode(nullptr) {}
2762 ~V8RegExpCode() override;
2763 explicit PROTOBUF_CONSTEXPR V8RegExpCode(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2764
2765 V8RegExpCode(const V8RegExpCode& from);
V8RegExpCode(V8RegExpCode && from)2766 V8RegExpCode(V8RegExpCode&& from) noexcept
2767 : V8RegExpCode() {
2768 *this = ::std::move(from);
2769 }
2770
2771 inline V8RegExpCode& operator=(const V8RegExpCode& from) {
2772 if (this == &from) return *this;
2773 CopyFrom(from);
2774 return *this;
2775 }
2776 inline V8RegExpCode& operator=(V8RegExpCode&& from) noexcept {
2777 if (this == &from) return *this;
2778 if (GetOwningArena() == from.GetOwningArena()
2779 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2780 && GetOwningArena() != nullptr
2781 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2782 ) {
2783 InternalSwap(&from);
2784 } else {
2785 CopyFrom(from);
2786 }
2787 return *this;
2788 }
2789
unknown_fields()2790 inline const std::string& unknown_fields() const {
2791 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
2792 }
mutable_unknown_fields()2793 inline std::string* mutable_unknown_fields() {
2794 return _internal_metadata_.mutable_unknown_fields<std::string>();
2795 }
2796
default_instance()2797 static const V8RegExpCode& default_instance() {
2798 return *internal_default_instance();
2799 }
internal_default_instance()2800 static inline const V8RegExpCode* internal_default_instance() {
2801 return reinterpret_cast<const V8RegExpCode*>(
2802 &_V8RegExpCode_default_instance_);
2803 }
2804 static constexpr int kIndexInFileMessages =
2805 10;
2806
swap(V8RegExpCode & a,V8RegExpCode & b)2807 friend void swap(V8RegExpCode& a, V8RegExpCode& b) {
2808 a.Swap(&b);
2809 }
Swap(V8RegExpCode * other)2810 inline void Swap(V8RegExpCode* other) {
2811 if (other == this) return;
2812 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2813 if (GetOwningArena() != nullptr &&
2814 GetOwningArena() == other->GetOwningArena()) {
2815 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2816 if (GetOwningArena() == other->GetOwningArena()) {
2817 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2818 InternalSwap(other);
2819 } else {
2820 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2821 }
2822 }
2823 void UnsafeArenaSwap(V8RegExpCode* other) {
2824 if (other == this) return;
2825 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2826 InternalSwap(other);
2827 }
2828
2829 // implements Message ----------------------------------------------
2830
2831 V8RegExpCode* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2832 return CreateMaybeMessage<V8RegExpCode>(arena);
2833 }
2834 V8RegExpCode* New() const {
2835 return New(nullptr);
2836 }
2837 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2838 void CopyFrom(const V8RegExpCode& from);
2839 void MergeFrom(const V8RegExpCode& from);
2840 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2841 bool IsInitialized() const final;
2842
2843 size_t ByteSizeLong() const final;
2844 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2845 ::uint8_t* _InternalSerialize(
2846 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2847 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2848
2849 private:
2850 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2851 void SharedDtor();
2852 void SetCachedSize(int size) const;
2853 void InternalSwap(V8RegExpCode* other);
2854
2855 private:
2856 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2857 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2858 return "perfetto.protos.V8RegExpCode";
2859 }
2860 protected:
2861 explicit V8RegExpCode(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2862 bool is_message_owned = false);
2863 public:
2864
2865 std::string GetTypeName() const final;
2866
2867 // nested types ----------------------------------------------------
2868
2869 // accessors -------------------------------------------------------
2870
2871 enum : int {
2872 kMachineCodeFieldNumber = 6,
2873 kPatternFieldNumber = 3,
2874 kV8IsolateIidFieldNumber = 1,
2875 kInstructionStartFieldNumber = 4,
2876 kInstructionSizeBytesFieldNumber = 5,
2877 kTidFieldNumber = 2,
2878 };
2879 // optional bytes machine_code = 6;
2880 bool has_machine_code() const;
2881 private:
2882 bool _internal_has_machine_code() const;
2883 public:
2884 void clear_machine_code();
2885 const std::string& machine_code() const;
2886 template <typename ArgT0 = const std::string&, typename... ArgT>
2887 void set_machine_code(ArgT0&& arg0, ArgT... args);
2888 std::string* mutable_machine_code();
2889 PROTOBUF_NODISCARD std::string* release_machine_code();
2890 void set_allocated_machine_code(std::string* machine_code);
2891 private:
2892 const std::string& _internal_machine_code() const;
2893 inline PROTOBUF_ALWAYS_INLINE void _internal_set_machine_code(const std::string& value);
2894 std::string* _internal_mutable_machine_code();
2895 public:
2896
2897 // optional .perfetto.protos.V8String pattern = 3;
2898 bool has_pattern() const;
2899 private:
2900 bool _internal_has_pattern() const;
2901 public:
2902 void clear_pattern();
2903 const ::perfetto::protos::V8String& pattern() const;
2904 PROTOBUF_NODISCARD ::perfetto::protos::V8String* release_pattern();
2905 ::perfetto::protos::V8String* mutable_pattern();
2906 void set_allocated_pattern(::perfetto::protos::V8String* pattern);
2907 private:
2908 const ::perfetto::protos::V8String& _internal_pattern() const;
2909 ::perfetto::protos::V8String* _internal_mutable_pattern();
2910 public:
2911 void unsafe_arena_set_allocated_pattern(
2912 ::perfetto::protos::V8String* pattern);
2913 ::perfetto::protos::V8String* unsafe_arena_release_pattern();
2914
2915 // optional uint64 v8_isolate_iid = 1;
2916 bool has_v8_isolate_iid() const;
2917 private:
2918 bool _internal_has_v8_isolate_iid() const;
2919 public:
2920 void clear_v8_isolate_iid();
2921 ::uint64_t v8_isolate_iid() const;
2922 void set_v8_isolate_iid(::uint64_t value);
2923 private:
2924 ::uint64_t _internal_v8_isolate_iid() const;
2925 void _internal_set_v8_isolate_iid(::uint64_t value);
2926 public:
2927
2928 // optional uint64 instruction_start = 4;
2929 bool has_instruction_start() const;
2930 private:
2931 bool _internal_has_instruction_start() const;
2932 public:
2933 void clear_instruction_start();
2934 ::uint64_t instruction_start() const;
2935 void set_instruction_start(::uint64_t value);
2936 private:
2937 ::uint64_t _internal_instruction_start() const;
2938 void _internal_set_instruction_start(::uint64_t value);
2939 public:
2940
2941 // optional uint64 instruction_size_bytes = 5;
2942 bool has_instruction_size_bytes() const;
2943 private:
2944 bool _internal_has_instruction_size_bytes() const;
2945 public:
2946 void clear_instruction_size_bytes();
2947 ::uint64_t instruction_size_bytes() const;
2948 void set_instruction_size_bytes(::uint64_t value);
2949 private:
2950 ::uint64_t _internal_instruction_size_bytes() const;
2951 void _internal_set_instruction_size_bytes(::uint64_t value);
2952 public:
2953
2954 // optional uint32 tid = 2;
2955 bool has_tid() const;
2956 private:
2957 bool _internal_has_tid() const;
2958 public:
2959 void clear_tid();
2960 ::uint32_t tid() const;
2961 void set_tid(::uint32_t value);
2962 private:
2963 ::uint32_t _internal_tid() const;
2964 void _internal_set_tid(::uint32_t value);
2965 public:
2966
2967 // @@protoc_insertion_point(class_scope:perfetto.protos.V8RegExpCode)
2968 private:
2969 class _Internal;
2970
2971 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2972 typedef void InternalArenaConstructable_;
2973 typedef void DestructorSkippable_;
2974 struct Impl_ {
2975 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
2976 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2977 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_code_;
2978 ::perfetto::protos::V8String* pattern_;
2979 ::uint64_t v8_isolate_iid_;
2980 ::uint64_t instruction_start_;
2981 ::uint64_t instruction_size_bytes_;
2982 ::uint32_t tid_;
2983 };
2984 union { Impl_ _impl_; };
2985 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
2986 };
2987 // -------------------------------------------------------------------
2988
2989 class V8CodeMove final :
2990 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8CodeMove) */ {
2991 public:
V8CodeMove()2992 inline V8CodeMove() : V8CodeMove(nullptr) {}
2993 ~V8CodeMove() override;
2994 explicit PROTOBUF_CONSTEXPR V8CodeMove(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2995
2996 V8CodeMove(const V8CodeMove& from);
V8CodeMove(V8CodeMove && from)2997 V8CodeMove(V8CodeMove&& from) noexcept
2998 : V8CodeMove() {
2999 *this = ::std::move(from);
3000 }
3001
3002 inline V8CodeMove& operator=(const V8CodeMove& from) {
3003 if (this == &from) return *this;
3004 CopyFrom(from);
3005 return *this;
3006 }
3007 inline V8CodeMove& operator=(V8CodeMove&& from) noexcept {
3008 if (this == &from) return *this;
3009 if (GetOwningArena() == from.GetOwningArena()
3010 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3011 && GetOwningArena() != nullptr
3012 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3013 ) {
3014 InternalSwap(&from);
3015 } else {
3016 CopyFrom(from);
3017 }
3018 return *this;
3019 }
3020
unknown_fields()3021 inline const std::string& unknown_fields() const {
3022 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3023 }
mutable_unknown_fields()3024 inline std::string* mutable_unknown_fields() {
3025 return _internal_metadata_.mutable_unknown_fields<std::string>();
3026 }
3027
default_instance()3028 static const V8CodeMove& default_instance() {
3029 return *internal_default_instance();
3030 }
3031 enum ToInstructionsCase {
3032 kToMachineCode = 6,
3033 kToBytecode = 7,
3034 TO_INSTRUCTIONS_NOT_SET = 0,
3035 };
3036
internal_default_instance()3037 static inline const V8CodeMove* internal_default_instance() {
3038 return reinterpret_cast<const V8CodeMove*>(
3039 &_V8CodeMove_default_instance_);
3040 }
3041 static constexpr int kIndexInFileMessages =
3042 11;
3043
swap(V8CodeMove & a,V8CodeMove & b)3044 friend void swap(V8CodeMove& a, V8CodeMove& b) {
3045 a.Swap(&b);
3046 }
Swap(V8CodeMove * other)3047 inline void Swap(V8CodeMove* other) {
3048 if (other == this) return;
3049 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3050 if (GetOwningArena() != nullptr &&
3051 GetOwningArena() == other->GetOwningArena()) {
3052 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3053 if (GetOwningArena() == other->GetOwningArena()) {
3054 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3055 InternalSwap(other);
3056 } else {
3057 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3058 }
3059 }
3060 void UnsafeArenaSwap(V8CodeMove* other) {
3061 if (other == this) return;
3062 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3063 InternalSwap(other);
3064 }
3065
3066 // implements Message ----------------------------------------------
3067
3068 V8CodeMove* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3069 return CreateMaybeMessage<V8CodeMove>(arena);
3070 }
3071 V8CodeMove* New() const {
3072 return New(nullptr);
3073 }
3074 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3075 void CopyFrom(const V8CodeMove& from);
3076 void MergeFrom(const V8CodeMove& from);
3077 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3078 bool IsInitialized() const final;
3079
3080 size_t ByteSizeLong() const final;
3081 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3082 ::uint8_t* _InternalSerialize(
3083 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3084 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3085
3086 private:
3087 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3088 void SharedDtor();
3089 void SetCachedSize(int size) const;
3090 void InternalSwap(V8CodeMove* other);
3091
3092 private:
3093 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3094 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3095 return "perfetto.protos.V8CodeMove";
3096 }
3097 protected:
3098 explicit V8CodeMove(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3099 bool is_message_owned = false);
3100 public:
3101
3102 std::string GetTypeName() const final;
3103
3104 // nested types ----------------------------------------------------
3105
3106 // accessors -------------------------------------------------------
3107
3108 enum : int {
3109 kIsolateIidFieldNumber = 1,
3110 kFromInstructionStartAddressFieldNumber = 3,
3111 kToInstructionStartAddressFieldNumber = 4,
3112 kInstructionSizeBytesFieldNumber = 5,
3113 kTidFieldNumber = 2,
3114 kToMachineCodeFieldNumber = 6,
3115 kToBytecodeFieldNumber = 7,
3116 };
3117 // optional uint64 isolate_iid = 1;
3118 bool has_isolate_iid() const;
3119 private:
3120 bool _internal_has_isolate_iid() const;
3121 public:
3122 void clear_isolate_iid();
3123 ::uint64_t isolate_iid() const;
3124 void set_isolate_iid(::uint64_t value);
3125 private:
3126 ::uint64_t _internal_isolate_iid() const;
3127 void _internal_set_isolate_iid(::uint64_t value);
3128 public:
3129
3130 // optional uint64 from_instruction_start_address = 3;
3131 bool has_from_instruction_start_address() const;
3132 private:
3133 bool _internal_has_from_instruction_start_address() const;
3134 public:
3135 void clear_from_instruction_start_address();
3136 ::uint64_t from_instruction_start_address() const;
3137 void set_from_instruction_start_address(::uint64_t value);
3138 private:
3139 ::uint64_t _internal_from_instruction_start_address() const;
3140 void _internal_set_from_instruction_start_address(::uint64_t value);
3141 public:
3142
3143 // optional uint64 to_instruction_start_address = 4;
3144 bool has_to_instruction_start_address() const;
3145 private:
3146 bool _internal_has_to_instruction_start_address() const;
3147 public:
3148 void clear_to_instruction_start_address();
3149 ::uint64_t to_instruction_start_address() const;
3150 void set_to_instruction_start_address(::uint64_t value);
3151 private:
3152 ::uint64_t _internal_to_instruction_start_address() const;
3153 void _internal_set_to_instruction_start_address(::uint64_t value);
3154 public:
3155
3156 // optional uint64 instruction_size_bytes = 5;
3157 bool has_instruction_size_bytes() const;
3158 private:
3159 bool _internal_has_instruction_size_bytes() const;
3160 public:
3161 void clear_instruction_size_bytes();
3162 ::uint64_t instruction_size_bytes() const;
3163 void set_instruction_size_bytes(::uint64_t value);
3164 private:
3165 ::uint64_t _internal_instruction_size_bytes() const;
3166 void _internal_set_instruction_size_bytes(::uint64_t value);
3167 public:
3168
3169 // optional uint32 tid = 2;
3170 bool has_tid() const;
3171 private:
3172 bool _internal_has_tid() const;
3173 public:
3174 void clear_tid();
3175 ::uint32_t tid() const;
3176 void set_tid(::uint32_t value);
3177 private:
3178 ::uint32_t _internal_tid() const;
3179 void _internal_set_tid(::uint32_t value);
3180 public:
3181
3182 // bytes to_machine_code = 6;
3183 bool has_to_machine_code() const;
3184 private:
3185 bool _internal_has_to_machine_code() const;
3186 public:
3187 void clear_to_machine_code();
3188 const std::string& to_machine_code() const;
3189 template <typename ArgT0 = const std::string&, typename... ArgT>
3190 void set_to_machine_code(ArgT0&& arg0, ArgT... args);
3191 std::string* mutable_to_machine_code();
3192 PROTOBUF_NODISCARD std::string* release_to_machine_code();
3193 void set_allocated_to_machine_code(std::string* to_machine_code);
3194 private:
3195 const std::string& _internal_to_machine_code() const;
3196 inline PROTOBUF_ALWAYS_INLINE void _internal_set_to_machine_code(const std::string& value);
3197 std::string* _internal_mutable_to_machine_code();
3198 public:
3199
3200 // bytes to_bytecode = 7;
3201 bool has_to_bytecode() const;
3202 private:
3203 bool _internal_has_to_bytecode() const;
3204 public:
3205 void clear_to_bytecode();
3206 const std::string& to_bytecode() const;
3207 template <typename ArgT0 = const std::string&, typename... ArgT>
3208 void set_to_bytecode(ArgT0&& arg0, ArgT... args);
3209 std::string* mutable_to_bytecode();
3210 PROTOBUF_NODISCARD std::string* release_to_bytecode();
3211 void set_allocated_to_bytecode(std::string* to_bytecode);
3212 private:
3213 const std::string& _internal_to_bytecode() const;
3214 inline PROTOBUF_ALWAYS_INLINE void _internal_set_to_bytecode(const std::string& value);
3215 std::string* _internal_mutable_to_bytecode();
3216 public:
3217
3218 void clear_to_instructions();
3219 ToInstructionsCase to_instructions_case() const;
3220 // @@protoc_insertion_point(class_scope:perfetto.protos.V8CodeMove)
3221 private:
3222 class _Internal;
3223 void set_has_to_machine_code();
3224 void set_has_to_bytecode();
3225
3226 inline bool has_to_instructions() const;
3227 inline void clear_has_to_instructions();
3228
3229 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3230 typedef void InternalArenaConstructable_;
3231 typedef void DestructorSkippable_;
3232 struct Impl_ {
3233 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3234 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3235 ::uint64_t isolate_iid_;
3236 ::uint64_t from_instruction_start_address_;
3237 ::uint64_t to_instruction_start_address_;
3238 ::uint64_t instruction_size_bytes_;
3239 ::uint32_t tid_;
3240 union ToInstructionsUnion {
3241 constexpr ToInstructionsUnion() : _constinit_{} {}
3242 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
3243 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr to_machine_code_;
3244 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr to_bytecode_;
3245 } to_instructions_;
3246 ::uint32_t _oneof_case_[1];
3247
3248 };
3249 union { Impl_ _impl_; };
3250 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
3251 };
3252 // -------------------------------------------------------------------
3253
3254 class V8CodeDefaults final :
3255 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.V8CodeDefaults) */ {
3256 public:
V8CodeDefaults()3257 inline V8CodeDefaults() : V8CodeDefaults(nullptr) {}
3258 ~V8CodeDefaults() override;
3259 explicit PROTOBUF_CONSTEXPR V8CodeDefaults(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3260
3261 V8CodeDefaults(const V8CodeDefaults& from);
V8CodeDefaults(V8CodeDefaults && from)3262 V8CodeDefaults(V8CodeDefaults&& from) noexcept
3263 : V8CodeDefaults() {
3264 *this = ::std::move(from);
3265 }
3266
3267 inline V8CodeDefaults& operator=(const V8CodeDefaults& from) {
3268 if (this == &from) return *this;
3269 CopyFrom(from);
3270 return *this;
3271 }
3272 inline V8CodeDefaults& operator=(V8CodeDefaults&& from) noexcept {
3273 if (this == &from) return *this;
3274 if (GetOwningArena() == from.GetOwningArena()
3275 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3276 && GetOwningArena() != nullptr
3277 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3278 ) {
3279 InternalSwap(&from);
3280 } else {
3281 CopyFrom(from);
3282 }
3283 return *this;
3284 }
3285
unknown_fields()3286 inline const std::string& unknown_fields() const {
3287 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
3288 }
mutable_unknown_fields()3289 inline std::string* mutable_unknown_fields() {
3290 return _internal_metadata_.mutable_unknown_fields<std::string>();
3291 }
3292
default_instance()3293 static const V8CodeDefaults& default_instance() {
3294 return *internal_default_instance();
3295 }
internal_default_instance()3296 static inline const V8CodeDefaults* internal_default_instance() {
3297 return reinterpret_cast<const V8CodeDefaults*>(
3298 &_V8CodeDefaults_default_instance_);
3299 }
3300 static constexpr int kIndexInFileMessages =
3301 12;
3302
swap(V8CodeDefaults & a,V8CodeDefaults & b)3303 friend void swap(V8CodeDefaults& a, V8CodeDefaults& b) {
3304 a.Swap(&b);
3305 }
Swap(V8CodeDefaults * other)3306 inline void Swap(V8CodeDefaults* other) {
3307 if (other == this) return;
3308 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3309 if (GetOwningArena() != nullptr &&
3310 GetOwningArena() == other->GetOwningArena()) {
3311 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3312 if (GetOwningArena() == other->GetOwningArena()) {
3313 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3314 InternalSwap(other);
3315 } else {
3316 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3317 }
3318 }
3319 void UnsafeArenaSwap(V8CodeDefaults* other) {
3320 if (other == this) return;
3321 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3322 InternalSwap(other);
3323 }
3324
3325 // implements Message ----------------------------------------------
3326
3327 V8CodeDefaults* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3328 return CreateMaybeMessage<V8CodeDefaults>(arena);
3329 }
3330 V8CodeDefaults* New() const {
3331 return New(nullptr);
3332 }
3333 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3334 void CopyFrom(const V8CodeDefaults& from);
3335 void MergeFrom(const V8CodeDefaults& from);
3336 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3337 bool IsInitialized() const final;
3338
3339 size_t ByteSizeLong() const final;
3340 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3341 ::uint8_t* _InternalSerialize(
3342 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3343 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3344
3345 private:
3346 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3347 void SharedDtor();
3348 void SetCachedSize(int size) const;
3349 void InternalSwap(V8CodeDefaults* other);
3350
3351 private:
3352 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3353 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3354 return "perfetto.protos.V8CodeDefaults";
3355 }
3356 protected:
3357 explicit V8CodeDefaults(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3358 bool is_message_owned = false);
3359 public:
3360
3361 std::string GetTypeName() const final;
3362
3363 // nested types ----------------------------------------------------
3364
3365 // accessors -------------------------------------------------------
3366
3367 enum : int {
3368 kTidFieldNumber = 1,
3369 };
3370 // optional uint32 tid = 1;
3371 bool has_tid() const;
3372 private:
3373 bool _internal_has_tid() const;
3374 public:
3375 void clear_tid();
3376 ::uint32_t tid() const;
3377 void set_tid(::uint32_t value);
3378 private:
3379 ::uint32_t _internal_tid() const;
3380 void _internal_set_tid(::uint32_t value);
3381 public:
3382
3383 // @@protoc_insertion_point(class_scope:perfetto.protos.V8CodeDefaults)
3384 private:
3385 class _Internal;
3386
3387 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3388 typedef void InternalArenaConstructable_;
3389 typedef void DestructorSkippable_;
3390 struct Impl_ {
3391 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
3392 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3393 ::uint32_t tid_;
3394 };
3395 union { Impl_ _impl_; };
3396 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fv8_2eproto;
3397 };
3398 // ===================================================================
3399
3400
3401 // ===================================================================
3402
3403 #ifdef __GNUC__
3404 #pragma GCC diagnostic push
3405 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3406 #endif // __GNUC__
3407 // V8String
3408
3409 // bytes latin1 = 1;
_internal_has_latin1()3410 inline bool V8String::_internal_has_latin1() const {
3411 return encoded_string_case() == kLatin1;
3412 }
has_latin1()3413 inline bool V8String::has_latin1() const {
3414 return _internal_has_latin1();
3415 }
set_has_latin1()3416 inline void V8String::set_has_latin1() {
3417 _impl_._oneof_case_[0] = kLatin1;
3418 }
clear_latin1()3419 inline void V8String::clear_latin1() {
3420 if (_internal_has_latin1()) {
3421 _impl_.encoded_string_.latin1_.Destroy();
3422 clear_has_encoded_string();
3423 }
3424 }
latin1()3425 inline const std::string& V8String::latin1() const {
3426 // @@protoc_insertion_point(field_get:perfetto.protos.V8String.latin1)
3427 return _internal_latin1();
3428 }
3429 template <typename ArgT0, typename... ArgT>
set_latin1(ArgT0 && arg0,ArgT...args)3430 inline void V8String::set_latin1(ArgT0&& arg0, ArgT... args) {
3431 if (!_internal_has_latin1()) {
3432 clear_encoded_string();
3433 set_has_latin1();
3434 _impl_.encoded_string_.latin1_.InitDefault();
3435 }
3436 _impl_.encoded_string_.latin1_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3437 // @@protoc_insertion_point(field_set:perfetto.protos.V8String.latin1)
3438 }
mutable_latin1()3439 inline std::string* V8String::mutable_latin1() {
3440 std::string* _s = _internal_mutable_latin1();
3441 // @@protoc_insertion_point(field_mutable:perfetto.protos.V8String.latin1)
3442 return _s;
3443 }
_internal_latin1()3444 inline const std::string& V8String::_internal_latin1() const {
3445 if (_internal_has_latin1()) {
3446 return _impl_.encoded_string_.latin1_.Get();
3447 }
3448 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3449 }
_internal_set_latin1(const std::string & value)3450 inline void V8String::_internal_set_latin1(const std::string& value) {
3451 if (!_internal_has_latin1()) {
3452 clear_encoded_string();
3453 set_has_latin1();
3454 _impl_.encoded_string_.latin1_.InitDefault();
3455 }
3456 _impl_.encoded_string_.latin1_.Set(value, GetArenaForAllocation());
3457 }
_internal_mutable_latin1()3458 inline std::string* V8String::_internal_mutable_latin1() {
3459 if (!_internal_has_latin1()) {
3460 clear_encoded_string();
3461 set_has_latin1();
3462 _impl_.encoded_string_.latin1_.InitDefault();
3463 }
3464 return _impl_.encoded_string_.latin1_.Mutable( GetArenaForAllocation());
3465 }
release_latin1()3466 inline std::string* V8String::release_latin1() {
3467 // @@protoc_insertion_point(field_release:perfetto.protos.V8String.latin1)
3468 if (_internal_has_latin1()) {
3469 clear_has_encoded_string();
3470 return _impl_.encoded_string_.latin1_.Release();
3471 } else {
3472 return nullptr;
3473 }
3474 }
set_allocated_latin1(std::string * latin1)3475 inline void V8String::set_allocated_latin1(std::string* latin1) {
3476 if (has_encoded_string()) {
3477 clear_encoded_string();
3478 }
3479 if (latin1 != nullptr) {
3480 set_has_latin1();
3481 _impl_.encoded_string_.latin1_.InitAllocated(latin1, GetArenaForAllocation());
3482 }
3483 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.V8String.latin1)
3484 }
3485
3486 // bytes utf16_le = 2;
_internal_has_utf16_le()3487 inline bool V8String::_internal_has_utf16_le() const {
3488 return encoded_string_case() == kUtf16Le;
3489 }
has_utf16_le()3490 inline bool V8String::has_utf16_le() const {
3491 return _internal_has_utf16_le();
3492 }
set_has_utf16_le()3493 inline void V8String::set_has_utf16_le() {
3494 _impl_._oneof_case_[0] = kUtf16Le;
3495 }
clear_utf16_le()3496 inline void V8String::clear_utf16_le() {
3497 if (_internal_has_utf16_le()) {
3498 _impl_.encoded_string_.utf16_le_.Destroy();
3499 clear_has_encoded_string();
3500 }
3501 }
utf16_le()3502 inline const std::string& V8String::utf16_le() const {
3503 // @@protoc_insertion_point(field_get:perfetto.protos.V8String.utf16_le)
3504 return _internal_utf16_le();
3505 }
3506 template <typename ArgT0, typename... ArgT>
set_utf16_le(ArgT0 && arg0,ArgT...args)3507 inline void V8String::set_utf16_le(ArgT0&& arg0, ArgT... args) {
3508 if (!_internal_has_utf16_le()) {
3509 clear_encoded_string();
3510 set_has_utf16_le();
3511 _impl_.encoded_string_.utf16_le_.InitDefault();
3512 }
3513 _impl_.encoded_string_.utf16_le_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3514 // @@protoc_insertion_point(field_set:perfetto.protos.V8String.utf16_le)
3515 }
mutable_utf16_le()3516 inline std::string* V8String::mutable_utf16_le() {
3517 std::string* _s = _internal_mutable_utf16_le();
3518 // @@protoc_insertion_point(field_mutable:perfetto.protos.V8String.utf16_le)
3519 return _s;
3520 }
_internal_utf16_le()3521 inline const std::string& V8String::_internal_utf16_le() const {
3522 if (_internal_has_utf16_le()) {
3523 return _impl_.encoded_string_.utf16_le_.Get();
3524 }
3525 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3526 }
_internal_set_utf16_le(const std::string & value)3527 inline void V8String::_internal_set_utf16_le(const std::string& value) {
3528 if (!_internal_has_utf16_le()) {
3529 clear_encoded_string();
3530 set_has_utf16_le();
3531 _impl_.encoded_string_.utf16_le_.InitDefault();
3532 }
3533 _impl_.encoded_string_.utf16_le_.Set(value, GetArenaForAllocation());
3534 }
_internal_mutable_utf16_le()3535 inline std::string* V8String::_internal_mutable_utf16_le() {
3536 if (!_internal_has_utf16_le()) {
3537 clear_encoded_string();
3538 set_has_utf16_le();
3539 _impl_.encoded_string_.utf16_le_.InitDefault();
3540 }
3541 return _impl_.encoded_string_.utf16_le_.Mutable( GetArenaForAllocation());
3542 }
release_utf16_le()3543 inline std::string* V8String::release_utf16_le() {
3544 // @@protoc_insertion_point(field_release:perfetto.protos.V8String.utf16_le)
3545 if (_internal_has_utf16_le()) {
3546 clear_has_encoded_string();
3547 return _impl_.encoded_string_.utf16_le_.Release();
3548 } else {
3549 return nullptr;
3550 }
3551 }
set_allocated_utf16_le(std::string * utf16_le)3552 inline void V8String::set_allocated_utf16_le(std::string* utf16_le) {
3553 if (has_encoded_string()) {
3554 clear_encoded_string();
3555 }
3556 if (utf16_le != nullptr) {
3557 set_has_utf16_le();
3558 _impl_.encoded_string_.utf16_le_.InitAllocated(utf16_le, GetArenaForAllocation());
3559 }
3560 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.V8String.utf16_le)
3561 }
3562
3563 // bytes utf16_be = 3;
_internal_has_utf16_be()3564 inline bool V8String::_internal_has_utf16_be() const {
3565 return encoded_string_case() == kUtf16Be;
3566 }
has_utf16_be()3567 inline bool V8String::has_utf16_be() const {
3568 return _internal_has_utf16_be();
3569 }
set_has_utf16_be()3570 inline void V8String::set_has_utf16_be() {
3571 _impl_._oneof_case_[0] = kUtf16Be;
3572 }
clear_utf16_be()3573 inline void V8String::clear_utf16_be() {
3574 if (_internal_has_utf16_be()) {
3575 _impl_.encoded_string_.utf16_be_.Destroy();
3576 clear_has_encoded_string();
3577 }
3578 }
utf16_be()3579 inline const std::string& V8String::utf16_be() const {
3580 // @@protoc_insertion_point(field_get:perfetto.protos.V8String.utf16_be)
3581 return _internal_utf16_be();
3582 }
3583 template <typename ArgT0, typename... ArgT>
set_utf16_be(ArgT0 && arg0,ArgT...args)3584 inline void V8String::set_utf16_be(ArgT0&& arg0, ArgT... args) {
3585 if (!_internal_has_utf16_be()) {
3586 clear_encoded_string();
3587 set_has_utf16_be();
3588 _impl_.encoded_string_.utf16_be_.InitDefault();
3589 }
3590 _impl_.encoded_string_.utf16_be_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3591 // @@protoc_insertion_point(field_set:perfetto.protos.V8String.utf16_be)
3592 }
mutable_utf16_be()3593 inline std::string* V8String::mutable_utf16_be() {
3594 std::string* _s = _internal_mutable_utf16_be();
3595 // @@protoc_insertion_point(field_mutable:perfetto.protos.V8String.utf16_be)
3596 return _s;
3597 }
_internal_utf16_be()3598 inline const std::string& V8String::_internal_utf16_be() const {
3599 if (_internal_has_utf16_be()) {
3600 return _impl_.encoded_string_.utf16_be_.Get();
3601 }
3602 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3603 }
_internal_set_utf16_be(const std::string & value)3604 inline void V8String::_internal_set_utf16_be(const std::string& value) {
3605 if (!_internal_has_utf16_be()) {
3606 clear_encoded_string();
3607 set_has_utf16_be();
3608 _impl_.encoded_string_.utf16_be_.InitDefault();
3609 }
3610 _impl_.encoded_string_.utf16_be_.Set(value, GetArenaForAllocation());
3611 }
_internal_mutable_utf16_be()3612 inline std::string* V8String::_internal_mutable_utf16_be() {
3613 if (!_internal_has_utf16_be()) {
3614 clear_encoded_string();
3615 set_has_utf16_be();
3616 _impl_.encoded_string_.utf16_be_.InitDefault();
3617 }
3618 return _impl_.encoded_string_.utf16_be_.Mutable( GetArenaForAllocation());
3619 }
release_utf16_be()3620 inline std::string* V8String::release_utf16_be() {
3621 // @@protoc_insertion_point(field_release:perfetto.protos.V8String.utf16_be)
3622 if (_internal_has_utf16_be()) {
3623 clear_has_encoded_string();
3624 return _impl_.encoded_string_.utf16_be_.Release();
3625 } else {
3626 return nullptr;
3627 }
3628 }
set_allocated_utf16_be(std::string * utf16_be)3629 inline void V8String::set_allocated_utf16_be(std::string* utf16_be) {
3630 if (has_encoded_string()) {
3631 clear_encoded_string();
3632 }
3633 if (utf16_be != nullptr) {
3634 set_has_utf16_be();
3635 _impl_.encoded_string_.utf16_be_.InitAllocated(utf16_be, GetArenaForAllocation());
3636 }
3637 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.V8String.utf16_be)
3638 }
3639
has_encoded_string()3640 inline bool V8String::has_encoded_string() const {
3641 return encoded_string_case() != ENCODED_STRING_NOT_SET;
3642 }
clear_has_encoded_string()3643 inline void V8String::clear_has_encoded_string() {
3644 _impl_._oneof_case_[0] = ENCODED_STRING_NOT_SET;
3645 }
encoded_string_case()3646 inline V8String::EncodedStringCase V8String::encoded_string_case() const {
3647 return V8String::EncodedStringCase(_impl_._oneof_case_[0]);
3648 }
3649 // -------------------------------------------------------------------
3650
3651 // InternedV8String
3652
3653 // optional uint64 iid = 1;
_internal_has_iid()3654 inline bool InternedV8String::_internal_has_iid() const {
3655 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3656 return value;
3657 }
has_iid()3658 inline bool InternedV8String::has_iid() const {
3659 return _internal_has_iid();
3660 }
clear_iid()3661 inline void InternedV8String::clear_iid() {
3662 _impl_.iid_ = ::uint64_t{0u};
3663 _impl_._has_bits_[0] &= ~0x00000001u;
3664 }
_internal_iid()3665 inline ::uint64_t InternedV8String::_internal_iid() const {
3666 return _impl_.iid_;
3667 }
iid()3668 inline ::uint64_t InternedV8String::iid() const {
3669 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8String.iid)
3670 return _internal_iid();
3671 }
_internal_set_iid(::uint64_t value)3672 inline void InternedV8String::_internal_set_iid(::uint64_t value) {
3673 _impl_._has_bits_[0] |= 0x00000001u;
3674 _impl_.iid_ = value;
3675 }
set_iid(::uint64_t value)3676 inline void InternedV8String::set_iid(::uint64_t value) {
3677 _internal_set_iid(value);
3678 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8String.iid)
3679 }
3680
3681 // bytes latin1 = 2;
_internal_has_latin1()3682 inline bool InternedV8String::_internal_has_latin1() const {
3683 return encoded_string_case() == kLatin1;
3684 }
has_latin1()3685 inline bool InternedV8String::has_latin1() const {
3686 return _internal_has_latin1();
3687 }
set_has_latin1()3688 inline void InternedV8String::set_has_latin1() {
3689 _impl_._oneof_case_[0] = kLatin1;
3690 }
clear_latin1()3691 inline void InternedV8String::clear_latin1() {
3692 if (_internal_has_latin1()) {
3693 _impl_.encoded_string_.latin1_.Destroy();
3694 clear_has_encoded_string();
3695 }
3696 }
latin1()3697 inline const std::string& InternedV8String::latin1() const {
3698 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8String.latin1)
3699 return _internal_latin1();
3700 }
3701 template <typename ArgT0, typename... ArgT>
set_latin1(ArgT0 && arg0,ArgT...args)3702 inline void InternedV8String::set_latin1(ArgT0&& arg0, ArgT... args) {
3703 if (!_internal_has_latin1()) {
3704 clear_encoded_string();
3705 set_has_latin1();
3706 _impl_.encoded_string_.latin1_.InitDefault();
3707 }
3708 _impl_.encoded_string_.latin1_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3709 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8String.latin1)
3710 }
mutable_latin1()3711 inline std::string* InternedV8String::mutable_latin1() {
3712 std::string* _s = _internal_mutable_latin1();
3713 // @@protoc_insertion_point(field_mutable:perfetto.protos.InternedV8String.latin1)
3714 return _s;
3715 }
_internal_latin1()3716 inline const std::string& InternedV8String::_internal_latin1() const {
3717 if (_internal_has_latin1()) {
3718 return _impl_.encoded_string_.latin1_.Get();
3719 }
3720 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3721 }
_internal_set_latin1(const std::string & value)3722 inline void InternedV8String::_internal_set_latin1(const std::string& value) {
3723 if (!_internal_has_latin1()) {
3724 clear_encoded_string();
3725 set_has_latin1();
3726 _impl_.encoded_string_.latin1_.InitDefault();
3727 }
3728 _impl_.encoded_string_.latin1_.Set(value, GetArenaForAllocation());
3729 }
_internal_mutable_latin1()3730 inline std::string* InternedV8String::_internal_mutable_latin1() {
3731 if (!_internal_has_latin1()) {
3732 clear_encoded_string();
3733 set_has_latin1();
3734 _impl_.encoded_string_.latin1_.InitDefault();
3735 }
3736 return _impl_.encoded_string_.latin1_.Mutable( GetArenaForAllocation());
3737 }
release_latin1()3738 inline std::string* InternedV8String::release_latin1() {
3739 // @@protoc_insertion_point(field_release:perfetto.protos.InternedV8String.latin1)
3740 if (_internal_has_latin1()) {
3741 clear_has_encoded_string();
3742 return _impl_.encoded_string_.latin1_.Release();
3743 } else {
3744 return nullptr;
3745 }
3746 }
set_allocated_latin1(std::string * latin1)3747 inline void InternedV8String::set_allocated_latin1(std::string* latin1) {
3748 if (has_encoded_string()) {
3749 clear_encoded_string();
3750 }
3751 if (latin1 != nullptr) {
3752 set_has_latin1();
3753 _impl_.encoded_string_.latin1_.InitAllocated(latin1, GetArenaForAllocation());
3754 }
3755 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.InternedV8String.latin1)
3756 }
3757
3758 // bytes utf16_le = 3;
_internal_has_utf16_le()3759 inline bool InternedV8String::_internal_has_utf16_le() const {
3760 return encoded_string_case() == kUtf16Le;
3761 }
has_utf16_le()3762 inline bool InternedV8String::has_utf16_le() const {
3763 return _internal_has_utf16_le();
3764 }
set_has_utf16_le()3765 inline void InternedV8String::set_has_utf16_le() {
3766 _impl_._oneof_case_[0] = kUtf16Le;
3767 }
clear_utf16_le()3768 inline void InternedV8String::clear_utf16_le() {
3769 if (_internal_has_utf16_le()) {
3770 _impl_.encoded_string_.utf16_le_.Destroy();
3771 clear_has_encoded_string();
3772 }
3773 }
utf16_le()3774 inline const std::string& InternedV8String::utf16_le() const {
3775 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8String.utf16_le)
3776 return _internal_utf16_le();
3777 }
3778 template <typename ArgT0, typename... ArgT>
set_utf16_le(ArgT0 && arg0,ArgT...args)3779 inline void InternedV8String::set_utf16_le(ArgT0&& arg0, ArgT... args) {
3780 if (!_internal_has_utf16_le()) {
3781 clear_encoded_string();
3782 set_has_utf16_le();
3783 _impl_.encoded_string_.utf16_le_.InitDefault();
3784 }
3785 _impl_.encoded_string_.utf16_le_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3786 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8String.utf16_le)
3787 }
mutable_utf16_le()3788 inline std::string* InternedV8String::mutable_utf16_le() {
3789 std::string* _s = _internal_mutable_utf16_le();
3790 // @@protoc_insertion_point(field_mutable:perfetto.protos.InternedV8String.utf16_le)
3791 return _s;
3792 }
_internal_utf16_le()3793 inline const std::string& InternedV8String::_internal_utf16_le() const {
3794 if (_internal_has_utf16_le()) {
3795 return _impl_.encoded_string_.utf16_le_.Get();
3796 }
3797 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3798 }
_internal_set_utf16_le(const std::string & value)3799 inline void InternedV8String::_internal_set_utf16_le(const std::string& value) {
3800 if (!_internal_has_utf16_le()) {
3801 clear_encoded_string();
3802 set_has_utf16_le();
3803 _impl_.encoded_string_.utf16_le_.InitDefault();
3804 }
3805 _impl_.encoded_string_.utf16_le_.Set(value, GetArenaForAllocation());
3806 }
_internal_mutable_utf16_le()3807 inline std::string* InternedV8String::_internal_mutable_utf16_le() {
3808 if (!_internal_has_utf16_le()) {
3809 clear_encoded_string();
3810 set_has_utf16_le();
3811 _impl_.encoded_string_.utf16_le_.InitDefault();
3812 }
3813 return _impl_.encoded_string_.utf16_le_.Mutable( GetArenaForAllocation());
3814 }
release_utf16_le()3815 inline std::string* InternedV8String::release_utf16_le() {
3816 // @@protoc_insertion_point(field_release:perfetto.protos.InternedV8String.utf16_le)
3817 if (_internal_has_utf16_le()) {
3818 clear_has_encoded_string();
3819 return _impl_.encoded_string_.utf16_le_.Release();
3820 } else {
3821 return nullptr;
3822 }
3823 }
set_allocated_utf16_le(std::string * utf16_le)3824 inline void InternedV8String::set_allocated_utf16_le(std::string* utf16_le) {
3825 if (has_encoded_string()) {
3826 clear_encoded_string();
3827 }
3828 if (utf16_le != nullptr) {
3829 set_has_utf16_le();
3830 _impl_.encoded_string_.utf16_le_.InitAllocated(utf16_le, GetArenaForAllocation());
3831 }
3832 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.InternedV8String.utf16_le)
3833 }
3834
3835 // bytes utf16_be = 4;
_internal_has_utf16_be()3836 inline bool InternedV8String::_internal_has_utf16_be() const {
3837 return encoded_string_case() == kUtf16Be;
3838 }
has_utf16_be()3839 inline bool InternedV8String::has_utf16_be() const {
3840 return _internal_has_utf16_be();
3841 }
set_has_utf16_be()3842 inline void InternedV8String::set_has_utf16_be() {
3843 _impl_._oneof_case_[0] = kUtf16Be;
3844 }
clear_utf16_be()3845 inline void InternedV8String::clear_utf16_be() {
3846 if (_internal_has_utf16_be()) {
3847 _impl_.encoded_string_.utf16_be_.Destroy();
3848 clear_has_encoded_string();
3849 }
3850 }
utf16_be()3851 inline const std::string& InternedV8String::utf16_be() const {
3852 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8String.utf16_be)
3853 return _internal_utf16_be();
3854 }
3855 template <typename ArgT0, typename... ArgT>
set_utf16_be(ArgT0 && arg0,ArgT...args)3856 inline void InternedV8String::set_utf16_be(ArgT0&& arg0, ArgT... args) {
3857 if (!_internal_has_utf16_be()) {
3858 clear_encoded_string();
3859 set_has_utf16_be();
3860 _impl_.encoded_string_.utf16_be_.InitDefault();
3861 }
3862 _impl_.encoded_string_.utf16_be_.SetBytes( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3863 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8String.utf16_be)
3864 }
mutable_utf16_be()3865 inline std::string* InternedV8String::mutable_utf16_be() {
3866 std::string* _s = _internal_mutable_utf16_be();
3867 // @@protoc_insertion_point(field_mutable:perfetto.protos.InternedV8String.utf16_be)
3868 return _s;
3869 }
_internal_utf16_be()3870 inline const std::string& InternedV8String::_internal_utf16_be() const {
3871 if (_internal_has_utf16_be()) {
3872 return _impl_.encoded_string_.utf16_be_.Get();
3873 }
3874 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3875 }
_internal_set_utf16_be(const std::string & value)3876 inline void InternedV8String::_internal_set_utf16_be(const std::string& value) {
3877 if (!_internal_has_utf16_be()) {
3878 clear_encoded_string();
3879 set_has_utf16_be();
3880 _impl_.encoded_string_.utf16_be_.InitDefault();
3881 }
3882 _impl_.encoded_string_.utf16_be_.Set(value, GetArenaForAllocation());
3883 }
_internal_mutable_utf16_be()3884 inline std::string* InternedV8String::_internal_mutable_utf16_be() {
3885 if (!_internal_has_utf16_be()) {
3886 clear_encoded_string();
3887 set_has_utf16_be();
3888 _impl_.encoded_string_.utf16_be_.InitDefault();
3889 }
3890 return _impl_.encoded_string_.utf16_be_.Mutable( GetArenaForAllocation());
3891 }
release_utf16_be()3892 inline std::string* InternedV8String::release_utf16_be() {
3893 // @@protoc_insertion_point(field_release:perfetto.protos.InternedV8String.utf16_be)
3894 if (_internal_has_utf16_be()) {
3895 clear_has_encoded_string();
3896 return _impl_.encoded_string_.utf16_be_.Release();
3897 } else {
3898 return nullptr;
3899 }
3900 }
set_allocated_utf16_be(std::string * utf16_be)3901 inline void InternedV8String::set_allocated_utf16_be(std::string* utf16_be) {
3902 if (has_encoded_string()) {
3903 clear_encoded_string();
3904 }
3905 if (utf16_be != nullptr) {
3906 set_has_utf16_be();
3907 _impl_.encoded_string_.utf16_be_.InitAllocated(utf16_be, GetArenaForAllocation());
3908 }
3909 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.InternedV8String.utf16_be)
3910 }
3911
has_encoded_string()3912 inline bool InternedV8String::has_encoded_string() const {
3913 return encoded_string_case() != ENCODED_STRING_NOT_SET;
3914 }
clear_has_encoded_string()3915 inline void InternedV8String::clear_has_encoded_string() {
3916 _impl_._oneof_case_[0] = ENCODED_STRING_NOT_SET;
3917 }
encoded_string_case()3918 inline InternedV8String::EncodedStringCase InternedV8String::encoded_string_case() const {
3919 return InternedV8String::EncodedStringCase(_impl_._oneof_case_[0]);
3920 }
3921 // -------------------------------------------------------------------
3922
3923 // InternedV8JsScript
3924
3925 // optional uint64 iid = 1;
_internal_has_iid()3926 inline bool InternedV8JsScript::_internal_has_iid() const {
3927 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3928 return value;
3929 }
has_iid()3930 inline bool InternedV8JsScript::has_iid() const {
3931 return _internal_has_iid();
3932 }
clear_iid()3933 inline void InternedV8JsScript::clear_iid() {
3934 _impl_.iid_ = ::uint64_t{0u};
3935 _impl_._has_bits_[0] &= ~0x00000004u;
3936 }
_internal_iid()3937 inline ::uint64_t InternedV8JsScript::_internal_iid() const {
3938 return _impl_.iid_;
3939 }
iid()3940 inline ::uint64_t InternedV8JsScript::iid() const {
3941 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsScript.iid)
3942 return _internal_iid();
3943 }
_internal_set_iid(::uint64_t value)3944 inline void InternedV8JsScript::_internal_set_iid(::uint64_t value) {
3945 _impl_._has_bits_[0] |= 0x00000004u;
3946 _impl_.iid_ = value;
3947 }
set_iid(::uint64_t value)3948 inline void InternedV8JsScript::set_iid(::uint64_t value) {
3949 _internal_set_iid(value);
3950 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsScript.iid)
3951 }
3952
3953 // optional int32 script_id = 2;
_internal_has_script_id()3954 inline bool InternedV8JsScript::_internal_has_script_id() const {
3955 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3956 return value;
3957 }
has_script_id()3958 inline bool InternedV8JsScript::has_script_id() const {
3959 return _internal_has_script_id();
3960 }
clear_script_id()3961 inline void InternedV8JsScript::clear_script_id() {
3962 _impl_.script_id_ = 0;
3963 _impl_._has_bits_[0] &= ~0x00000008u;
3964 }
_internal_script_id()3965 inline ::int32_t InternedV8JsScript::_internal_script_id() const {
3966 return _impl_.script_id_;
3967 }
script_id()3968 inline ::int32_t InternedV8JsScript::script_id() const {
3969 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsScript.script_id)
3970 return _internal_script_id();
3971 }
_internal_set_script_id(::int32_t value)3972 inline void InternedV8JsScript::_internal_set_script_id(::int32_t value) {
3973 _impl_._has_bits_[0] |= 0x00000008u;
3974 _impl_.script_id_ = value;
3975 }
set_script_id(::int32_t value)3976 inline void InternedV8JsScript::set_script_id(::int32_t value) {
3977 _internal_set_script_id(value);
3978 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsScript.script_id)
3979 }
3980
3981 // optional .perfetto.protos.InternedV8JsScript.Type type = 3;
_internal_has_type()3982 inline bool InternedV8JsScript::_internal_has_type() const {
3983 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
3984 return value;
3985 }
has_type()3986 inline bool InternedV8JsScript::has_type() const {
3987 return _internal_has_type();
3988 }
clear_type()3989 inline void InternedV8JsScript::clear_type() {
3990 _impl_.type_ = 0;
3991 _impl_._has_bits_[0] &= ~0x00000010u;
3992 }
_internal_type()3993 inline ::perfetto::protos::InternedV8JsScript_Type InternedV8JsScript::_internal_type() const {
3994 return static_cast< ::perfetto::protos::InternedV8JsScript_Type >(_impl_.type_);
3995 }
type()3996 inline ::perfetto::protos::InternedV8JsScript_Type InternedV8JsScript::type() const {
3997 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsScript.type)
3998 return _internal_type();
3999 }
_internal_set_type(::perfetto::protos::InternedV8JsScript_Type value)4000 inline void InternedV8JsScript::_internal_set_type(::perfetto::protos::InternedV8JsScript_Type value) {
4001 assert(::perfetto::protos::InternedV8JsScript_Type_IsValid(value));
4002 _impl_._has_bits_[0] |= 0x00000010u;
4003 _impl_.type_ = value;
4004 }
set_type(::perfetto::protos::InternedV8JsScript_Type value)4005 inline void InternedV8JsScript::set_type(::perfetto::protos::InternedV8JsScript_Type value) {
4006 _internal_set_type(value);
4007 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsScript.type)
4008 }
4009
4010 // optional .perfetto.protos.V8String name = 4;
_internal_has_name()4011 inline bool InternedV8JsScript::_internal_has_name() const {
4012 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4013 PROTOBUF_ASSUME(!value || _impl_.name_ != nullptr);
4014 return value;
4015 }
has_name()4016 inline bool InternedV8JsScript::has_name() const {
4017 return _internal_has_name();
4018 }
clear_name()4019 inline void InternedV8JsScript::clear_name() {
4020 if (_impl_.name_ != nullptr) _impl_.name_->Clear();
4021 _impl_._has_bits_[0] &= ~0x00000001u;
4022 }
_internal_name()4023 inline const ::perfetto::protos::V8String& InternedV8JsScript::_internal_name() const {
4024 const ::perfetto::protos::V8String* p = _impl_.name_;
4025 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::V8String&>(
4026 ::perfetto::protos::_V8String_default_instance_);
4027 }
name()4028 inline const ::perfetto::protos::V8String& InternedV8JsScript::name() const {
4029 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsScript.name)
4030 return _internal_name();
4031 }
unsafe_arena_set_allocated_name(::perfetto::protos::V8String * name)4032 inline void InternedV8JsScript::unsafe_arena_set_allocated_name(
4033 ::perfetto::protos::V8String* name) {
4034 if (GetArenaForAllocation() == nullptr) {
4035 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.name_);
4036 }
4037 _impl_.name_ = name;
4038 if (name) {
4039 _impl_._has_bits_[0] |= 0x00000001u;
4040 } else {
4041 _impl_._has_bits_[0] &= ~0x00000001u;
4042 }
4043 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.InternedV8JsScript.name)
4044 }
release_name()4045 inline ::perfetto::protos::V8String* InternedV8JsScript::release_name() {
4046 _impl_._has_bits_[0] &= ~0x00000001u;
4047 ::perfetto::protos::V8String* temp = _impl_.name_;
4048 _impl_.name_ = nullptr;
4049 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4050 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4051 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4052 if (GetArenaForAllocation() == nullptr) { delete old; }
4053 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4054 if (GetArenaForAllocation() != nullptr) {
4055 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4056 }
4057 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4058 return temp;
4059 }
unsafe_arena_release_name()4060 inline ::perfetto::protos::V8String* InternedV8JsScript::unsafe_arena_release_name() {
4061 // @@protoc_insertion_point(field_release:perfetto.protos.InternedV8JsScript.name)
4062 _impl_._has_bits_[0] &= ~0x00000001u;
4063 ::perfetto::protos::V8String* temp = _impl_.name_;
4064 _impl_.name_ = nullptr;
4065 return temp;
4066 }
_internal_mutable_name()4067 inline ::perfetto::protos::V8String* InternedV8JsScript::_internal_mutable_name() {
4068 _impl_._has_bits_[0] |= 0x00000001u;
4069 if (_impl_.name_ == nullptr) {
4070 auto* p = CreateMaybeMessage<::perfetto::protos::V8String>(GetArenaForAllocation());
4071 _impl_.name_ = p;
4072 }
4073 return _impl_.name_;
4074 }
mutable_name()4075 inline ::perfetto::protos::V8String* InternedV8JsScript::mutable_name() {
4076 ::perfetto::protos::V8String* _msg = _internal_mutable_name();
4077 // @@protoc_insertion_point(field_mutable:perfetto.protos.InternedV8JsScript.name)
4078 return _msg;
4079 }
set_allocated_name(::perfetto::protos::V8String * name)4080 inline void InternedV8JsScript::set_allocated_name(::perfetto::protos::V8String* name) {
4081 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4082 if (message_arena == nullptr) {
4083 delete _impl_.name_;
4084 }
4085 if (name) {
4086 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4087 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(name);
4088 if (message_arena != submessage_arena) {
4089 name = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4090 message_arena, name, submessage_arena);
4091 }
4092 _impl_._has_bits_[0] |= 0x00000001u;
4093 } else {
4094 _impl_._has_bits_[0] &= ~0x00000001u;
4095 }
4096 _impl_.name_ = name;
4097 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.InternedV8JsScript.name)
4098 }
4099
4100 // optional .perfetto.protos.V8String source = 5;
_internal_has_source()4101 inline bool InternedV8JsScript::_internal_has_source() const {
4102 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4103 PROTOBUF_ASSUME(!value || _impl_.source_ != nullptr);
4104 return value;
4105 }
has_source()4106 inline bool InternedV8JsScript::has_source() const {
4107 return _internal_has_source();
4108 }
clear_source()4109 inline void InternedV8JsScript::clear_source() {
4110 if (_impl_.source_ != nullptr) _impl_.source_->Clear();
4111 _impl_._has_bits_[0] &= ~0x00000002u;
4112 }
_internal_source()4113 inline const ::perfetto::protos::V8String& InternedV8JsScript::_internal_source() const {
4114 const ::perfetto::protos::V8String* p = _impl_.source_;
4115 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::V8String&>(
4116 ::perfetto::protos::_V8String_default_instance_);
4117 }
source()4118 inline const ::perfetto::protos::V8String& InternedV8JsScript::source() const {
4119 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsScript.source)
4120 return _internal_source();
4121 }
unsafe_arena_set_allocated_source(::perfetto::protos::V8String * source)4122 inline void InternedV8JsScript::unsafe_arena_set_allocated_source(
4123 ::perfetto::protos::V8String* source) {
4124 if (GetArenaForAllocation() == nullptr) {
4125 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.source_);
4126 }
4127 _impl_.source_ = source;
4128 if (source) {
4129 _impl_._has_bits_[0] |= 0x00000002u;
4130 } else {
4131 _impl_._has_bits_[0] &= ~0x00000002u;
4132 }
4133 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.InternedV8JsScript.source)
4134 }
release_source()4135 inline ::perfetto::protos::V8String* InternedV8JsScript::release_source() {
4136 _impl_._has_bits_[0] &= ~0x00000002u;
4137 ::perfetto::protos::V8String* temp = _impl_.source_;
4138 _impl_.source_ = nullptr;
4139 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4140 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4141 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4142 if (GetArenaForAllocation() == nullptr) { delete old; }
4143 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4144 if (GetArenaForAllocation() != nullptr) {
4145 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4146 }
4147 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4148 return temp;
4149 }
unsafe_arena_release_source()4150 inline ::perfetto::protos::V8String* InternedV8JsScript::unsafe_arena_release_source() {
4151 // @@protoc_insertion_point(field_release:perfetto.protos.InternedV8JsScript.source)
4152 _impl_._has_bits_[0] &= ~0x00000002u;
4153 ::perfetto::protos::V8String* temp = _impl_.source_;
4154 _impl_.source_ = nullptr;
4155 return temp;
4156 }
_internal_mutable_source()4157 inline ::perfetto::protos::V8String* InternedV8JsScript::_internal_mutable_source() {
4158 _impl_._has_bits_[0] |= 0x00000002u;
4159 if (_impl_.source_ == nullptr) {
4160 auto* p = CreateMaybeMessage<::perfetto::protos::V8String>(GetArenaForAllocation());
4161 _impl_.source_ = p;
4162 }
4163 return _impl_.source_;
4164 }
mutable_source()4165 inline ::perfetto::protos::V8String* InternedV8JsScript::mutable_source() {
4166 ::perfetto::protos::V8String* _msg = _internal_mutable_source();
4167 // @@protoc_insertion_point(field_mutable:perfetto.protos.InternedV8JsScript.source)
4168 return _msg;
4169 }
set_allocated_source(::perfetto::protos::V8String * source)4170 inline void InternedV8JsScript::set_allocated_source(::perfetto::protos::V8String* source) {
4171 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4172 if (message_arena == nullptr) {
4173 delete _impl_.source_;
4174 }
4175 if (source) {
4176 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4177 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(source);
4178 if (message_arena != submessage_arena) {
4179 source = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4180 message_arena, source, submessage_arena);
4181 }
4182 _impl_._has_bits_[0] |= 0x00000002u;
4183 } else {
4184 _impl_._has_bits_[0] &= ~0x00000002u;
4185 }
4186 _impl_.source_ = source;
4187 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.InternedV8JsScript.source)
4188 }
4189
4190 // -------------------------------------------------------------------
4191
4192 // InternedV8WasmScript
4193
4194 // optional uint64 iid = 1;
_internal_has_iid()4195 inline bool InternedV8WasmScript::_internal_has_iid() const {
4196 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4197 return value;
4198 }
has_iid()4199 inline bool InternedV8WasmScript::has_iid() const {
4200 return _internal_has_iid();
4201 }
clear_iid()4202 inline void InternedV8WasmScript::clear_iid() {
4203 _impl_.iid_ = ::uint64_t{0u};
4204 _impl_._has_bits_[0] &= ~0x00000002u;
4205 }
_internal_iid()4206 inline ::uint64_t InternedV8WasmScript::_internal_iid() const {
4207 return _impl_.iid_;
4208 }
iid()4209 inline ::uint64_t InternedV8WasmScript::iid() const {
4210 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8WasmScript.iid)
4211 return _internal_iid();
4212 }
_internal_set_iid(::uint64_t value)4213 inline void InternedV8WasmScript::_internal_set_iid(::uint64_t value) {
4214 _impl_._has_bits_[0] |= 0x00000002u;
4215 _impl_.iid_ = value;
4216 }
set_iid(::uint64_t value)4217 inline void InternedV8WasmScript::set_iid(::uint64_t value) {
4218 _internal_set_iid(value);
4219 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8WasmScript.iid)
4220 }
4221
4222 // optional int32 script_id = 2;
_internal_has_script_id()4223 inline bool InternedV8WasmScript::_internal_has_script_id() const {
4224 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4225 return value;
4226 }
has_script_id()4227 inline bool InternedV8WasmScript::has_script_id() const {
4228 return _internal_has_script_id();
4229 }
clear_script_id()4230 inline void InternedV8WasmScript::clear_script_id() {
4231 _impl_.script_id_ = 0;
4232 _impl_._has_bits_[0] &= ~0x00000004u;
4233 }
_internal_script_id()4234 inline ::int32_t InternedV8WasmScript::_internal_script_id() const {
4235 return _impl_.script_id_;
4236 }
script_id()4237 inline ::int32_t InternedV8WasmScript::script_id() const {
4238 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8WasmScript.script_id)
4239 return _internal_script_id();
4240 }
_internal_set_script_id(::int32_t value)4241 inline void InternedV8WasmScript::_internal_set_script_id(::int32_t value) {
4242 _impl_._has_bits_[0] |= 0x00000004u;
4243 _impl_.script_id_ = value;
4244 }
set_script_id(::int32_t value)4245 inline void InternedV8WasmScript::set_script_id(::int32_t value) {
4246 _internal_set_script_id(value);
4247 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8WasmScript.script_id)
4248 }
4249
4250 // optional string url = 3;
_internal_has_url()4251 inline bool InternedV8WasmScript::_internal_has_url() const {
4252 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4253 return value;
4254 }
has_url()4255 inline bool InternedV8WasmScript::has_url() const {
4256 return _internal_has_url();
4257 }
clear_url()4258 inline void InternedV8WasmScript::clear_url() {
4259 _impl_.url_.ClearToEmpty();
4260 _impl_._has_bits_[0] &= ~0x00000001u;
4261 }
url()4262 inline const std::string& InternedV8WasmScript::url() const {
4263 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8WasmScript.url)
4264 return _internal_url();
4265 }
4266 template <typename ArgT0, typename... ArgT>
4267 inline PROTOBUF_ALWAYS_INLINE
set_url(ArgT0 && arg0,ArgT...args)4268 void InternedV8WasmScript::set_url(ArgT0&& arg0, ArgT... args) {
4269 _impl_._has_bits_[0] |= 0x00000001u;
4270 _impl_.url_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4271 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8WasmScript.url)
4272 }
mutable_url()4273 inline std::string* InternedV8WasmScript::mutable_url() {
4274 std::string* _s = _internal_mutable_url();
4275 // @@protoc_insertion_point(field_mutable:perfetto.protos.InternedV8WasmScript.url)
4276 return _s;
4277 }
_internal_url()4278 inline const std::string& InternedV8WasmScript::_internal_url() const {
4279 return _impl_.url_.Get();
4280 }
_internal_set_url(const std::string & value)4281 inline void InternedV8WasmScript::_internal_set_url(const std::string& value) {
4282 _impl_._has_bits_[0] |= 0x00000001u;
4283 _impl_.url_.Set(value, GetArenaForAllocation());
4284 }
_internal_mutable_url()4285 inline std::string* InternedV8WasmScript::_internal_mutable_url() {
4286 _impl_._has_bits_[0] |= 0x00000001u;
4287 return _impl_.url_.Mutable(GetArenaForAllocation());
4288 }
release_url()4289 inline std::string* InternedV8WasmScript::release_url() {
4290 // @@protoc_insertion_point(field_release:perfetto.protos.InternedV8WasmScript.url)
4291 if (!_internal_has_url()) {
4292 return nullptr;
4293 }
4294 _impl_._has_bits_[0] &= ~0x00000001u;
4295 auto* p = _impl_.url_.Release();
4296 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4297 if (_impl_.url_.IsDefault()) {
4298 _impl_.url_.Set("", GetArenaForAllocation());
4299 }
4300 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4301 return p;
4302 }
set_allocated_url(std::string * url)4303 inline void InternedV8WasmScript::set_allocated_url(std::string* url) {
4304 if (url != nullptr) {
4305 _impl_._has_bits_[0] |= 0x00000001u;
4306 } else {
4307 _impl_._has_bits_[0] &= ~0x00000001u;
4308 }
4309 _impl_.url_.SetAllocated(url, GetArenaForAllocation());
4310 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4311 if (_impl_.url_.IsDefault()) {
4312 _impl_.url_.Set("", GetArenaForAllocation());
4313 }
4314 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4315 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.InternedV8WasmScript.url)
4316 }
4317
4318 // -------------------------------------------------------------------
4319
4320 // InternedV8JsFunction
4321
4322 // optional uint64 iid = 1;
_internal_has_iid()4323 inline bool InternedV8JsFunction::_internal_has_iid() const {
4324 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4325 return value;
4326 }
has_iid()4327 inline bool InternedV8JsFunction::has_iid() const {
4328 return _internal_has_iid();
4329 }
clear_iid()4330 inline void InternedV8JsFunction::clear_iid() {
4331 _impl_.iid_ = ::uint64_t{0u};
4332 _impl_._has_bits_[0] &= ~0x00000001u;
4333 }
_internal_iid()4334 inline ::uint64_t InternedV8JsFunction::_internal_iid() const {
4335 return _impl_.iid_;
4336 }
iid()4337 inline ::uint64_t InternedV8JsFunction::iid() const {
4338 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsFunction.iid)
4339 return _internal_iid();
4340 }
_internal_set_iid(::uint64_t value)4341 inline void InternedV8JsFunction::_internal_set_iid(::uint64_t value) {
4342 _impl_._has_bits_[0] |= 0x00000001u;
4343 _impl_.iid_ = value;
4344 }
set_iid(::uint64_t value)4345 inline void InternedV8JsFunction::set_iid(::uint64_t value) {
4346 _internal_set_iid(value);
4347 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsFunction.iid)
4348 }
4349
4350 // optional uint64 v8_js_function_name_iid = 2;
_internal_has_v8_js_function_name_iid()4351 inline bool InternedV8JsFunction::_internal_has_v8_js_function_name_iid() const {
4352 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4353 return value;
4354 }
has_v8_js_function_name_iid()4355 inline bool InternedV8JsFunction::has_v8_js_function_name_iid() const {
4356 return _internal_has_v8_js_function_name_iid();
4357 }
clear_v8_js_function_name_iid()4358 inline void InternedV8JsFunction::clear_v8_js_function_name_iid() {
4359 _impl_.v8_js_function_name_iid_ = ::uint64_t{0u};
4360 _impl_._has_bits_[0] &= ~0x00000002u;
4361 }
_internal_v8_js_function_name_iid()4362 inline ::uint64_t InternedV8JsFunction::_internal_v8_js_function_name_iid() const {
4363 return _impl_.v8_js_function_name_iid_;
4364 }
v8_js_function_name_iid()4365 inline ::uint64_t InternedV8JsFunction::v8_js_function_name_iid() const {
4366 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsFunction.v8_js_function_name_iid)
4367 return _internal_v8_js_function_name_iid();
4368 }
_internal_set_v8_js_function_name_iid(::uint64_t value)4369 inline void InternedV8JsFunction::_internal_set_v8_js_function_name_iid(::uint64_t value) {
4370 _impl_._has_bits_[0] |= 0x00000002u;
4371 _impl_.v8_js_function_name_iid_ = value;
4372 }
set_v8_js_function_name_iid(::uint64_t value)4373 inline void InternedV8JsFunction::set_v8_js_function_name_iid(::uint64_t value) {
4374 _internal_set_v8_js_function_name_iid(value);
4375 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsFunction.v8_js_function_name_iid)
4376 }
4377
4378 // optional uint64 v8_js_script_iid = 3;
_internal_has_v8_js_script_iid()4379 inline bool InternedV8JsFunction::_internal_has_v8_js_script_iid() const {
4380 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4381 return value;
4382 }
has_v8_js_script_iid()4383 inline bool InternedV8JsFunction::has_v8_js_script_iid() const {
4384 return _internal_has_v8_js_script_iid();
4385 }
clear_v8_js_script_iid()4386 inline void InternedV8JsFunction::clear_v8_js_script_iid() {
4387 _impl_.v8_js_script_iid_ = ::uint64_t{0u};
4388 _impl_._has_bits_[0] &= ~0x00000004u;
4389 }
_internal_v8_js_script_iid()4390 inline ::uint64_t InternedV8JsFunction::_internal_v8_js_script_iid() const {
4391 return _impl_.v8_js_script_iid_;
4392 }
v8_js_script_iid()4393 inline ::uint64_t InternedV8JsFunction::v8_js_script_iid() const {
4394 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsFunction.v8_js_script_iid)
4395 return _internal_v8_js_script_iid();
4396 }
_internal_set_v8_js_script_iid(::uint64_t value)4397 inline void InternedV8JsFunction::_internal_set_v8_js_script_iid(::uint64_t value) {
4398 _impl_._has_bits_[0] |= 0x00000004u;
4399 _impl_.v8_js_script_iid_ = value;
4400 }
set_v8_js_script_iid(::uint64_t value)4401 inline void InternedV8JsFunction::set_v8_js_script_iid(::uint64_t value) {
4402 _internal_set_v8_js_script_iid(value);
4403 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsFunction.v8_js_script_iid)
4404 }
4405
4406 // optional bool is_toplevel = 4;
_internal_has_is_toplevel()4407 inline bool InternedV8JsFunction::_internal_has_is_toplevel() const {
4408 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4409 return value;
4410 }
has_is_toplevel()4411 inline bool InternedV8JsFunction::has_is_toplevel() const {
4412 return _internal_has_is_toplevel();
4413 }
clear_is_toplevel()4414 inline void InternedV8JsFunction::clear_is_toplevel() {
4415 _impl_.is_toplevel_ = false;
4416 _impl_._has_bits_[0] &= ~0x00000008u;
4417 }
_internal_is_toplevel()4418 inline bool InternedV8JsFunction::_internal_is_toplevel() const {
4419 return _impl_.is_toplevel_;
4420 }
is_toplevel()4421 inline bool InternedV8JsFunction::is_toplevel() const {
4422 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsFunction.is_toplevel)
4423 return _internal_is_toplevel();
4424 }
_internal_set_is_toplevel(bool value)4425 inline void InternedV8JsFunction::_internal_set_is_toplevel(bool value) {
4426 _impl_._has_bits_[0] |= 0x00000008u;
4427 _impl_.is_toplevel_ = value;
4428 }
set_is_toplevel(bool value)4429 inline void InternedV8JsFunction::set_is_toplevel(bool value) {
4430 _internal_set_is_toplevel(value);
4431 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsFunction.is_toplevel)
4432 }
4433
4434 // optional .perfetto.protos.InternedV8JsFunction.Kind kind = 5;
_internal_has_kind()4435 inline bool InternedV8JsFunction::_internal_has_kind() const {
4436 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
4437 return value;
4438 }
has_kind()4439 inline bool InternedV8JsFunction::has_kind() const {
4440 return _internal_has_kind();
4441 }
clear_kind()4442 inline void InternedV8JsFunction::clear_kind() {
4443 _impl_.kind_ = 0;
4444 _impl_._has_bits_[0] &= ~0x00000010u;
4445 }
_internal_kind()4446 inline ::perfetto::protos::InternedV8JsFunction_Kind InternedV8JsFunction::_internal_kind() const {
4447 return static_cast< ::perfetto::protos::InternedV8JsFunction_Kind >(_impl_.kind_);
4448 }
kind()4449 inline ::perfetto::protos::InternedV8JsFunction_Kind InternedV8JsFunction::kind() const {
4450 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsFunction.kind)
4451 return _internal_kind();
4452 }
_internal_set_kind(::perfetto::protos::InternedV8JsFunction_Kind value)4453 inline void InternedV8JsFunction::_internal_set_kind(::perfetto::protos::InternedV8JsFunction_Kind value) {
4454 assert(::perfetto::protos::InternedV8JsFunction_Kind_IsValid(value));
4455 _impl_._has_bits_[0] |= 0x00000010u;
4456 _impl_.kind_ = value;
4457 }
set_kind(::perfetto::protos::InternedV8JsFunction_Kind value)4458 inline void InternedV8JsFunction::set_kind(::perfetto::protos::InternedV8JsFunction_Kind value) {
4459 _internal_set_kind(value);
4460 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsFunction.kind)
4461 }
4462
4463 // optional uint32 byte_offset = 6;
_internal_has_byte_offset()4464 inline bool InternedV8JsFunction::_internal_has_byte_offset() const {
4465 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
4466 return value;
4467 }
has_byte_offset()4468 inline bool InternedV8JsFunction::has_byte_offset() const {
4469 return _internal_has_byte_offset();
4470 }
clear_byte_offset()4471 inline void InternedV8JsFunction::clear_byte_offset() {
4472 _impl_.byte_offset_ = 0u;
4473 _impl_._has_bits_[0] &= ~0x00000020u;
4474 }
_internal_byte_offset()4475 inline ::uint32_t InternedV8JsFunction::_internal_byte_offset() const {
4476 return _impl_.byte_offset_;
4477 }
byte_offset()4478 inline ::uint32_t InternedV8JsFunction::byte_offset() const {
4479 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8JsFunction.byte_offset)
4480 return _internal_byte_offset();
4481 }
_internal_set_byte_offset(::uint32_t value)4482 inline void InternedV8JsFunction::_internal_set_byte_offset(::uint32_t value) {
4483 _impl_._has_bits_[0] |= 0x00000020u;
4484 _impl_.byte_offset_ = value;
4485 }
set_byte_offset(::uint32_t value)4486 inline void InternedV8JsFunction::set_byte_offset(::uint32_t value) {
4487 _internal_set_byte_offset(value);
4488 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8JsFunction.byte_offset)
4489 }
4490
4491 // -------------------------------------------------------------------
4492
4493 // InternedV8Isolate_CodeRange
4494
4495 // optional uint64 base_address = 1;
_internal_has_base_address()4496 inline bool InternedV8Isolate_CodeRange::_internal_has_base_address() const {
4497 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4498 return value;
4499 }
has_base_address()4500 inline bool InternedV8Isolate_CodeRange::has_base_address() const {
4501 return _internal_has_base_address();
4502 }
clear_base_address()4503 inline void InternedV8Isolate_CodeRange::clear_base_address() {
4504 _impl_.base_address_ = ::uint64_t{0u};
4505 _impl_._has_bits_[0] &= ~0x00000001u;
4506 }
_internal_base_address()4507 inline ::uint64_t InternedV8Isolate_CodeRange::_internal_base_address() const {
4508 return _impl_.base_address_;
4509 }
base_address()4510 inline ::uint64_t InternedV8Isolate_CodeRange::base_address() const {
4511 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.CodeRange.base_address)
4512 return _internal_base_address();
4513 }
_internal_set_base_address(::uint64_t value)4514 inline void InternedV8Isolate_CodeRange::_internal_set_base_address(::uint64_t value) {
4515 _impl_._has_bits_[0] |= 0x00000001u;
4516 _impl_.base_address_ = value;
4517 }
set_base_address(::uint64_t value)4518 inline void InternedV8Isolate_CodeRange::set_base_address(::uint64_t value) {
4519 _internal_set_base_address(value);
4520 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.CodeRange.base_address)
4521 }
4522
4523 // optional uint64 size = 2;
_internal_has_size()4524 inline bool InternedV8Isolate_CodeRange::_internal_has_size() const {
4525 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4526 return value;
4527 }
has_size()4528 inline bool InternedV8Isolate_CodeRange::has_size() const {
4529 return _internal_has_size();
4530 }
clear_size()4531 inline void InternedV8Isolate_CodeRange::clear_size() {
4532 _impl_.size_ = ::uint64_t{0u};
4533 _impl_._has_bits_[0] &= ~0x00000002u;
4534 }
_internal_size()4535 inline ::uint64_t InternedV8Isolate_CodeRange::_internal_size() const {
4536 return _impl_.size_;
4537 }
size()4538 inline ::uint64_t InternedV8Isolate_CodeRange::size() const {
4539 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.CodeRange.size)
4540 return _internal_size();
4541 }
_internal_set_size(::uint64_t value)4542 inline void InternedV8Isolate_CodeRange::_internal_set_size(::uint64_t value) {
4543 _impl_._has_bits_[0] |= 0x00000002u;
4544 _impl_.size_ = value;
4545 }
set_size(::uint64_t value)4546 inline void InternedV8Isolate_CodeRange::set_size(::uint64_t value) {
4547 _internal_set_size(value);
4548 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.CodeRange.size)
4549 }
4550
4551 // optional uint64 embedded_blob_code_copy_start_address = 3;
_internal_has_embedded_blob_code_copy_start_address()4552 inline bool InternedV8Isolate_CodeRange::_internal_has_embedded_blob_code_copy_start_address() const {
4553 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4554 return value;
4555 }
has_embedded_blob_code_copy_start_address()4556 inline bool InternedV8Isolate_CodeRange::has_embedded_blob_code_copy_start_address() const {
4557 return _internal_has_embedded_blob_code_copy_start_address();
4558 }
clear_embedded_blob_code_copy_start_address()4559 inline void InternedV8Isolate_CodeRange::clear_embedded_blob_code_copy_start_address() {
4560 _impl_.embedded_blob_code_copy_start_address_ = ::uint64_t{0u};
4561 _impl_._has_bits_[0] &= ~0x00000004u;
4562 }
_internal_embedded_blob_code_copy_start_address()4563 inline ::uint64_t InternedV8Isolate_CodeRange::_internal_embedded_blob_code_copy_start_address() const {
4564 return _impl_.embedded_blob_code_copy_start_address_;
4565 }
embedded_blob_code_copy_start_address()4566 inline ::uint64_t InternedV8Isolate_CodeRange::embedded_blob_code_copy_start_address() const {
4567 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.CodeRange.embedded_blob_code_copy_start_address)
4568 return _internal_embedded_blob_code_copy_start_address();
4569 }
_internal_set_embedded_blob_code_copy_start_address(::uint64_t value)4570 inline void InternedV8Isolate_CodeRange::_internal_set_embedded_blob_code_copy_start_address(::uint64_t value) {
4571 _impl_._has_bits_[0] |= 0x00000004u;
4572 _impl_.embedded_blob_code_copy_start_address_ = value;
4573 }
set_embedded_blob_code_copy_start_address(::uint64_t value)4574 inline void InternedV8Isolate_CodeRange::set_embedded_blob_code_copy_start_address(::uint64_t value) {
4575 _internal_set_embedded_blob_code_copy_start_address(value);
4576 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.CodeRange.embedded_blob_code_copy_start_address)
4577 }
4578
4579 // optional bool is_process_wide = 4;
_internal_has_is_process_wide()4580 inline bool InternedV8Isolate_CodeRange::_internal_has_is_process_wide() const {
4581 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4582 return value;
4583 }
has_is_process_wide()4584 inline bool InternedV8Isolate_CodeRange::has_is_process_wide() const {
4585 return _internal_has_is_process_wide();
4586 }
clear_is_process_wide()4587 inline void InternedV8Isolate_CodeRange::clear_is_process_wide() {
4588 _impl_.is_process_wide_ = false;
4589 _impl_._has_bits_[0] &= ~0x00000008u;
4590 }
_internal_is_process_wide()4591 inline bool InternedV8Isolate_CodeRange::_internal_is_process_wide() const {
4592 return _impl_.is_process_wide_;
4593 }
is_process_wide()4594 inline bool InternedV8Isolate_CodeRange::is_process_wide() const {
4595 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.CodeRange.is_process_wide)
4596 return _internal_is_process_wide();
4597 }
_internal_set_is_process_wide(bool value)4598 inline void InternedV8Isolate_CodeRange::_internal_set_is_process_wide(bool value) {
4599 _impl_._has_bits_[0] |= 0x00000008u;
4600 _impl_.is_process_wide_ = value;
4601 }
set_is_process_wide(bool value)4602 inline void InternedV8Isolate_CodeRange::set_is_process_wide(bool value) {
4603 _internal_set_is_process_wide(value);
4604 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.CodeRange.is_process_wide)
4605 }
4606
4607 // -------------------------------------------------------------------
4608
4609 // InternedV8Isolate
4610
4611 // optional uint64 iid = 1;
_internal_has_iid()4612 inline bool InternedV8Isolate::_internal_has_iid() const {
4613 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
4614 return value;
4615 }
has_iid()4616 inline bool InternedV8Isolate::has_iid() const {
4617 return _internal_has_iid();
4618 }
clear_iid()4619 inline void InternedV8Isolate::clear_iid() {
4620 _impl_.iid_ = ::uint64_t{0u};
4621 _impl_._has_bits_[0] &= ~0x00000002u;
4622 }
_internal_iid()4623 inline ::uint64_t InternedV8Isolate::_internal_iid() const {
4624 return _impl_.iid_;
4625 }
iid()4626 inline ::uint64_t InternedV8Isolate::iid() const {
4627 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.iid)
4628 return _internal_iid();
4629 }
_internal_set_iid(::uint64_t value)4630 inline void InternedV8Isolate::_internal_set_iid(::uint64_t value) {
4631 _impl_._has_bits_[0] |= 0x00000002u;
4632 _impl_.iid_ = value;
4633 }
set_iid(::uint64_t value)4634 inline void InternedV8Isolate::set_iid(::uint64_t value) {
4635 _internal_set_iid(value);
4636 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.iid)
4637 }
4638
4639 // optional uint32 pid = 2;
_internal_has_pid()4640 inline bool InternedV8Isolate::_internal_has_pid() const {
4641 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
4642 return value;
4643 }
has_pid()4644 inline bool InternedV8Isolate::has_pid() const {
4645 return _internal_has_pid();
4646 }
clear_pid()4647 inline void InternedV8Isolate::clear_pid() {
4648 _impl_.pid_ = 0u;
4649 _impl_._has_bits_[0] &= ~0x00000004u;
4650 }
_internal_pid()4651 inline ::uint32_t InternedV8Isolate::_internal_pid() const {
4652 return _impl_.pid_;
4653 }
pid()4654 inline ::uint32_t InternedV8Isolate::pid() const {
4655 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.pid)
4656 return _internal_pid();
4657 }
_internal_set_pid(::uint32_t value)4658 inline void InternedV8Isolate::_internal_set_pid(::uint32_t value) {
4659 _impl_._has_bits_[0] |= 0x00000004u;
4660 _impl_.pid_ = value;
4661 }
set_pid(::uint32_t value)4662 inline void InternedV8Isolate::set_pid(::uint32_t value) {
4663 _internal_set_pid(value);
4664 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.pid)
4665 }
4666
4667 // optional int32 isolate_id = 3;
_internal_has_isolate_id()4668 inline bool InternedV8Isolate::_internal_has_isolate_id() const {
4669 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
4670 return value;
4671 }
has_isolate_id()4672 inline bool InternedV8Isolate::has_isolate_id() const {
4673 return _internal_has_isolate_id();
4674 }
clear_isolate_id()4675 inline void InternedV8Isolate::clear_isolate_id() {
4676 _impl_.isolate_id_ = 0;
4677 _impl_._has_bits_[0] &= ~0x00000008u;
4678 }
_internal_isolate_id()4679 inline ::int32_t InternedV8Isolate::_internal_isolate_id() const {
4680 return _impl_.isolate_id_;
4681 }
isolate_id()4682 inline ::int32_t InternedV8Isolate::isolate_id() const {
4683 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.isolate_id)
4684 return _internal_isolate_id();
4685 }
_internal_set_isolate_id(::int32_t value)4686 inline void InternedV8Isolate::_internal_set_isolate_id(::int32_t value) {
4687 _impl_._has_bits_[0] |= 0x00000008u;
4688 _impl_.isolate_id_ = value;
4689 }
set_isolate_id(::int32_t value)4690 inline void InternedV8Isolate::set_isolate_id(::int32_t value) {
4691 _internal_set_isolate_id(value);
4692 // @@protoc_insertion_point(field_set:perfetto.protos.InternedV8Isolate.isolate_id)
4693 }
4694
4695 // optional .perfetto.protos.InternedV8Isolate.CodeRange code_range = 4;
_internal_has_code_range()4696 inline bool InternedV8Isolate::_internal_has_code_range() const {
4697 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
4698 PROTOBUF_ASSUME(!value || _impl_.code_range_ != nullptr);
4699 return value;
4700 }
has_code_range()4701 inline bool InternedV8Isolate::has_code_range() const {
4702 return _internal_has_code_range();
4703 }
clear_code_range()4704 inline void InternedV8Isolate::clear_code_range() {
4705 if (_impl_.code_range_ != nullptr) _impl_.code_range_->Clear();
4706 _impl_._has_bits_[0] &= ~0x00000001u;
4707 }
_internal_code_range()4708 inline const ::perfetto::protos::InternedV8Isolate_CodeRange& InternedV8Isolate::_internal_code_range() const {
4709 const ::perfetto::protos::InternedV8Isolate_CodeRange* p = _impl_.code_range_;
4710 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::InternedV8Isolate_CodeRange&>(
4711 ::perfetto::protos::_InternedV8Isolate_CodeRange_default_instance_);
4712 }
code_range()4713 inline const ::perfetto::protos::InternedV8Isolate_CodeRange& InternedV8Isolate::code_range() const {
4714 // @@protoc_insertion_point(field_get:perfetto.protos.InternedV8Isolate.code_range)
4715 return _internal_code_range();
4716 }
unsafe_arena_set_allocated_code_range(::perfetto::protos::InternedV8Isolate_CodeRange * code_range)4717 inline void InternedV8Isolate::unsafe_arena_set_allocated_code_range(
4718 ::perfetto::protos::InternedV8Isolate_CodeRange* code_range) {
4719 if (GetArenaForAllocation() == nullptr) {
4720 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.code_range_);
4721 }
4722 _impl_.code_range_ = code_range;
4723 if (code_range) {
4724 _impl_._has_bits_[0] |= 0x00000001u;
4725 } else {
4726 _impl_._has_bits_[0] &= ~0x00000001u;
4727 }
4728 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.InternedV8Isolate.code_range)
4729 }
release_code_range()4730