1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/chrome/chrome_trace_event.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_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_2fchrome_5ftrace_5fevent_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_2fchrome_5ftrace_5fevent_2eproto {
44   static const ::uint32_t offsets[];
45 };
46 namespace perfetto {
47 namespace protos {
48 class ChromeEventBundle;
49 struct ChromeEventBundleDefaultTypeInternal;
50 extern ChromeEventBundleDefaultTypeInternal _ChromeEventBundle_default_instance_;
51 class ChromeLegacyJsonTrace;
52 struct ChromeLegacyJsonTraceDefaultTypeInternal;
53 extern ChromeLegacyJsonTraceDefaultTypeInternal _ChromeLegacyJsonTrace_default_instance_;
54 class ChromeMetadata;
55 struct ChromeMetadataDefaultTypeInternal;
56 extern ChromeMetadataDefaultTypeInternal _ChromeMetadata_default_instance_;
57 class ChromeStringTableEntry;
58 struct ChromeStringTableEntryDefaultTypeInternal;
59 extern ChromeStringTableEntryDefaultTypeInternal _ChromeStringTableEntry_default_instance_;
60 class ChromeTraceEvent;
61 struct ChromeTraceEventDefaultTypeInternal;
62 extern ChromeTraceEventDefaultTypeInternal _ChromeTraceEvent_default_instance_;
63 class ChromeTraceEvent_Arg;
64 struct ChromeTraceEvent_ArgDefaultTypeInternal;
65 extern ChromeTraceEvent_ArgDefaultTypeInternal _ChromeTraceEvent_Arg_default_instance_;
66 class ChromeTracedValue;
67 struct ChromeTracedValueDefaultTypeInternal;
68 extern ChromeTracedValueDefaultTypeInternal _ChromeTracedValue_default_instance_;
69 }  // namespace protos
70 }  // namespace perfetto
71 PROTOBUF_NAMESPACE_OPEN
72 template<> ::perfetto::protos::ChromeEventBundle* Arena::CreateMaybeMessage<::perfetto::protos::ChromeEventBundle>(Arena*);
73 template<> ::perfetto::protos::ChromeLegacyJsonTrace* Arena::CreateMaybeMessage<::perfetto::protos::ChromeLegacyJsonTrace>(Arena*);
74 template<> ::perfetto::protos::ChromeMetadata* Arena::CreateMaybeMessage<::perfetto::protos::ChromeMetadata>(Arena*);
75 template<> ::perfetto::protos::ChromeStringTableEntry* Arena::CreateMaybeMessage<::perfetto::protos::ChromeStringTableEntry>(Arena*);
76 template<> ::perfetto::protos::ChromeTraceEvent* Arena::CreateMaybeMessage<::perfetto::protos::ChromeTraceEvent>(Arena*);
77 template<> ::perfetto::protos::ChromeTraceEvent_Arg* Arena::CreateMaybeMessage<::perfetto::protos::ChromeTraceEvent_Arg>(Arena*);
78 template<> ::perfetto::protos::ChromeTracedValue* Arena::CreateMaybeMessage<::perfetto::protos::ChromeTracedValue>(Arena*);
79 PROTOBUF_NAMESPACE_CLOSE
80 namespace perfetto {
81 namespace protos {
82 
83 enum ChromeTracedValue_NestedType : int {
84   ChromeTracedValue_NestedType_DICT = 0,
85   ChromeTracedValue_NestedType_ARRAY = 1
86 };
87 bool ChromeTracedValue_NestedType_IsValid(int value);
88 constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_NestedType_MIN = ChromeTracedValue_NestedType_DICT;
89 constexpr ChromeTracedValue_NestedType ChromeTracedValue_NestedType_NestedType_MAX = ChromeTracedValue_NestedType_ARRAY;
90 constexpr int ChromeTracedValue_NestedType_NestedType_ARRAYSIZE = ChromeTracedValue_NestedType_NestedType_MAX + 1;
91 
92 const std::string& ChromeTracedValue_NestedType_Name(ChromeTracedValue_NestedType value);
93 template<typename T>
ChromeTracedValue_NestedType_Name(T enum_t_value)94 inline const std::string& ChromeTracedValue_NestedType_Name(T enum_t_value) {
95   static_assert(::std::is_same<T, ChromeTracedValue_NestedType>::value ||
96     ::std::is_integral<T>::value,
97     "Incorrect type passed to function ChromeTracedValue_NestedType_Name.");
98   return ChromeTracedValue_NestedType_Name(static_cast<ChromeTracedValue_NestedType>(enum_t_value));
99 }
100 bool ChromeTracedValue_NestedType_Parse(
101     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeTracedValue_NestedType* value);
102 enum ChromeLegacyJsonTrace_TraceType : int {
103   ChromeLegacyJsonTrace_TraceType_USER_TRACE = 0,
104   ChromeLegacyJsonTrace_TraceType_SYSTEM_TRACE = 1
105 };
106 bool ChromeLegacyJsonTrace_TraceType_IsValid(int value);
107 constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_TraceType_MIN = ChromeLegacyJsonTrace_TraceType_USER_TRACE;
108 constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace_TraceType_TraceType_MAX = ChromeLegacyJsonTrace_TraceType_SYSTEM_TRACE;
109 constexpr int ChromeLegacyJsonTrace_TraceType_TraceType_ARRAYSIZE = ChromeLegacyJsonTrace_TraceType_TraceType_MAX + 1;
110 
111 const std::string& ChromeLegacyJsonTrace_TraceType_Name(ChromeLegacyJsonTrace_TraceType value);
112 template<typename T>
ChromeLegacyJsonTrace_TraceType_Name(T enum_t_value)113 inline const std::string& ChromeLegacyJsonTrace_TraceType_Name(T enum_t_value) {
114   static_assert(::std::is_same<T, ChromeLegacyJsonTrace_TraceType>::value ||
115     ::std::is_integral<T>::value,
116     "Incorrect type passed to function ChromeLegacyJsonTrace_TraceType_Name.");
117   return ChromeLegacyJsonTrace_TraceType_Name(static_cast<ChromeLegacyJsonTrace_TraceType>(enum_t_value));
118 }
119 bool ChromeLegacyJsonTrace_TraceType_Parse(
120     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeLegacyJsonTrace_TraceType* value);
121 // ===================================================================
122 
123 class ChromeTracedValue final :
124     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeTracedValue) */ {
125  public:
ChromeTracedValue()126   inline ChromeTracedValue() : ChromeTracedValue(nullptr) {}
127   ~ChromeTracedValue() override;
128   explicit PROTOBUF_CONSTEXPR ChromeTracedValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
129 
130   ChromeTracedValue(const ChromeTracedValue& from);
ChromeTracedValue(ChromeTracedValue && from)131   ChromeTracedValue(ChromeTracedValue&& from) noexcept
132     : ChromeTracedValue() {
133     *this = ::std::move(from);
134   }
135 
136   inline ChromeTracedValue& operator=(const ChromeTracedValue& from) {
137     if (this == &from) return *this;
138     CopyFrom(from);
139     return *this;
140   }
141   inline ChromeTracedValue& operator=(ChromeTracedValue&& from) noexcept {
142     if (this == &from) return *this;
143     if (GetOwningArena() == from.GetOwningArena()
144   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
145         && GetOwningArena() != nullptr
146   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
147     ) {
148       InternalSwap(&from);
149     } else {
150       CopyFrom(from);
151     }
152     return *this;
153   }
154 
unknown_fields()155   inline const std::string& unknown_fields() const {
156     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
157   }
mutable_unknown_fields()158   inline std::string* mutable_unknown_fields() {
159     return _internal_metadata_.mutable_unknown_fields<std::string>();
160   }
161 
default_instance()162   static const ChromeTracedValue& default_instance() {
163     return *internal_default_instance();
164   }
internal_default_instance()165   static inline const ChromeTracedValue* internal_default_instance() {
166     return reinterpret_cast<const ChromeTracedValue*>(
167                &_ChromeTracedValue_default_instance_);
168   }
169   static constexpr int kIndexInFileMessages =
170     0;
171 
swap(ChromeTracedValue & a,ChromeTracedValue & b)172   friend void swap(ChromeTracedValue& a, ChromeTracedValue& b) {
173     a.Swap(&b);
174   }
Swap(ChromeTracedValue * other)175   inline void Swap(ChromeTracedValue* other) {
176     if (other == this) return;
177   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
178     if (GetOwningArena() != nullptr &&
179         GetOwningArena() == other->GetOwningArena()) {
180    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
181     if (GetOwningArena() == other->GetOwningArena()) {
182   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
183       InternalSwap(other);
184     } else {
185       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
186     }
187   }
188   void UnsafeArenaSwap(ChromeTracedValue* other) {
189     if (other == this) return;
190     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
191     InternalSwap(other);
192   }
193 
194   // implements Message ----------------------------------------------
195 
196   ChromeTracedValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
197     return CreateMaybeMessage<ChromeTracedValue>(arena);
198   }
199   ChromeTracedValue* New() const {
200     return New(nullptr);
201   }
202   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
203   void CopyFrom(const ChromeTracedValue& from);
204   void MergeFrom(const ChromeTracedValue& from);
205   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
206   bool IsInitialized() const final;
207 
208   size_t ByteSizeLong() const final;
209   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
210   ::uint8_t* _InternalSerialize(
211       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
212   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
213 
214   private:
215   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
216   void SharedDtor();
217   void SetCachedSize(int size) const;
218   void InternalSwap(ChromeTracedValue* other);
219 
220   private:
221   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
222   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
223     return "perfetto.protos.ChromeTracedValue";
224   }
225   protected:
226   explicit ChromeTracedValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
227                        bool is_message_owned = false);
228   public:
229 
230   std::string GetTypeName() const final;
231 
232   // nested types ----------------------------------------------------
233 
234   typedef ChromeTracedValue_NestedType NestedType;
235   static constexpr NestedType DICT =
236     ChromeTracedValue_NestedType_DICT;
237   static constexpr NestedType ARRAY =
238     ChromeTracedValue_NestedType_ARRAY;
239   static inline bool NestedType_IsValid(int value) {
240     return ChromeTracedValue_NestedType_IsValid(value);
241   }
242   static constexpr NestedType NestedType_MIN =
243     ChromeTracedValue_NestedType_NestedType_MIN;
244   static constexpr NestedType NestedType_MAX =
245     ChromeTracedValue_NestedType_NestedType_MAX;
246   static constexpr int NestedType_ARRAYSIZE =
247     ChromeTracedValue_NestedType_NestedType_ARRAYSIZE;
248   template<typename T>
249   static inline const std::string& NestedType_Name(T enum_t_value) {
250     static_assert(::std::is_same<T, NestedType>::value ||
251       ::std::is_integral<T>::value,
252       "Incorrect type passed to function NestedType_Name.");
253     return ChromeTracedValue_NestedType_Name(enum_t_value);
254   }
255   static inline bool NestedType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
256       NestedType* value) {
257     return ChromeTracedValue_NestedType_Parse(name, value);
258   }
259 
260   // accessors -------------------------------------------------------
261 
262   enum : int {
263     kDictKeysFieldNumber = 2,
264     kDictValuesFieldNumber = 3,
265     kArrayValuesFieldNumber = 4,
266     kStringValueFieldNumber = 8,
267     kNestedTypeFieldNumber = 1,
268     kIntValueFieldNumber = 5,
269     kDoubleValueFieldNumber = 6,
270     kBoolValueFieldNumber = 7,
271   };
272   // repeated string dict_keys = 2;
273   int dict_keys_size() const;
274   private:
275   int _internal_dict_keys_size() const;
276   public:
277   void clear_dict_keys();
278   const std::string& dict_keys(int index) const;
279   std::string* mutable_dict_keys(int index);
280   void set_dict_keys(int index, const std::string& value);
281   void set_dict_keys(int index, std::string&& value);
282   void set_dict_keys(int index, const char* value);
283   void set_dict_keys(int index, const char* value, size_t size);
284   std::string* add_dict_keys();
285   void add_dict_keys(const std::string& value);
286   void add_dict_keys(std::string&& value);
287   void add_dict_keys(const char* value);
288   void add_dict_keys(const char* value, size_t size);
289   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dict_keys() const;
290   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dict_keys();
291   private:
292   const std::string& _internal_dict_keys(int index) const;
293   std::string* _internal_add_dict_keys();
294   public:
295 
296   // repeated .perfetto.protos.ChromeTracedValue dict_values = 3;
297   int dict_values_size() const;
298   private:
299   int _internal_dict_values_size() const;
300   public:
301   void clear_dict_values();
302   ::perfetto::protos::ChromeTracedValue* mutable_dict_values(int index);
303   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >*
304       mutable_dict_values();
305   private:
306   const ::perfetto::protos::ChromeTracedValue& _internal_dict_values(int index) const;
307   ::perfetto::protos::ChromeTracedValue* _internal_add_dict_values();
308   public:
309   const ::perfetto::protos::ChromeTracedValue& dict_values(int index) const;
310   ::perfetto::protos::ChromeTracedValue* add_dict_values();
311   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >&
312       dict_values() const;
313 
314   // repeated .perfetto.protos.ChromeTracedValue array_values = 4;
315   int array_values_size() const;
316   private:
317   int _internal_array_values_size() const;
318   public:
319   void clear_array_values();
320   ::perfetto::protos::ChromeTracedValue* mutable_array_values(int index);
321   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >*
322       mutable_array_values();
323   private:
324   const ::perfetto::protos::ChromeTracedValue& _internal_array_values(int index) const;
325   ::perfetto::protos::ChromeTracedValue* _internal_add_array_values();
326   public:
327   const ::perfetto::protos::ChromeTracedValue& array_values(int index) const;
328   ::perfetto::protos::ChromeTracedValue* add_array_values();
329   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >&
330       array_values() const;
331 
332   // optional string string_value = 8;
333   bool has_string_value() const;
334   private:
335   bool _internal_has_string_value() const;
336   public:
337   void clear_string_value();
338   const std::string& string_value() const;
339   template <typename ArgT0 = const std::string&, typename... ArgT>
340   void set_string_value(ArgT0&& arg0, ArgT... args);
341   std::string* mutable_string_value();
342   PROTOBUF_NODISCARD std::string* release_string_value();
343   void set_allocated_string_value(std::string* string_value);
344   private:
345   const std::string& _internal_string_value() const;
346   inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
347   std::string* _internal_mutable_string_value();
348   public:
349 
350   // optional .perfetto.protos.ChromeTracedValue.NestedType nested_type = 1;
351   bool has_nested_type() const;
352   private:
353   bool _internal_has_nested_type() const;
354   public:
355   void clear_nested_type();
356   ::perfetto::protos::ChromeTracedValue_NestedType nested_type() const;
357   void set_nested_type(::perfetto::protos::ChromeTracedValue_NestedType value);
358   private:
359   ::perfetto::protos::ChromeTracedValue_NestedType _internal_nested_type() const;
360   void _internal_set_nested_type(::perfetto::protos::ChromeTracedValue_NestedType value);
361   public:
362 
363   // optional int32 int_value = 5;
364   bool has_int_value() const;
365   private:
366   bool _internal_has_int_value() const;
367   public:
368   void clear_int_value();
369   ::int32_t int_value() const;
370   void set_int_value(::int32_t value);
371   private:
372   ::int32_t _internal_int_value() const;
373   void _internal_set_int_value(::int32_t value);
374   public:
375 
376   // optional double double_value = 6;
377   bool has_double_value() const;
378   private:
379   bool _internal_has_double_value() const;
380   public:
381   void clear_double_value();
382   double double_value() const;
383   void set_double_value(double value);
384   private:
385   double _internal_double_value() const;
386   void _internal_set_double_value(double value);
387   public:
388 
389   // optional bool bool_value = 7;
390   bool has_bool_value() const;
391   private:
392   bool _internal_has_bool_value() const;
393   public:
394   void clear_bool_value();
395   bool bool_value() const;
396   void set_bool_value(bool value);
397   private:
398   bool _internal_bool_value() const;
399   void _internal_set_bool_value(bool value);
400   public:
401 
402   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeTracedValue)
403  private:
404   class _Internal;
405 
406   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
407   typedef void InternalArenaConstructable_;
408   typedef void DestructorSkippable_;
409   struct Impl_ {
410     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
411     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
412     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dict_keys_;
413     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue > dict_values_;
414     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue > array_values_;
415     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
416     int nested_type_;
417     ::int32_t int_value_;
418     double double_value_;
419     bool bool_value_;
420   };
421   union { Impl_ _impl_; };
422   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
423 };
424 // -------------------------------------------------------------------
425 
426 class ChromeStringTableEntry final :
427     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeStringTableEntry) */ {
428  public:
ChromeStringTableEntry()429   inline ChromeStringTableEntry() : ChromeStringTableEntry(nullptr) {}
430   ~ChromeStringTableEntry() override;
431   explicit PROTOBUF_CONSTEXPR ChromeStringTableEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
432 
433   ChromeStringTableEntry(const ChromeStringTableEntry& from);
ChromeStringTableEntry(ChromeStringTableEntry && from)434   ChromeStringTableEntry(ChromeStringTableEntry&& from) noexcept
435     : ChromeStringTableEntry() {
436     *this = ::std::move(from);
437   }
438 
439   inline ChromeStringTableEntry& operator=(const ChromeStringTableEntry& from) {
440     if (this == &from) return *this;
441     CopyFrom(from);
442     return *this;
443   }
444   inline ChromeStringTableEntry& operator=(ChromeStringTableEntry&& from) noexcept {
445     if (this == &from) return *this;
446     if (GetOwningArena() == from.GetOwningArena()
447   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
448         && GetOwningArena() != nullptr
449   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
450     ) {
451       InternalSwap(&from);
452     } else {
453       CopyFrom(from);
454     }
455     return *this;
456   }
457 
unknown_fields()458   inline const std::string& unknown_fields() const {
459     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
460   }
mutable_unknown_fields()461   inline std::string* mutable_unknown_fields() {
462     return _internal_metadata_.mutable_unknown_fields<std::string>();
463   }
464 
default_instance()465   static const ChromeStringTableEntry& default_instance() {
466     return *internal_default_instance();
467   }
internal_default_instance()468   static inline const ChromeStringTableEntry* internal_default_instance() {
469     return reinterpret_cast<const ChromeStringTableEntry*>(
470                &_ChromeStringTableEntry_default_instance_);
471   }
472   static constexpr int kIndexInFileMessages =
473     1;
474 
swap(ChromeStringTableEntry & a,ChromeStringTableEntry & b)475   friend void swap(ChromeStringTableEntry& a, ChromeStringTableEntry& b) {
476     a.Swap(&b);
477   }
Swap(ChromeStringTableEntry * other)478   inline void Swap(ChromeStringTableEntry* other) {
479     if (other == this) return;
480   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
481     if (GetOwningArena() != nullptr &&
482         GetOwningArena() == other->GetOwningArena()) {
483    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
484     if (GetOwningArena() == other->GetOwningArena()) {
485   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
486       InternalSwap(other);
487     } else {
488       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
489     }
490   }
491   void UnsafeArenaSwap(ChromeStringTableEntry* other) {
492     if (other == this) return;
493     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
494     InternalSwap(other);
495   }
496 
497   // implements Message ----------------------------------------------
498 
499   ChromeStringTableEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
500     return CreateMaybeMessage<ChromeStringTableEntry>(arena);
501   }
502   ChromeStringTableEntry* New() const {
503     return New(nullptr);
504   }
505   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
506   void CopyFrom(const ChromeStringTableEntry& from);
507   void MergeFrom(const ChromeStringTableEntry& from);
508   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
509   bool IsInitialized() const final;
510 
511   size_t ByteSizeLong() const final;
512   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
513   ::uint8_t* _InternalSerialize(
514       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
515   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
516 
517   private:
518   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
519   void SharedDtor();
520   void SetCachedSize(int size) const;
521   void InternalSwap(ChromeStringTableEntry* other);
522 
523   private:
524   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
525   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
526     return "perfetto.protos.ChromeStringTableEntry";
527   }
528   protected:
529   explicit ChromeStringTableEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
530                        bool is_message_owned = false);
531   public:
532 
533   std::string GetTypeName() const final;
534 
535   // nested types ----------------------------------------------------
536 
537   // accessors -------------------------------------------------------
538 
539   enum : int {
540     kValueFieldNumber = 1,
541     kIndexFieldNumber = 2,
542   };
543   // optional string value = 1;
544   bool has_value() const;
545   private:
546   bool _internal_has_value() const;
547   public:
548   void clear_value();
549   const std::string& value() const;
550   template <typename ArgT0 = const std::string&, typename... ArgT>
551   void set_value(ArgT0&& arg0, ArgT... args);
552   std::string* mutable_value();
553   PROTOBUF_NODISCARD std::string* release_value();
554   void set_allocated_value(std::string* value);
555   private:
556   const std::string& _internal_value() const;
557   inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
558   std::string* _internal_mutable_value();
559   public:
560 
561   // optional int32 index = 2;
562   bool has_index() const;
563   private:
564   bool _internal_has_index() const;
565   public:
566   void clear_index();
567   ::int32_t index() const;
568   void set_index(::int32_t value);
569   private:
570   ::int32_t _internal_index() const;
571   void _internal_set_index(::int32_t value);
572   public:
573 
574   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeStringTableEntry)
575  private:
576   class _Internal;
577 
578   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
579   typedef void InternalArenaConstructable_;
580   typedef void DestructorSkippable_;
581   struct Impl_ {
582     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
583     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
584     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
585     ::int32_t index_;
586   };
587   union { Impl_ _impl_; };
588   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
589 };
590 // -------------------------------------------------------------------
591 
592 class ChromeTraceEvent_Arg final :
593     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeTraceEvent.Arg) */ {
594  public:
ChromeTraceEvent_Arg()595   inline ChromeTraceEvent_Arg() : ChromeTraceEvent_Arg(nullptr) {}
596   ~ChromeTraceEvent_Arg() override;
597   explicit PROTOBUF_CONSTEXPR ChromeTraceEvent_Arg(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
598 
599   ChromeTraceEvent_Arg(const ChromeTraceEvent_Arg& from);
ChromeTraceEvent_Arg(ChromeTraceEvent_Arg && from)600   ChromeTraceEvent_Arg(ChromeTraceEvent_Arg&& from) noexcept
601     : ChromeTraceEvent_Arg() {
602     *this = ::std::move(from);
603   }
604 
605   inline ChromeTraceEvent_Arg& operator=(const ChromeTraceEvent_Arg& from) {
606     if (this == &from) return *this;
607     CopyFrom(from);
608     return *this;
609   }
610   inline ChromeTraceEvent_Arg& operator=(ChromeTraceEvent_Arg&& from) noexcept {
611     if (this == &from) return *this;
612     if (GetOwningArena() == from.GetOwningArena()
613   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
614         && GetOwningArena() != nullptr
615   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
616     ) {
617       InternalSwap(&from);
618     } else {
619       CopyFrom(from);
620     }
621     return *this;
622   }
623 
unknown_fields()624   inline const std::string& unknown_fields() const {
625     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
626   }
mutable_unknown_fields()627   inline std::string* mutable_unknown_fields() {
628     return _internal_metadata_.mutable_unknown_fields<std::string>();
629   }
630 
default_instance()631   static const ChromeTraceEvent_Arg& default_instance() {
632     return *internal_default_instance();
633   }
634   enum ValueCase {
635     kBoolValue = 2,
636     kUintValue = 3,
637     kIntValue = 4,
638     kDoubleValue = 5,
639     kStringValue = 6,
640     kPointerValue = 7,
641     kJsonValue = 8,
642     kTracedValue = 10,
643     VALUE_NOT_SET = 0,
644   };
645 
internal_default_instance()646   static inline const ChromeTraceEvent_Arg* internal_default_instance() {
647     return reinterpret_cast<const ChromeTraceEvent_Arg*>(
648                &_ChromeTraceEvent_Arg_default_instance_);
649   }
650   static constexpr int kIndexInFileMessages =
651     2;
652 
swap(ChromeTraceEvent_Arg & a,ChromeTraceEvent_Arg & b)653   friend void swap(ChromeTraceEvent_Arg& a, ChromeTraceEvent_Arg& b) {
654     a.Swap(&b);
655   }
Swap(ChromeTraceEvent_Arg * other)656   inline void Swap(ChromeTraceEvent_Arg* other) {
657     if (other == this) return;
658   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
659     if (GetOwningArena() != nullptr &&
660         GetOwningArena() == other->GetOwningArena()) {
661    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
662     if (GetOwningArena() == other->GetOwningArena()) {
663   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
664       InternalSwap(other);
665     } else {
666       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
667     }
668   }
669   void UnsafeArenaSwap(ChromeTraceEvent_Arg* other) {
670     if (other == this) return;
671     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
672     InternalSwap(other);
673   }
674 
675   // implements Message ----------------------------------------------
676 
677   ChromeTraceEvent_Arg* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
678     return CreateMaybeMessage<ChromeTraceEvent_Arg>(arena);
679   }
680   ChromeTraceEvent_Arg* New() const {
681     return New(nullptr);
682   }
683   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
684   void CopyFrom(const ChromeTraceEvent_Arg& from);
685   void MergeFrom(const ChromeTraceEvent_Arg& from);
686   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
687   bool IsInitialized() const final;
688 
689   size_t ByteSizeLong() const final;
690   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
691   ::uint8_t* _InternalSerialize(
692       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
693   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
694 
695   private:
696   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
697   void SharedDtor();
698   void SetCachedSize(int size) const;
699   void InternalSwap(ChromeTraceEvent_Arg* other);
700 
701   private:
702   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
703   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
704     return "perfetto.protos.ChromeTraceEvent.Arg";
705   }
706   protected:
707   explicit ChromeTraceEvent_Arg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
708                        bool is_message_owned = false);
709   public:
710 
711   std::string GetTypeName() const final;
712 
713   // nested types ----------------------------------------------------
714 
715   // accessors -------------------------------------------------------
716 
717   enum : int {
718     kNameFieldNumber = 1,
719     kNameIndexFieldNumber = 9,
720     kBoolValueFieldNumber = 2,
721     kUintValueFieldNumber = 3,
722     kIntValueFieldNumber = 4,
723     kDoubleValueFieldNumber = 5,
724     kStringValueFieldNumber = 6,
725     kPointerValueFieldNumber = 7,
726     kJsonValueFieldNumber = 8,
727     kTracedValueFieldNumber = 10,
728   };
729   // optional string name = 1;
730   bool has_name() const;
731   private:
732   bool _internal_has_name() const;
733   public:
734   void clear_name();
735   const std::string& name() const;
736   template <typename ArgT0 = const std::string&, typename... ArgT>
737   void set_name(ArgT0&& arg0, ArgT... args);
738   std::string* mutable_name();
739   PROTOBUF_NODISCARD std::string* release_name();
740   void set_allocated_name(std::string* name);
741   private:
742   const std::string& _internal_name() const;
743   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
744   std::string* _internal_mutable_name();
745   public:
746 
747   // optional uint32 name_index = 9;
748   bool has_name_index() const;
749   private:
750   bool _internal_has_name_index() const;
751   public:
752   void clear_name_index();
753   ::uint32_t name_index() const;
754   void set_name_index(::uint32_t value);
755   private:
756   ::uint32_t _internal_name_index() const;
757   void _internal_set_name_index(::uint32_t value);
758   public:
759 
760   // bool bool_value = 2;
761   bool has_bool_value() const;
762   private:
763   bool _internal_has_bool_value() const;
764   public:
765   void clear_bool_value();
766   bool bool_value() const;
767   void set_bool_value(bool value);
768   private:
769   bool _internal_bool_value() const;
770   void _internal_set_bool_value(bool value);
771   public:
772 
773   // uint64 uint_value = 3;
774   bool has_uint_value() const;
775   private:
776   bool _internal_has_uint_value() const;
777   public:
778   void clear_uint_value();
779   ::uint64_t uint_value() const;
780   void set_uint_value(::uint64_t value);
781   private:
782   ::uint64_t _internal_uint_value() const;
783   void _internal_set_uint_value(::uint64_t value);
784   public:
785 
786   // int64 int_value = 4;
787   bool has_int_value() const;
788   private:
789   bool _internal_has_int_value() const;
790   public:
791   void clear_int_value();
792   ::int64_t int_value() const;
793   void set_int_value(::int64_t value);
794   private:
795   ::int64_t _internal_int_value() const;
796   void _internal_set_int_value(::int64_t value);
797   public:
798 
799   // double double_value = 5;
800   bool has_double_value() const;
801   private:
802   bool _internal_has_double_value() const;
803   public:
804   void clear_double_value();
805   double double_value() const;
806   void set_double_value(double value);
807   private:
808   double _internal_double_value() const;
809   void _internal_set_double_value(double value);
810   public:
811 
812   // string string_value = 6;
813   bool has_string_value() const;
814   private:
815   bool _internal_has_string_value() const;
816   public:
817   void clear_string_value();
818   const std::string& string_value() const;
819   template <typename ArgT0 = const std::string&, typename... ArgT>
820   void set_string_value(ArgT0&& arg0, ArgT... args);
821   std::string* mutable_string_value();
822   PROTOBUF_NODISCARD std::string* release_string_value();
823   void set_allocated_string_value(std::string* string_value);
824   private:
825   const std::string& _internal_string_value() const;
826   inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
827   std::string* _internal_mutable_string_value();
828   public:
829 
830   // uint64 pointer_value = 7;
831   bool has_pointer_value() const;
832   private:
833   bool _internal_has_pointer_value() const;
834   public:
835   void clear_pointer_value();
836   ::uint64_t pointer_value() const;
837   void set_pointer_value(::uint64_t value);
838   private:
839   ::uint64_t _internal_pointer_value() const;
840   void _internal_set_pointer_value(::uint64_t value);
841   public:
842 
843   // string json_value = 8;
844   bool has_json_value() const;
845   private:
846   bool _internal_has_json_value() const;
847   public:
848   void clear_json_value();
849   const std::string& json_value() const;
850   template <typename ArgT0 = const std::string&, typename... ArgT>
851   void set_json_value(ArgT0&& arg0, ArgT... args);
852   std::string* mutable_json_value();
853   PROTOBUF_NODISCARD std::string* release_json_value();
854   void set_allocated_json_value(std::string* json_value);
855   private:
856   const std::string& _internal_json_value() const;
857   inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_value(const std::string& value);
858   std::string* _internal_mutable_json_value();
859   public:
860 
861   // .perfetto.protos.ChromeTracedValue traced_value = 10;
862   bool has_traced_value() const;
863   private:
864   bool _internal_has_traced_value() const;
865   public:
866   void clear_traced_value();
867   const ::perfetto::protos::ChromeTracedValue& traced_value() const;
868   PROTOBUF_NODISCARD ::perfetto::protos::ChromeTracedValue* release_traced_value();
869   ::perfetto::protos::ChromeTracedValue* mutable_traced_value();
870   void set_allocated_traced_value(::perfetto::protos::ChromeTracedValue* traced_value);
871   private:
872   const ::perfetto::protos::ChromeTracedValue& _internal_traced_value() const;
873   ::perfetto::protos::ChromeTracedValue* _internal_mutable_traced_value();
874   public:
875   void unsafe_arena_set_allocated_traced_value(
876       ::perfetto::protos::ChromeTracedValue* traced_value);
877   ::perfetto::protos::ChromeTracedValue* unsafe_arena_release_traced_value();
878 
879   void clear_value();
880   ValueCase value_case() const;
881   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeTraceEvent.Arg)
882  private:
883   class _Internal;
884   void set_has_bool_value();
885   void set_has_uint_value();
886   void set_has_int_value();
887   void set_has_double_value();
888   void set_has_string_value();
889   void set_has_pointer_value();
890   void set_has_json_value();
891   void set_has_traced_value();
892 
893   inline bool has_value() const;
894   inline void clear_has_value();
895 
896   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
897   typedef void InternalArenaConstructable_;
898   typedef void DestructorSkippable_;
899   struct Impl_ {
900     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
901     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
902     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
903     ::uint32_t name_index_;
904     union ValueUnion {
905       constexpr ValueUnion() : _constinit_{} {}
906         ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
907       bool bool_value_;
908       ::uint64_t uint_value_;
909       ::int64_t int_value_;
910       double double_value_;
911       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
912       ::uint64_t pointer_value_;
913       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_value_;
914       ::perfetto::protos::ChromeTracedValue* traced_value_;
915     } value_;
916     ::uint32_t _oneof_case_[1];
917 
918   };
919   union { Impl_ _impl_; };
920   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
921 };
922 // -------------------------------------------------------------------
923 
924 class ChromeTraceEvent final :
925     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeTraceEvent) */ {
926  public:
ChromeTraceEvent()927   inline ChromeTraceEvent() : ChromeTraceEvent(nullptr) {}
928   ~ChromeTraceEvent() override;
929   explicit PROTOBUF_CONSTEXPR ChromeTraceEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
930 
931   ChromeTraceEvent(const ChromeTraceEvent& from);
ChromeTraceEvent(ChromeTraceEvent && from)932   ChromeTraceEvent(ChromeTraceEvent&& from) noexcept
933     : ChromeTraceEvent() {
934     *this = ::std::move(from);
935   }
936 
937   inline ChromeTraceEvent& operator=(const ChromeTraceEvent& from) {
938     if (this == &from) return *this;
939     CopyFrom(from);
940     return *this;
941   }
942   inline ChromeTraceEvent& operator=(ChromeTraceEvent&& from) noexcept {
943     if (this == &from) return *this;
944     if (GetOwningArena() == from.GetOwningArena()
945   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
946         && GetOwningArena() != nullptr
947   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
948     ) {
949       InternalSwap(&from);
950     } else {
951       CopyFrom(from);
952     }
953     return *this;
954   }
955 
unknown_fields()956   inline const std::string& unknown_fields() const {
957     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
958   }
mutable_unknown_fields()959   inline std::string* mutable_unknown_fields() {
960     return _internal_metadata_.mutable_unknown_fields<std::string>();
961   }
962 
default_instance()963   static const ChromeTraceEvent& default_instance() {
964     return *internal_default_instance();
965   }
internal_default_instance()966   static inline const ChromeTraceEvent* internal_default_instance() {
967     return reinterpret_cast<const ChromeTraceEvent*>(
968                &_ChromeTraceEvent_default_instance_);
969   }
970   static constexpr int kIndexInFileMessages =
971     3;
972 
swap(ChromeTraceEvent & a,ChromeTraceEvent & b)973   friend void swap(ChromeTraceEvent& a, ChromeTraceEvent& b) {
974     a.Swap(&b);
975   }
Swap(ChromeTraceEvent * other)976   inline void Swap(ChromeTraceEvent* other) {
977     if (other == this) return;
978   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
979     if (GetOwningArena() != nullptr &&
980         GetOwningArena() == other->GetOwningArena()) {
981    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
982     if (GetOwningArena() == other->GetOwningArena()) {
983   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
984       InternalSwap(other);
985     } else {
986       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
987     }
988   }
989   void UnsafeArenaSwap(ChromeTraceEvent* other) {
990     if (other == this) return;
991     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
992     InternalSwap(other);
993   }
994 
995   // implements Message ----------------------------------------------
996 
997   ChromeTraceEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
998     return CreateMaybeMessage<ChromeTraceEvent>(arena);
999   }
1000   ChromeTraceEvent* New() const {
1001     return New(nullptr);
1002   }
1003   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1004   void CopyFrom(const ChromeTraceEvent& from);
1005   void MergeFrom(const ChromeTraceEvent& from);
1006   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1007   bool IsInitialized() const final;
1008 
1009   size_t ByteSizeLong() const final;
1010   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1011   ::uint8_t* _InternalSerialize(
1012       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1013   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1014 
1015   private:
1016   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1017   void SharedDtor();
1018   void SetCachedSize(int size) const;
1019   void InternalSwap(ChromeTraceEvent* other);
1020 
1021   private:
1022   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1023   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1024     return "perfetto.protos.ChromeTraceEvent";
1025   }
1026   protected:
1027   explicit ChromeTraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1028                        bool is_message_owned = false);
1029   public:
1030 
1031   std::string GetTypeName() const final;
1032 
1033   // nested types ----------------------------------------------------
1034 
1035   typedef ChromeTraceEvent_Arg Arg;
1036 
1037   // accessors -------------------------------------------------------
1038 
1039   enum : int {
1040     kArgsFieldNumber = 14,
1041     kNameFieldNumber = 1,
1042     kScopeFieldNumber = 7,
1043     kCategoryGroupNameFieldNumber = 10,
1044     kTimestampFieldNumber = 2,
1045     kPhaseFieldNumber = 3,
1046     kThreadIdFieldNumber = 4,
1047     kDurationFieldNumber = 5,
1048     kThreadDurationFieldNumber = 6,
1049     kIdFieldNumber = 8,
1050     kFlagsFieldNumber = 9,
1051     kProcessIdFieldNumber = 11,
1052     kThreadTimestampFieldNumber = 12,
1053     kBindIdFieldNumber = 13,
1054     kNameIndexFieldNumber = 15,
1055     kCategoryGroupNameIndexFieldNumber = 16,
1056   };
1057   // repeated .perfetto.protos.ChromeTraceEvent.Arg args = 14;
1058   int args_size() const;
1059   private:
1060   int _internal_args_size() const;
1061   public:
1062   void clear_args();
1063   ::perfetto::protos::ChromeTraceEvent_Arg* mutable_args(int index);
1064   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent_Arg >*
1065       mutable_args();
1066   private:
1067   const ::perfetto::protos::ChromeTraceEvent_Arg& _internal_args(int index) const;
1068   ::perfetto::protos::ChromeTraceEvent_Arg* _internal_add_args();
1069   public:
1070   const ::perfetto::protos::ChromeTraceEvent_Arg& args(int index) const;
1071   ::perfetto::protos::ChromeTraceEvent_Arg* add_args();
1072   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent_Arg >&
1073       args() const;
1074 
1075   // optional string name = 1;
1076   bool has_name() const;
1077   private:
1078   bool _internal_has_name() const;
1079   public:
1080   void clear_name();
1081   const std::string& name() const;
1082   template <typename ArgT0 = const std::string&, typename... ArgT>
1083   void set_name(ArgT0&& arg0, ArgT... args);
1084   std::string* mutable_name();
1085   PROTOBUF_NODISCARD std::string* release_name();
1086   void set_allocated_name(std::string* name);
1087   private:
1088   const std::string& _internal_name() const;
1089   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1090   std::string* _internal_mutable_name();
1091   public:
1092 
1093   // optional string scope = 7;
1094   bool has_scope() const;
1095   private:
1096   bool _internal_has_scope() const;
1097   public:
1098   void clear_scope();
1099   const std::string& scope() const;
1100   template <typename ArgT0 = const std::string&, typename... ArgT>
1101   void set_scope(ArgT0&& arg0, ArgT... args);
1102   std::string* mutable_scope();
1103   PROTOBUF_NODISCARD std::string* release_scope();
1104   void set_allocated_scope(std::string* scope);
1105   private:
1106   const std::string& _internal_scope() const;
1107   inline PROTOBUF_ALWAYS_INLINE void _internal_set_scope(const std::string& value);
1108   std::string* _internal_mutable_scope();
1109   public:
1110 
1111   // optional string category_group_name = 10;
1112   bool has_category_group_name() const;
1113   private:
1114   bool _internal_has_category_group_name() const;
1115   public:
1116   void clear_category_group_name();
1117   const std::string& category_group_name() const;
1118   template <typename ArgT0 = const std::string&, typename... ArgT>
1119   void set_category_group_name(ArgT0&& arg0, ArgT... args);
1120   std::string* mutable_category_group_name();
1121   PROTOBUF_NODISCARD std::string* release_category_group_name();
1122   void set_allocated_category_group_name(std::string* category_group_name);
1123   private:
1124   const std::string& _internal_category_group_name() const;
1125   inline PROTOBUF_ALWAYS_INLINE void _internal_set_category_group_name(const std::string& value);
1126   std::string* _internal_mutable_category_group_name();
1127   public:
1128 
1129   // optional int64 timestamp = 2;
1130   bool has_timestamp() const;
1131   private:
1132   bool _internal_has_timestamp() const;
1133   public:
1134   void clear_timestamp();
1135   ::int64_t timestamp() const;
1136   void set_timestamp(::int64_t value);
1137   private:
1138   ::int64_t _internal_timestamp() const;
1139   void _internal_set_timestamp(::int64_t value);
1140   public:
1141 
1142   // optional int32 phase = 3;
1143   bool has_phase() const;
1144   private:
1145   bool _internal_has_phase() const;
1146   public:
1147   void clear_phase();
1148   ::int32_t phase() const;
1149   void set_phase(::int32_t value);
1150   private:
1151   ::int32_t _internal_phase() const;
1152   void _internal_set_phase(::int32_t value);
1153   public:
1154 
1155   // optional int32 thread_id = 4;
1156   bool has_thread_id() const;
1157   private:
1158   bool _internal_has_thread_id() const;
1159   public:
1160   void clear_thread_id();
1161   ::int32_t thread_id() const;
1162   void set_thread_id(::int32_t value);
1163   private:
1164   ::int32_t _internal_thread_id() const;
1165   void _internal_set_thread_id(::int32_t value);
1166   public:
1167 
1168   // optional int64 duration = 5;
1169   bool has_duration() const;
1170   private:
1171   bool _internal_has_duration() const;
1172   public:
1173   void clear_duration();
1174   ::int64_t duration() const;
1175   void set_duration(::int64_t value);
1176   private:
1177   ::int64_t _internal_duration() const;
1178   void _internal_set_duration(::int64_t value);
1179   public:
1180 
1181   // optional int64 thread_duration = 6;
1182   bool has_thread_duration() const;
1183   private:
1184   bool _internal_has_thread_duration() const;
1185   public:
1186   void clear_thread_duration();
1187   ::int64_t thread_duration() const;
1188   void set_thread_duration(::int64_t value);
1189   private:
1190   ::int64_t _internal_thread_duration() const;
1191   void _internal_set_thread_duration(::int64_t value);
1192   public:
1193 
1194   // optional uint64 id = 8;
1195   bool has_id() const;
1196   private:
1197   bool _internal_has_id() const;
1198   public:
1199   void clear_id();
1200   ::uint64_t id() const;
1201   void set_id(::uint64_t value);
1202   private:
1203   ::uint64_t _internal_id() const;
1204   void _internal_set_id(::uint64_t value);
1205   public:
1206 
1207   // optional uint32 flags = 9;
1208   bool has_flags() const;
1209   private:
1210   bool _internal_has_flags() const;
1211   public:
1212   void clear_flags();
1213   ::uint32_t flags() const;
1214   void set_flags(::uint32_t value);
1215   private:
1216   ::uint32_t _internal_flags() const;
1217   void _internal_set_flags(::uint32_t value);
1218   public:
1219 
1220   // optional int32 process_id = 11;
1221   bool has_process_id() const;
1222   private:
1223   bool _internal_has_process_id() const;
1224   public:
1225   void clear_process_id();
1226   ::int32_t process_id() const;
1227   void set_process_id(::int32_t value);
1228   private:
1229   ::int32_t _internal_process_id() const;
1230   void _internal_set_process_id(::int32_t value);
1231   public:
1232 
1233   // optional int64 thread_timestamp = 12;
1234   bool has_thread_timestamp() const;
1235   private:
1236   bool _internal_has_thread_timestamp() const;
1237   public:
1238   void clear_thread_timestamp();
1239   ::int64_t thread_timestamp() const;
1240   void set_thread_timestamp(::int64_t value);
1241   private:
1242   ::int64_t _internal_thread_timestamp() const;
1243   void _internal_set_thread_timestamp(::int64_t value);
1244   public:
1245 
1246   // optional uint64 bind_id = 13;
1247   bool has_bind_id() const;
1248   private:
1249   bool _internal_has_bind_id() const;
1250   public:
1251   void clear_bind_id();
1252   ::uint64_t bind_id() const;
1253   void set_bind_id(::uint64_t value);
1254   private:
1255   ::uint64_t _internal_bind_id() const;
1256   void _internal_set_bind_id(::uint64_t value);
1257   public:
1258 
1259   // optional uint32 name_index = 15;
1260   bool has_name_index() const;
1261   private:
1262   bool _internal_has_name_index() const;
1263   public:
1264   void clear_name_index();
1265   ::uint32_t name_index() const;
1266   void set_name_index(::uint32_t value);
1267   private:
1268   ::uint32_t _internal_name_index() const;
1269   void _internal_set_name_index(::uint32_t value);
1270   public:
1271 
1272   // optional uint32 category_group_name_index = 16;
1273   bool has_category_group_name_index() const;
1274   private:
1275   bool _internal_has_category_group_name_index() const;
1276   public:
1277   void clear_category_group_name_index();
1278   ::uint32_t category_group_name_index() const;
1279   void set_category_group_name_index(::uint32_t value);
1280   private:
1281   ::uint32_t _internal_category_group_name_index() const;
1282   void _internal_set_category_group_name_index(::uint32_t value);
1283   public:
1284 
1285   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeTraceEvent)
1286  private:
1287   class _Internal;
1288 
1289   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1290   typedef void InternalArenaConstructable_;
1291   typedef void DestructorSkippable_;
1292   struct Impl_ {
1293     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1294     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1295     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent_Arg > args_;
1296     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1297     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr scope_;
1298     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr category_group_name_;
1299     ::int64_t timestamp_;
1300     ::int32_t phase_;
1301     ::int32_t thread_id_;
1302     ::int64_t duration_;
1303     ::int64_t thread_duration_;
1304     ::uint64_t id_;
1305     ::uint32_t flags_;
1306     ::int32_t process_id_;
1307     ::int64_t thread_timestamp_;
1308     ::uint64_t bind_id_;
1309     ::uint32_t name_index_;
1310     ::uint32_t category_group_name_index_;
1311   };
1312   union { Impl_ _impl_; };
1313   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
1314 };
1315 // -------------------------------------------------------------------
1316 
1317 class ChromeMetadata final :
1318     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeMetadata) */ {
1319  public:
ChromeMetadata()1320   inline ChromeMetadata() : ChromeMetadata(nullptr) {}
1321   ~ChromeMetadata() override;
1322   explicit PROTOBUF_CONSTEXPR ChromeMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1323 
1324   ChromeMetadata(const ChromeMetadata& from);
ChromeMetadata(ChromeMetadata && from)1325   ChromeMetadata(ChromeMetadata&& from) noexcept
1326     : ChromeMetadata() {
1327     *this = ::std::move(from);
1328   }
1329 
1330   inline ChromeMetadata& operator=(const ChromeMetadata& from) {
1331     if (this == &from) return *this;
1332     CopyFrom(from);
1333     return *this;
1334   }
1335   inline ChromeMetadata& operator=(ChromeMetadata&& from) noexcept {
1336     if (this == &from) return *this;
1337     if (GetOwningArena() == from.GetOwningArena()
1338   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1339         && GetOwningArena() != nullptr
1340   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1341     ) {
1342       InternalSwap(&from);
1343     } else {
1344       CopyFrom(from);
1345     }
1346     return *this;
1347   }
1348 
unknown_fields()1349   inline const std::string& unknown_fields() const {
1350     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1351   }
mutable_unknown_fields()1352   inline std::string* mutable_unknown_fields() {
1353     return _internal_metadata_.mutable_unknown_fields<std::string>();
1354   }
1355 
default_instance()1356   static const ChromeMetadata& default_instance() {
1357     return *internal_default_instance();
1358   }
1359   enum ValueCase {
1360     kStringValue = 2,
1361     kBoolValue = 3,
1362     kIntValue = 4,
1363     kJsonValue = 5,
1364     VALUE_NOT_SET = 0,
1365   };
1366 
internal_default_instance()1367   static inline const ChromeMetadata* internal_default_instance() {
1368     return reinterpret_cast<const ChromeMetadata*>(
1369                &_ChromeMetadata_default_instance_);
1370   }
1371   static constexpr int kIndexInFileMessages =
1372     4;
1373 
swap(ChromeMetadata & a,ChromeMetadata & b)1374   friend void swap(ChromeMetadata& a, ChromeMetadata& b) {
1375     a.Swap(&b);
1376   }
Swap(ChromeMetadata * other)1377   inline void Swap(ChromeMetadata* other) {
1378     if (other == this) return;
1379   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1380     if (GetOwningArena() != nullptr &&
1381         GetOwningArena() == other->GetOwningArena()) {
1382    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1383     if (GetOwningArena() == other->GetOwningArena()) {
1384   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1385       InternalSwap(other);
1386     } else {
1387       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1388     }
1389   }
1390   void UnsafeArenaSwap(ChromeMetadata* other) {
1391     if (other == this) return;
1392     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1393     InternalSwap(other);
1394   }
1395 
1396   // implements Message ----------------------------------------------
1397 
1398   ChromeMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1399     return CreateMaybeMessage<ChromeMetadata>(arena);
1400   }
1401   ChromeMetadata* New() const {
1402     return New(nullptr);
1403   }
1404   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1405   void CopyFrom(const ChromeMetadata& from);
1406   void MergeFrom(const ChromeMetadata& from);
1407   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1408   bool IsInitialized() const final;
1409 
1410   size_t ByteSizeLong() const final;
1411   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1412   ::uint8_t* _InternalSerialize(
1413       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1414   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1415 
1416   private:
1417   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1418   void SharedDtor();
1419   void SetCachedSize(int size) const;
1420   void InternalSwap(ChromeMetadata* other);
1421 
1422   private:
1423   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1424   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1425     return "perfetto.protos.ChromeMetadata";
1426   }
1427   protected:
1428   explicit ChromeMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1429                        bool is_message_owned = false);
1430   public:
1431 
1432   std::string GetTypeName() const final;
1433 
1434   // nested types ----------------------------------------------------
1435 
1436   // accessors -------------------------------------------------------
1437 
1438   enum : int {
1439     kNameFieldNumber = 1,
1440     kStringValueFieldNumber = 2,
1441     kBoolValueFieldNumber = 3,
1442     kIntValueFieldNumber = 4,
1443     kJsonValueFieldNumber = 5,
1444   };
1445   // optional string name = 1;
1446   bool has_name() const;
1447   private:
1448   bool _internal_has_name() const;
1449   public:
1450   void clear_name();
1451   const std::string& name() const;
1452   template <typename ArgT0 = const std::string&, typename... ArgT>
1453   void set_name(ArgT0&& arg0, ArgT... args);
1454   std::string* mutable_name();
1455   PROTOBUF_NODISCARD std::string* release_name();
1456   void set_allocated_name(std::string* name);
1457   private:
1458   const std::string& _internal_name() const;
1459   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
1460   std::string* _internal_mutable_name();
1461   public:
1462 
1463   // string string_value = 2;
1464   bool has_string_value() const;
1465   private:
1466   bool _internal_has_string_value() const;
1467   public:
1468   void clear_string_value();
1469   const std::string& string_value() const;
1470   template <typename ArgT0 = const std::string&, typename... ArgT>
1471   void set_string_value(ArgT0&& arg0, ArgT... args);
1472   std::string* mutable_string_value();
1473   PROTOBUF_NODISCARD std::string* release_string_value();
1474   void set_allocated_string_value(std::string* string_value);
1475   private:
1476   const std::string& _internal_string_value() const;
1477   inline PROTOBUF_ALWAYS_INLINE void _internal_set_string_value(const std::string& value);
1478   std::string* _internal_mutable_string_value();
1479   public:
1480 
1481   // bool bool_value = 3;
1482   bool has_bool_value() const;
1483   private:
1484   bool _internal_has_bool_value() const;
1485   public:
1486   void clear_bool_value();
1487   bool bool_value() const;
1488   void set_bool_value(bool value);
1489   private:
1490   bool _internal_bool_value() const;
1491   void _internal_set_bool_value(bool value);
1492   public:
1493 
1494   // int64 int_value = 4;
1495   bool has_int_value() const;
1496   private:
1497   bool _internal_has_int_value() const;
1498   public:
1499   void clear_int_value();
1500   ::int64_t int_value() const;
1501   void set_int_value(::int64_t value);
1502   private:
1503   ::int64_t _internal_int_value() const;
1504   void _internal_set_int_value(::int64_t value);
1505   public:
1506 
1507   // string json_value = 5;
1508   bool has_json_value() const;
1509   private:
1510   bool _internal_has_json_value() const;
1511   public:
1512   void clear_json_value();
1513   const std::string& json_value() const;
1514   template <typename ArgT0 = const std::string&, typename... ArgT>
1515   void set_json_value(ArgT0&& arg0, ArgT... args);
1516   std::string* mutable_json_value();
1517   PROTOBUF_NODISCARD std::string* release_json_value();
1518   void set_allocated_json_value(std::string* json_value);
1519   private:
1520   const std::string& _internal_json_value() const;
1521   inline PROTOBUF_ALWAYS_INLINE void _internal_set_json_value(const std::string& value);
1522   std::string* _internal_mutable_json_value();
1523   public:
1524 
1525   void clear_value();
1526   ValueCase value_case() const;
1527   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeMetadata)
1528  private:
1529   class _Internal;
1530   void set_has_string_value();
1531   void set_has_bool_value();
1532   void set_has_int_value();
1533   void set_has_json_value();
1534 
1535   inline bool has_value() const;
1536   inline void clear_has_value();
1537 
1538   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1539   typedef void InternalArenaConstructable_;
1540   typedef void DestructorSkippable_;
1541   struct Impl_ {
1542     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1543     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1544     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
1545     union ValueUnion {
1546       constexpr ValueUnion() : _constinit_{} {}
1547         ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
1548       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_value_;
1549       bool bool_value_;
1550       ::int64_t int_value_;
1551       ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr json_value_;
1552     } value_;
1553     ::uint32_t _oneof_case_[1];
1554 
1555   };
1556   union { Impl_ _impl_; };
1557   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
1558 };
1559 // -------------------------------------------------------------------
1560 
1561 class ChromeLegacyJsonTrace final :
1562     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeLegacyJsonTrace) */ {
1563  public:
ChromeLegacyJsonTrace()1564   inline ChromeLegacyJsonTrace() : ChromeLegacyJsonTrace(nullptr) {}
1565   ~ChromeLegacyJsonTrace() override;
1566   explicit PROTOBUF_CONSTEXPR ChromeLegacyJsonTrace(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1567 
1568   ChromeLegacyJsonTrace(const ChromeLegacyJsonTrace& from);
ChromeLegacyJsonTrace(ChromeLegacyJsonTrace && from)1569   ChromeLegacyJsonTrace(ChromeLegacyJsonTrace&& from) noexcept
1570     : ChromeLegacyJsonTrace() {
1571     *this = ::std::move(from);
1572   }
1573 
1574   inline ChromeLegacyJsonTrace& operator=(const ChromeLegacyJsonTrace& from) {
1575     if (this == &from) return *this;
1576     CopyFrom(from);
1577     return *this;
1578   }
1579   inline ChromeLegacyJsonTrace& operator=(ChromeLegacyJsonTrace&& from) noexcept {
1580     if (this == &from) return *this;
1581     if (GetOwningArena() == from.GetOwningArena()
1582   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1583         && GetOwningArena() != nullptr
1584   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1585     ) {
1586       InternalSwap(&from);
1587     } else {
1588       CopyFrom(from);
1589     }
1590     return *this;
1591   }
1592 
unknown_fields()1593   inline const std::string& unknown_fields() const {
1594     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1595   }
mutable_unknown_fields()1596   inline std::string* mutable_unknown_fields() {
1597     return _internal_metadata_.mutable_unknown_fields<std::string>();
1598   }
1599 
default_instance()1600   static const ChromeLegacyJsonTrace& default_instance() {
1601     return *internal_default_instance();
1602   }
internal_default_instance()1603   static inline const ChromeLegacyJsonTrace* internal_default_instance() {
1604     return reinterpret_cast<const ChromeLegacyJsonTrace*>(
1605                &_ChromeLegacyJsonTrace_default_instance_);
1606   }
1607   static constexpr int kIndexInFileMessages =
1608     5;
1609 
swap(ChromeLegacyJsonTrace & a,ChromeLegacyJsonTrace & b)1610   friend void swap(ChromeLegacyJsonTrace& a, ChromeLegacyJsonTrace& b) {
1611     a.Swap(&b);
1612   }
Swap(ChromeLegacyJsonTrace * other)1613   inline void Swap(ChromeLegacyJsonTrace* other) {
1614     if (other == this) return;
1615   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1616     if (GetOwningArena() != nullptr &&
1617         GetOwningArena() == other->GetOwningArena()) {
1618    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1619     if (GetOwningArena() == other->GetOwningArena()) {
1620   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1621       InternalSwap(other);
1622     } else {
1623       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1624     }
1625   }
1626   void UnsafeArenaSwap(ChromeLegacyJsonTrace* other) {
1627     if (other == this) return;
1628     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1629     InternalSwap(other);
1630   }
1631 
1632   // implements Message ----------------------------------------------
1633 
1634   ChromeLegacyJsonTrace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1635     return CreateMaybeMessage<ChromeLegacyJsonTrace>(arena);
1636   }
1637   ChromeLegacyJsonTrace* New() const {
1638     return New(nullptr);
1639   }
1640   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1641   void CopyFrom(const ChromeLegacyJsonTrace& from);
1642   void MergeFrom(const ChromeLegacyJsonTrace& from);
1643   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1644   bool IsInitialized() const final;
1645 
1646   size_t ByteSizeLong() const final;
1647   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1648   ::uint8_t* _InternalSerialize(
1649       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1650   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1651 
1652   private:
1653   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1654   void SharedDtor();
1655   void SetCachedSize(int size) const;
1656   void InternalSwap(ChromeLegacyJsonTrace* other);
1657 
1658   private:
1659   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1660   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1661     return "perfetto.protos.ChromeLegacyJsonTrace";
1662   }
1663   protected:
1664   explicit ChromeLegacyJsonTrace(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1665                        bool is_message_owned = false);
1666   public:
1667 
1668   std::string GetTypeName() const final;
1669 
1670   // nested types ----------------------------------------------------
1671 
1672   typedef ChromeLegacyJsonTrace_TraceType TraceType;
1673   static constexpr TraceType USER_TRACE =
1674     ChromeLegacyJsonTrace_TraceType_USER_TRACE;
1675   static constexpr TraceType SYSTEM_TRACE =
1676     ChromeLegacyJsonTrace_TraceType_SYSTEM_TRACE;
1677   static inline bool TraceType_IsValid(int value) {
1678     return ChromeLegacyJsonTrace_TraceType_IsValid(value);
1679   }
1680   static constexpr TraceType TraceType_MIN =
1681     ChromeLegacyJsonTrace_TraceType_TraceType_MIN;
1682   static constexpr TraceType TraceType_MAX =
1683     ChromeLegacyJsonTrace_TraceType_TraceType_MAX;
1684   static constexpr int TraceType_ARRAYSIZE =
1685     ChromeLegacyJsonTrace_TraceType_TraceType_ARRAYSIZE;
1686   template<typename T>
1687   static inline const std::string& TraceType_Name(T enum_t_value) {
1688     static_assert(::std::is_same<T, TraceType>::value ||
1689       ::std::is_integral<T>::value,
1690       "Incorrect type passed to function TraceType_Name.");
1691     return ChromeLegacyJsonTrace_TraceType_Name(enum_t_value);
1692   }
1693   static inline bool TraceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1694       TraceType* value) {
1695     return ChromeLegacyJsonTrace_TraceType_Parse(name, value);
1696   }
1697 
1698   // accessors -------------------------------------------------------
1699 
1700   enum : int {
1701     kDataFieldNumber = 2,
1702     kTypeFieldNumber = 1,
1703   };
1704   // optional string data = 2;
1705   bool has_data() const;
1706   private:
1707   bool _internal_has_data() const;
1708   public:
1709   void clear_data();
1710   const std::string& data() const;
1711   template <typename ArgT0 = const std::string&, typename... ArgT>
1712   void set_data(ArgT0&& arg0, ArgT... args);
1713   std::string* mutable_data();
1714   PROTOBUF_NODISCARD std::string* release_data();
1715   void set_allocated_data(std::string* data);
1716   private:
1717   const std::string& _internal_data() const;
1718   inline PROTOBUF_ALWAYS_INLINE void _internal_set_data(const std::string& value);
1719   std::string* _internal_mutable_data();
1720   public:
1721 
1722   // optional .perfetto.protos.ChromeLegacyJsonTrace.TraceType type = 1;
1723   bool has_type() const;
1724   private:
1725   bool _internal_has_type() const;
1726   public:
1727   void clear_type();
1728   ::perfetto::protos::ChromeLegacyJsonTrace_TraceType type() const;
1729   void set_type(::perfetto::protos::ChromeLegacyJsonTrace_TraceType value);
1730   private:
1731   ::perfetto::protos::ChromeLegacyJsonTrace_TraceType _internal_type() const;
1732   void _internal_set_type(::perfetto::protos::ChromeLegacyJsonTrace_TraceType value);
1733   public:
1734 
1735   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeLegacyJsonTrace)
1736  private:
1737   class _Internal;
1738 
1739   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1740   typedef void InternalArenaConstructable_;
1741   typedef void DestructorSkippable_;
1742   struct Impl_ {
1743     ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1744     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1745     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr data_;
1746     int type_;
1747   };
1748   union { Impl_ _impl_; };
1749   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
1750 };
1751 // -------------------------------------------------------------------
1752 
1753 class ChromeEventBundle final :
1754     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeEventBundle) */ {
1755  public:
ChromeEventBundle()1756   inline ChromeEventBundle() : ChromeEventBundle(nullptr) {}
1757   ~ChromeEventBundle() override;
1758   explicit PROTOBUF_CONSTEXPR ChromeEventBundle(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1759 
1760   ChromeEventBundle(const ChromeEventBundle& from);
ChromeEventBundle(ChromeEventBundle && from)1761   ChromeEventBundle(ChromeEventBundle&& from) noexcept
1762     : ChromeEventBundle() {
1763     *this = ::std::move(from);
1764   }
1765 
1766   inline ChromeEventBundle& operator=(const ChromeEventBundle& from) {
1767     if (this == &from) return *this;
1768     CopyFrom(from);
1769     return *this;
1770   }
1771   inline ChromeEventBundle& operator=(ChromeEventBundle&& from) noexcept {
1772     if (this == &from) return *this;
1773     if (GetOwningArena() == from.GetOwningArena()
1774   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1775         && GetOwningArena() != nullptr
1776   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1777     ) {
1778       InternalSwap(&from);
1779     } else {
1780       CopyFrom(from);
1781     }
1782     return *this;
1783   }
1784 
unknown_fields()1785   inline const std::string& unknown_fields() const {
1786     return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1787   }
mutable_unknown_fields()1788   inline std::string* mutable_unknown_fields() {
1789     return _internal_metadata_.mutable_unknown_fields<std::string>();
1790   }
1791 
default_instance()1792   static const ChromeEventBundle& default_instance() {
1793     return *internal_default_instance();
1794   }
internal_default_instance()1795   static inline const ChromeEventBundle* internal_default_instance() {
1796     return reinterpret_cast<const ChromeEventBundle*>(
1797                &_ChromeEventBundle_default_instance_);
1798   }
1799   static constexpr int kIndexInFileMessages =
1800     6;
1801 
swap(ChromeEventBundle & a,ChromeEventBundle & b)1802   friend void swap(ChromeEventBundle& a, ChromeEventBundle& b) {
1803     a.Swap(&b);
1804   }
Swap(ChromeEventBundle * other)1805   inline void Swap(ChromeEventBundle* other) {
1806     if (other == this) return;
1807   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1808     if (GetOwningArena() != nullptr &&
1809         GetOwningArena() == other->GetOwningArena()) {
1810    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1811     if (GetOwningArena() == other->GetOwningArena()) {
1812   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1813       InternalSwap(other);
1814     } else {
1815       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1816     }
1817   }
1818   void UnsafeArenaSwap(ChromeEventBundle* other) {
1819     if (other == this) return;
1820     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1821     InternalSwap(other);
1822   }
1823 
1824   // implements Message ----------------------------------------------
1825 
1826   ChromeEventBundle* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1827     return CreateMaybeMessage<ChromeEventBundle>(arena);
1828   }
1829   ChromeEventBundle* New() const {
1830     return New(nullptr);
1831   }
1832   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1833   void CopyFrom(const ChromeEventBundle& from);
1834   void MergeFrom(const ChromeEventBundle& from);
1835   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1836   bool IsInitialized() const final;
1837 
1838   size_t ByteSizeLong() const final;
1839   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1840   ::uint8_t* _InternalSerialize(
1841       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1842   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1843 
1844   private:
1845   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1846   void SharedDtor();
1847   void SetCachedSize(int size) const;
1848   void InternalSwap(ChromeEventBundle* other);
1849 
1850   private:
1851   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1852   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1853     return "perfetto.protos.ChromeEventBundle";
1854   }
1855   protected:
1856   explicit ChromeEventBundle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1857                        bool is_message_owned = false);
1858   public:
1859 
1860   std::string GetTypeName() const final;
1861 
1862   // nested types ----------------------------------------------------
1863 
1864   // accessors -------------------------------------------------------
1865 
1866   enum : int {
1867     kTraceEventsFieldNumber = 1,
1868     kMetadataFieldNumber = 2,
1869     kStringTableFieldNumber = 3,
1870     kLegacyFtraceOutputFieldNumber = 4,
1871     kLegacyJsonTraceFieldNumber = 5,
1872   };
1873   // repeated .perfetto.protos.ChromeTraceEvent trace_events = 1 [deprecated = true];
1874   PROTOBUF_DEPRECATED int trace_events_size() const;
1875   private:
1876   int _internal_trace_events_size() const;
1877   public:
1878   PROTOBUF_DEPRECATED void clear_trace_events();
1879   PROTOBUF_DEPRECATED ::perfetto::protos::ChromeTraceEvent* mutable_trace_events(int index);
1880   PROTOBUF_DEPRECATED ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent >*
1881       mutable_trace_events();
1882   private:
1883   const ::perfetto::protos::ChromeTraceEvent& _internal_trace_events(int index) const;
1884   ::perfetto::protos::ChromeTraceEvent* _internal_add_trace_events();
1885   public:
1886   PROTOBUF_DEPRECATED const ::perfetto::protos::ChromeTraceEvent& trace_events(int index) const;
1887   PROTOBUF_DEPRECATED ::perfetto::protos::ChromeTraceEvent* add_trace_events();
1888   PROTOBUF_DEPRECATED const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent >&
1889       trace_events() const;
1890 
1891   // repeated .perfetto.protos.ChromeMetadata metadata = 2;
1892   int metadata_size() const;
1893   private:
1894   int _internal_metadata_size() const;
1895   public:
1896   void clear_metadata();
1897   ::perfetto::protos::ChromeMetadata* mutable_metadata(int index);
1898   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadata >*
1899       mutable_metadata();
1900   private:
1901   const ::perfetto::protos::ChromeMetadata& _internal_metadata(int index) const;
1902   ::perfetto::protos::ChromeMetadata* _internal_add_metadata();
1903   public:
1904   const ::perfetto::protos::ChromeMetadata& metadata(int index) const;
1905   ::perfetto::protos::ChromeMetadata* add_metadata();
1906   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadata >&
1907       metadata() const;
1908 
1909   // repeated .perfetto.protos.ChromeStringTableEntry string_table = 3 [deprecated = true];
1910   PROTOBUF_DEPRECATED int string_table_size() const;
1911   private:
1912   int _internal_string_table_size() const;
1913   public:
1914   PROTOBUF_DEPRECATED void clear_string_table();
1915   PROTOBUF_DEPRECATED ::perfetto::protos::ChromeStringTableEntry* mutable_string_table(int index);
1916   PROTOBUF_DEPRECATED ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeStringTableEntry >*
1917       mutable_string_table();
1918   private:
1919   const ::perfetto::protos::ChromeStringTableEntry& _internal_string_table(int index) const;
1920   ::perfetto::protos::ChromeStringTableEntry* _internal_add_string_table();
1921   public:
1922   PROTOBUF_DEPRECATED const ::perfetto::protos::ChromeStringTableEntry& string_table(int index) const;
1923   PROTOBUF_DEPRECATED ::perfetto::protos::ChromeStringTableEntry* add_string_table();
1924   PROTOBUF_DEPRECATED const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeStringTableEntry >&
1925       string_table() const;
1926 
1927   // repeated string legacy_ftrace_output = 4;
1928   int legacy_ftrace_output_size() const;
1929   private:
1930   int _internal_legacy_ftrace_output_size() const;
1931   public:
1932   void clear_legacy_ftrace_output();
1933   const std::string& legacy_ftrace_output(int index) const;
1934   std::string* mutable_legacy_ftrace_output(int index);
1935   void set_legacy_ftrace_output(int index, const std::string& value);
1936   void set_legacy_ftrace_output(int index, std::string&& value);
1937   void set_legacy_ftrace_output(int index, const char* value);
1938   void set_legacy_ftrace_output(int index, const char* value, size_t size);
1939   std::string* add_legacy_ftrace_output();
1940   void add_legacy_ftrace_output(const std::string& value);
1941   void add_legacy_ftrace_output(std::string&& value);
1942   void add_legacy_ftrace_output(const char* value);
1943   void add_legacy_ftrace_output(const char* value, size_t size);
1944   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& legacy_ftrace_output() const;
1945   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_legacy_ftrace_output();
1946   private:
1947   const std::string& _internal_legacy_ftrace_output(int index) const;
1948   std::string* _internal_add_legacy_ftrace_output();
1949   public:
1950 
1951   // repeated .perfetto.protos.ChromeLegacyJsonTrace legacy_json_trace = 5;
1952   int legacy_json_trace_size() const;
1953   private:
1954   int _internal_legacy_json_trace_size() const;
1955   public:
1956   void clear_legacy_json_trace();
1957   ::perfetto::protos::ChromeLegacyJsonTrace* mutable_legacy_json_trace(int index);
1958   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeLegacyJsonTrace >*
1959       mutable_legacy_json_trace();
1960   private:
1961   const ::perfetto::protos::ChromeLegacyJsonTrace& _internal_legacy_json_trace(int index) const;
1962   ::perfetto::protos::ChromeLegacyJsonTrace* _internal_add_legacy_json_trace();
1963   public:
1964   const ::perfetto::protos::ChromeLegacyJsonTrace& legacy_json_trace(int index) const;
1965   ::perfetto::protos::ChromeLegacyJsonTrace* add_legacy_json_trace();
1966   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeLegacyJsonTrace >&
1967       legacy_json_trace() const;
1968 
1969   // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeEventBundle)
1970  private:
1971   class _Internal;
1972 
1973   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1974   typedef void InternalArenaConstructable_;
1975   typedef void DestructorSkippable_;
1976   struct Impl_ {
1977     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent > trace_events_;
1978     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadata > metadata_;
1979     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeStringTableEntry > string_table_;
1980     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> legacy_ftrace_output_;
1981     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeLegacyJsonTrace > legacy_json_trace_;
1982     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1983   };
1984   union { Impl_ _impl_; };
1985   friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto;
1986 };
1987 // ===================================================================
1988 
1989 
1990 // ===================================================================
1991 
1992 #ifdef __GNUC__
1993   #pragma GCC diagnostic push
1994   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1995 #endif  // __GNUC__
1996 // ChromeTracedValue
1997 
1998 // optional .perfetto.protos.ChromeTracedValue.NestedType nested_type = 1;
_internal_has_nested_type()1999 inline bool ChromeTracedValue::_internal_has_nested_type() const {
2000   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2001   return value;
2002 }
has_nested_type()2003 inline bool ChromeTracedValue::has_nested_type() const {
2004   return _internal_has_nested_type();
2005 }
clear_nested_type()2006 inline void ChromeTracedValue::clear_nested_type() {
2007   _impl_.nested_type_ = 0;
2008   _impl_._has_bits_[0] &= ~0x00000002u;
2009 }
_internal_nested_type()2010 inline ::perfetto::protos::ChromeTracedValue_NestedType ChromeTracedValue::_internal_nested_type() const {
2011   return static_cast< ::perfetto::protos::ChromeTracedValue_NestedType >(_impl_.nested_type_);
2012 }
nested_type()2013 inline ::perfetto::protos::ChromeTracedValue_NestedType ChromeTracedValue::nested_type() const {
2014   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.nested_type)
2015   return _internal_nested_type();
2016 }
_internal_set_nested_type(::perfetto::protos::ChromeTracedValue_NestedType value)2017 inline void ChromeTracedValue::_internal_set_nested_type(::perfetto::protos::ChromeTracedValue_NestedType value) {
2018   assert(::perfetto::protos::ChromeTracedValue_NestedType_IsValid(value));
2019   _impl_._has_bits_[0] |= 0x00000002u;
2020   _impl_.nested_type_ = value;
2021 }
set_nested_type(::perfetto::protos::ChromeTracedValue_NestedType value)2022 inline void ChromeTracedValue::set_nested_type(::perfetto::protos::ChromeTracedValue_NestedType value) {
2023   _internal_set_nested_type(value);
2024   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.nested_type)
2025 }
2026 
2027 // repeated string dict_keys = 2;
_internal_dict_keys_size()2028 inline int ChromeTracedValue::_internal_dict_keys_size() const {
2029   return _impl_.dict_keys_.size();
2030 }
dict_keys_size()2031 inline int ChromeTracedValue::dict_keys_size() const {
2032   return _internal_dict_keys_size();
2033 }
clear_dict_keys()2034 inline void ChromeTracedValue::clear_dict_keys() {
2035   _impl_.dict_keys_.Clear();
2036 }
add_dict_keys()2037 inline std::string* ChromeTracedValue::add_dict_keys() {
2038   std::string* _s = _internal_add_dict_keys();
2039   // @@protoc_insertion_point(field_add_mutable:perfetto.protos.ChromeTracedValue.dict_keys)
2040   return _s;
2041 }
_internal_dict_keys(int index)2042 inline const std::string& ChromeTracedValue::_internal_dict_keys(int index) const {
2043   return _impl_.dict_keys_.Get(index);
2044 }
dict_keys(int index)2045 inline const std::string& ChromeTracedValue::dict_keys(int index) const {
2046   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.dict_keys)
2047   return _internal_dict_keys(index);
2048 }
mutable_dict_keys(int index)2049 inline std::string* ChromeTracedValue::mutable_dict_keys(int index) {
2050   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTracedValue.dict_keys)
2051   return _impl_.dict_keys_.Mutable(index);
2052 }
set_dict_keys(int index,const std::string & value)2053 inline void ChromeTracedValue::set_dict_keys(int index, const std::string& value) {
2054   _impl_.dict_keys_.Mutable(index)->assign(value);
2055   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.dict_keys)
2056 }
set_dict_keys(int index,std::string && value)2057 inline void ChromeTracedValue::set_dict_keys(int index, std::string&& value) {
2058   _impl_.dict_keys_.Mutable(index)->assign(std::move(value));
2059   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.dict_keys)
2060 }
set_dict_keys(int index,const char * value)2061 inline void ChromeTracedValue::set_dict_keys(int index, const char* value) {
2062   GOOGLE_DCHECK(value != nullptr);
2063   _impl_.dict_keys_.Mutable(index)->assign(value);
2064   // @@protoc_insertion_point(field_set_char:perfetto.protos.ChromeTracedValue.dict_keys)
2065 }
set_dict_keys(int index,const char * value,size_t size)2066 inline void ChromeTracedValue::set_dict_keys(int index, const char* value, size_t size) {
2067   _impl_.dict_keys_.Mutable(index)->assign(
2068     reinterpret_cast<const char*>(value), size);
2069   // @@protoc_insertion_point(field_set_pointer:perfetto.protos.ChromeTracedValue.dict_keys)
2070 }
_internal_add_dict_keys()2071 inline std::string* ChromeTracedValue::_internal_add_dict_keys() {
2072   return _impl_.dict_keys_.Add();
2073 }
add_dict_keys(const std::string & value)2074 inline void ChromeTracedValue::add_dict_keys(const std::string& value) {
2075   _impl_.dict_keys_.Add()->assign(value);
2076   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeTracedValue.dict_keys)
2077 }
add_dict_keys(std::string && value)2078 inline void ChromeTracedValue::add_dict_keys(std::string&& value) {
2079   _impl_.dict_keys_.Add(std::move(value));
2080   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeTracedValue.dict_keys)
2081 }
add_dict_keys(const char * value)2082 inline void ChromeTracedValue::add_dict_keys(const char* value) {
2083   GOOGLE_DCHECK(value != nullptr);
2084   _impl_.dict_keys_.Add()->assign(value);
2085   // @@protoc_insertion_point(field_add_char:perfetto.protos.ChromeTracedValue.dict_keys)
2086 }
add_dict_keys(const char * value,size_t size)2087 inline void ChromeTracedValue::add_dict_keys(const char* value, size_t size) {
2088   _impl_.dict_keys_.Add()->assign(reinterpret_cast<const char*>(value), size);
2089   // @@protoc_insertion_point(field_add_pointer:perfetto.protos.ChromeTracedValue.dict_keys)
2090 }
2091 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
dict_keys()2092 ChromeTracedValue::dict_keys() const {
2093   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeTracedValue.dict_keys)
2094   return _impl_.dict_keys_;
2095 }
2096 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_dict_keys()2097 ChromeTracedValue::mutable_dict_keys() {
2098   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeTracedValue.dict_keys)
2099   return &_impl_.dict_keys_;
2100 }
2101 
2102 // repeated .perfetto.protos.ChromeTracedValue dict_values = 3;
_internal_dict_values_size()2103 inline int ChromeTracedValue::_internal_dict_values_size() const {
2104   return _impl_.dict_values_.size();
2105 }
dict_values_size()2106 inline int ChromeTracedValue::dict_values_size() const {
2107   return _internal_dict_values_size();
2108 }
clear_dict_values()2109 inline void ChromeTracedValue::clear_dict_values() {
2110   _impl_.dict_values_.Clear();
2111 }
mutable_dict_values(int index)2112 inline ::perfetto::protos::ChromeTracedValue* ChromeTracedValue::mutable_dict_values(int index) {
2113   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTracedValue.dict_values)
2114   return _impl_.dict_values_.Mutable(index);
2115 }
2116 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >*
mutable_dict_values()2117 ChromeTracedValue::mutable_dict_values() {
2118   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeTracedValue.dict_values)
2119   return &_impl_.dict_values_;
2120 }
_internal_dict_values(int index)2121 inline const ::perfetto::protos::ChromeTracedValue& ChromeTracedValue::_internal_dict_values(int index) const {
2122   return _impl_.dict_values_.Get(index);
2123 }
dict_values(int index)2124 inline const ::perfetto::protos::ChromeTracedValue& ChromeTracedValue::dict_values(int index) const {
2125   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.dict_values)
2126   return _internal_dict_values(index);
2127 }
_internal_add_dict_values()2128 inline ::perfetto::protos::ChromeTracedValue* ChromeTracedValue::_internal_add_dict_values() {
2129   return _impl_.dict_values_.Add();
2130 }
add_dict_values()2131 inline ::perfetto::protos::ChromeTracedValue* ChromeTracedValue::add_dict_values() {
2132   ::perfetto::protos::ChromeTracedValue* _add = _internal_add_dict_values();
2133   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeTracedValue.dict_values)
2134   return _add;
2135 }
2136 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >&
dict_values()2137 ChromeTracedValue::dict_values() const {
2138   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeTracedValue.dict_values)
2139   return _impl_.dict_values_;
2140 }
2141 
2142 // repeated .perfetto.protos.ChromeTracedValue array_values = 4;
_internal_array_values_size()2143 inline int ChromeTracedValue::_internal_array_values_size() const {
2144   return _impl_.array_values_.size();
2145 }
array_values_size()2146 inline int ChromeTracedValue::array_values_size() const {
2147   return _internal_array_values_size();
2148 }
clear_array_values()2149 inline void ChromeTracedValue::clear_array_values() {
2150   _impl_.array_values_.Clear();
2151 }
mutable_array_values(int index)2152 inline ::perfetto::protos::ChromeTracedValue* ChromeTracedValue::mutable_array_values(int index) {
2153   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTracedValue.array_values)
2154   return _impl_.array_values_.Mutable(index);
2155 }
2156 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >*
mutable_array_values()2157 ChromeTracedValue::mutable_array_values() {
2158   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeTracedValue.array_values)
2159   return &_impl_.array_values_;
2160 }
_internal_array_values(int index)2161 inline const ::perfetto::protos::ChromeTracedValue& ChromeTracedValue::_internal_array_values(int index) const {
2162   return _impl_.array_values_.Get(index);
2163 }
array_values(int index)2164 inline const ::perfetto::protos::ChromeTracedValue& ChromeTracedValue::array_values(int index) const {
2165   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.array_values)
2166   return _internal_array_values(index);
2167 }
_internal_add_array_values()2168 inline ::perfetto::protos::ChromeTracedValue* ChromeTracedValue::_internal_add_array_values() {
2169   return _impl_.array_values_.Add();
2170 }
add_array_values()2171 inline ::perfetto::protos::ChromeTracedValue* ChromeTracedValue::add_array_values() {
2172   ::perfetto::protos::ChromeTracedValue* _add = _internal_add_array_values();
2173   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeTracedValue.array_values)
2174   return _add;
2175 }
2176 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTracedValue >&
array_values()2177 ChromeTracedValue::array_values() const {
2178   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeTracedValue.array_values)
2179   return _impl_.array_values_;
2180 }
2181 
2182 // optional int32 int_value = 5;
_internal_has_int_value()2183 inline bool ChromeTracedValue::_internal_has_int_value() const {
2184   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2185   return value;
2186 }
has_int_value()2187 inline bool ChromeTracedValue::has_int_value() const {
2188   return _internal_has_int_value();
2189 }
clear_int_value()2190 inline void ChromeTracedValue::clear_int_value() {
2191   _impl_.int_value_ = 0;
2192   _impl_._has_bits_[0] &= ~0x00000004u;
2193 }
_internal_int_value()2194 inline ::int32_t ChromeTracedValue::_internal_int_value() const {
2195   return _impl_.int_value_;
2196 }
int_value()2197 inline ::int32_t ChromeTracedValue::int_value() const {
2198   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.int_value)
2199   return _internal_int_value();
2200 }
_internal_set_int_value(::int32_t value)2201 inline void ChromeTracedValue::_internal_set_int_value(::int32_t value) {
2202   _impl_._has_bits_[0] |= 0x00000004u;
2203   _impl_.int_value_ = value;
2204 }
set_int_value(::int32_t value)2205 inline void ChromeTracedValue::set_int_value(::int32_t value) {
2206   _internal_set_int_value(value);
2207   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.int_value)
2208 }
2209 
2210 // optional double double_value = 6;
_internal_has_double_value()2211 inline bool ChromeTracedValue::_internal_has_double_value() const {
2212   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2213   return value;
2214 }
has_double_value()2215 inline bool ChromeTracedValue::has_double_value() const {
2216   return _internal_has_double_value();
2217 }
clear_double_value()2218 inline void ChromeTracedValue::clear_double_value() {
2219   _impl_.double_value_ = 0;
2220   _impl_._has_bits_[0] &= ~0x00000008u;
2221 }
_internal_double_value()2222 inline double ChromeTracedValue::_internal_double_value() const {
2223   return _impl_.double_value_;
2224 }
double_value()2225 inline double ChromeTracedValue::double_value() const {
2226   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.double_value)
2227   return _internal_double_value();
2228 }
_internal_set_double_value(double value)2229 inline void ChromeTracedValue::_internal_set_double_value(double value) {
2230   _impl_._has_bits_[0] |= 0x00000008u;
2231   _impl_.double_value_ = value;
2232 }
set_double_value(double value)2233 inline void ChromeTracedValue::set_double_value(double value) {
2234   _internal_set_double_value(value);
2235   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.double_value)
2236 }
2237 
2238 // optional bool bool_value = 7;
_internal_has_bool_value()2239 inline bool ChromeTracedValue::_internal_has_bool_value() const {
2240   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2241   return value;
2242 }
has_bool_value()2243 inline bool ChromeTracedValue::has_bool_value() const {
2244   return _internal_has_bool_value();
2245 }
clear_bool_value()2246 inline void ChromeTracedValue::clear_bool_value() {
2247   _impl_.bool_value_ = false;
2248   _impl_._has_bits_[0] &= ~0x00000010u;
2249 }
_internal_bool_value()2250 inline bool ChromeTracedValue::_internal_bool_value() const {
2251   return _impl_.bool_value_;
2252 }
bool_value()2253 inline bool ChromeTracedValue::bool_value() const {
2254   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.bool_value)
2255   return _internal_bool_value();
2256 }
_internal_set_bool_value(bool value)2257 inline void ChromeTracedValue::_internal_set_bool_value(bool value) {
2258   _impl_._has_bits_[0] |= 0x00000010u;
2259   _impl_.bool_value_ = value;
2260 }
set_bool_value(bool value)2261 inline void ChromeTracedValue::set_bool_value(bool value) {
2262   _internal_set_bool_value(value);
2263   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.bool_value)
2264 }
2265 
2266 // optional string string_value = 8;
_internal_has_string_value()2267 inline bool ChromeTracedValue::_internal_has_string_value() const {
2268   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2269   return value;
2270 }
has_string_value()2271 inline bool ChromeTracedValue::has_string_value() const {
2272   return _internal_has_string_value();
2273 }
clear_string_value()2274 inline void ChromeTracedValue::clear_string_value() {
2275   _impl_.string_value_.ClearToEmpty();
2276   _impl_._has_bits_[0] &= ~0x00000001u;
2277 }
string_value()2278 inline const std::string& ChromeTracedValue::string_value() const {
2279   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTracedValue.string_value)
2280   return _internal_string_value();
2281 }
2282 template <typename ArgT0, typename... ArgT>
2283 inline PROTOBUF_ALWAYS_INLINE
set_string_value(ArgT0 && arg0,ArgT...args)2284 void ChromeTracedValue::set_string_value(ArgT0&& arg0, ArgT... args) {
2285  _impl_._has_bits_[0] |= 0x00000001u;
2286  _impl_.string_value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2287   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTracedValue.string_value)
2288 }
mutable_string_value()2289 inline std::string* ChromeTracedValue::mutable_string_value() {
2290   std::string* _s = _internal_mutable_string_value();
2291   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTracedValue.string_value)
2292   return _s;
2293 }
_internal_string_value()2294 inline const std::string& ChromeTracedValue::_internal_string_value() const {
2295   return _impl_.string_value_.Get();
2296 }
_internal_set_string_value(const std::string & value)2297 inline void ChromeTracedValue::_internal_set_string_value(const std::string& value) {
2298   _impl_._has_bits_[0] |= 0x00000001u;
2299   _impl_.string_value_.Set(value, GetArenaForAllocation());
2300 }
_internal_mutable_string_value()2301 inline std::string* ChromeTracedValue::_internal_mutable_string_value() {
2302   _impl_._has_bits_[0] |= 0x00000001u;
2303   return _impl_.string_value_.Mutable(GetArenaForAllocation());
2304 }
release_string_value()2305 inline std::string* ChromeTracedValue::release_string_value() {
2306   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTracedValue.string_value)
2307   if (!_internal_has_string_value()) {
2308     return nullptr;
2309   }
2310   _impl_._has_bits_[0] &= ~0x00000001u;
2311   auto* p = _impl_.string_value_.Release();
2312 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2313   if (_impl_.string_value_.IsDefault()) {
2314     _impl_.string_value_.Set("", GetArenaForAllocation());
2315   }
2316 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2317   return p;
2318 }
set_allocated_string_value(std::string * string_value)2319 inline void ChromeTracedValue::set_allocated_string_value(std::string* string_value) {
2320   if (string_value != nullptr) {
2321     _impl_._has_bits_[0] |= 0x00000001u;
2322   } else {
2323     _impl_._has_bits_[0] &= ~0x00000001u;
2324   }
2325   _impl_.string_value_.SetAllocated(string_value, GetArenaForAllocation());
2326 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2327   if (_impl_.string_value_.IsDefault()) {
2328     _impl_.string_value_.Set("", GetArenaForAllocation());
2329   }
2330 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2331   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTracedValue.string_value)
2332 }
2333 
2334 // -------------------------------------------------------------------
2335 
2336 // ChromeStringTableEntry
2337 
2338 // optional string value = 1;
_internal_has_value()2339 inline bool ChromeStringTableEntry::_internal_has_value() const {
2340   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2341   return value;
2342 }
has_value()2343 inline bool ChromeStringTableEntry::has_value() const {
2344   return _internal_has_value();
2345 }
clear_value()2346 inline void ChromeStringTableEntry::clear_value() {
2347   _impl_.value_.ClearToEmpty();
2348   _impl_._has_bits_[0] &= ~0x00000001u;
2349 }
value()2350 inline const std::string& ChromeStringTableEntry::value() const {
2351   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeStringTableEntry.value)
2352   return _internal_value();
2353 }
2354 template <typename ArgT0, typename... ArgT>
2355 inline PROTOBUF_ALWAYS_INLINE
set_value(ArgT0 && arg0,ArgT...args)2356 void ChromeStringTableEntry::set_value(ArgT0&& arg0, ArgT... args) {
2357  _impl_._has_bits_[0] |= 0x00000001u;
2358  _impl_.value_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2359   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeStringTableEntry.value)
2360 }
mutable_value()2361 inline std::string* ChromeStringTableEntry::mutable_value() {
2362   std::string* _s = _internal_mutable_value();
2363   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeStringTableEntry.value)
2364   return _s;
2365 }
_internal_value()2366 inline const std::string& ChromeStringTableEntry::_internal_value() const {
2367   return _impl_.value_.Get();
2368 }
_internal_set_value(const std::string & value)2369 inline void ChromeStringTableEntry::_internal_set_value(const std::string& value) {
2370   _impl_._has_bits_[0] |= 0x00000001u;
2371   _impl_.value_.Set(value, GetArenaForAllocation());
2372 }
_internal_mutable_value()2373 inline std::string* ChromeStringTableEntry::_internal_mutable_value() {
2374   _impl_._has_bits_[0] |= 0x00000001u;
2375   return _impl_.value_.Mutable(GetArenaForAllocation());
2376 }
release_value()2377 inline std::string* ChromeStringTableEntry::release_value() {
2378   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeStringTableEntry.value)
2379   if (!_internal_has_value()) {
2380     return nullptr;
2381   }
2382   _impl_._has_bits_[0] &= ~0x00000001u;
2383   auto* p = _impl_.value_.Release();
2384 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2385   if (_impl_.value_.IsDefault()) {
2386     _impl_.value_.Set("", GetArenaForAllocation());
2387   }
2388 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2389   return p;
2390 }
set_allocated_value(std::string * value)2391 inline void ChromeStringTableEntry::set_allocated_value(std::string* value) {
2392   if (value != nullptr) {
2393     _impl_._has_bits_[0] |= 0x00000001u;
2394   } else {
2395     _impl_._has_bits_[0] &= ~0x00000001u;
2396   }
2397   _impl_.value_.SetAllocated(value, GetArenaForAllocation());
2398 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2399   if (_impl_.value_.IsDefault()) {
2400     _impl_.value_.Set("", GetArenaForAllocation());
2401   }
2402 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2403   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeStringTableEntry.value)
2404 }
2405 
2406 // optional int32 index = 2;
_internal_has_index()2407 inline bool ChromeStringTableEntry::_internal_has_index() const {
2408   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2409   return value;
2410 }
has_index()2411 inline bool ChromeStringTableEntry::has_index() const {
2412   return _internal_has_index();
2413 }
clear_index()2414 inline void ChromeStringTableEntry::clear_index() {
2415   _impl_.index_ = 0;
2416   _impl_._has_bits_[0] &= ~0x00000002u;
2417 }
_internal_index()2418 inline ::int32_t ChromeStringTableEntry::_internal_index() const {
2419   return _impl_.index_;
2420 }
index()2421 inline ::int32_t ChromeStringTableEntry::index() const {
2422   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeStringTableEntry.index)
2423   return _internal_index();
2424 }
_internal_set_index(::int32_t value)2425 inline void ChromeStringTableEntry::_internal_set_index(::int32_t value) {
2426   _impl_._has_bits_[0] |= 0x00000002u;
2427   _impl_.index_ = value;
2428 }
set_index(::int32_t value)2429 inline void ChromeStringTableEntry::set_index(::int32_t value) {
2430   _internal_set_index(value);
2431   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeStringTableEntry.index)
2432 }
2433 
2434 // -------------------------------------------------------------------
2435 
2436 // ChromeTraceEvent_Arg
2437 
2438 // optional string name = 1;
_internal_has_name()2439 inline bool ChromeTraceEvent_Arg::_internal_has_name() const {
2440   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2441   return value;
2442 }
has_name()2443 inline bool ChromeTraceEvent_Arg::has_name() const {
2444   return _internal_has_name();
2445 }
clear_name()2446 inline void ChromeTraceEvent_Arg::clear_name() {
2447   _impl_.name_.ClearToEmpty();
2448   _impl_._has_bits_[0] &= ~0x00000001u;
2449 }
name()2450 inline const std::string& ChromeTraceEvent_Arg::name() const {
2451   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.name)
2452   return _internal_name();
2453 }
2454 template <typename ArgT0, typename... ArgT>
2455 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)2456 void ChromeTraceEvent_Arg::set_name(ArgT0&& arg0, ArgT... args) {
2457  _impl_._has_bits_[0] |= 0x00000001u;
2458  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2459   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.name)
2460 }
mutable_name()2461 inline std::string* ChromeTraceEvent_Arg::mutable_name() {
2462   std::string* _s = _internal_mutable_name();
2463   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.Arg.name)
2464   return _s;
2465 }
_internal_name()2466 inline const std::string& ChromeTraceEvent_Arg::_internal_name() const {
2467   return _impl_.name_.Get();
2468 }
_internal_set_name(const std::string & value)2469 inline void ChromeTraceEvent_Arg::_internal_set_name(const std::string& value) {
2470   _impl_._has_bits_[0] |= 0x00000001u;
2471   _impl_.name_.Set(value, GetArenaForAllocation());
2472 }
_internal_mutable_name()2473 inline std::string* ChromeTraceEvent_Arg::_internal_mutable_name() {
2474   _impl_._has_bits_[0] |= 0x00000001u;
2475   return _impl_.name_.Mutable(GetArenaForAllocation());
2476 }
release_name()2477 inline std::string* ChromeTraceEvent_Arg::release_name() {
2478   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.Arg.name)
2479   if (!_internal_has_name()) {
2480     return nullptr;
2481   }
2482   _impl_._has_bits_[0] &= ~0x00000001u;
2483   auto* p = _impl_.name_.Release();
2484 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2485   if (_impl_.name_.IsDefault()) {
2486     _impl_.name_.Set("", GetArenaForAllocation());
2487   }
2488 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2489   return p;
2490 }
set_allocated_name(std::string * name)2491 inline void ChromeTraceEvent_Arg::set_allocated_name(std::string* name) {
2492   if (name != nullptr) {
2493     _impl_._has_bits_[0] |= 0x00000001u;
2494   } else {
2495     _impl_._has_bits_[0] &= ~0x00000001u;
2496   }
2497   _impl_.name_.SetAllocated(name, GetArenaForAllocation());
2498 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2499   if (_impl_.name_.IsDefault()) {
2500     _impl_.name_.Set("", GetArenaForAllocation());
2501   }
2502 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2503   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.Arg.name)
2504 }
2505 
2506 // bool bool_value = 2;
_internal_has_bool_value()2507 inline bool ChromeTraceEvent_Arg::_internal_has_bool_value() const {
2508   return value_case() == kBoolValue;
2509 }
has_bool_value()2510 inline bool ChromeTraceEvent_Arg::has_bool_value() const {
2511   return _internal_has_bool_value();
2512 }
set_has_bool_value()2513 inline void ChromeTraceEvent_Arg::set_has_bool_value() {
2514   _impl_._oneof_case_[0] = kBoolValue;
2515 }
clear_bool_value()2516 inline void ChromeTraceEvent_Arg::clear_bool_value() {
2517   if (_internal_has_bool_value()) {
2518     _impl_.value_.bool_value_ = false;
2519     clear_has_value();
2520   }
2521 }
_internal_bool_value()2522 inline bool ChromeTraceEvent_Arg::_internal_bool_value() const {
2523   if (_internal_has_bool_value()) {
2524     return _impl_.value_.bool_value_;
2525   }
2526   return false;
2527 }
_internal_set_bool_value(bool value)2528 inline void ChromeTraceEvent_Arg::_internal_set_bool_value(bool value) {
2529   if (!_internal_has_bool_value()) {
2530     clear_value();
2531     set_has_bool_value();
2532   }
2533   _impl_.value_.bool_value_ = value;
2534 }
bool_value()2535 inline bool ChromeTraceEvent_Arg::bool_value() const {
2536   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.bool_value)
2537   return _internal_bool_value();
2538 }
set_bool_value(bool value)2539 inline void ChromeTraceEvent_Arg::set_bool_value(bool value) {
2540   _internal_set_bool_value(value);
2541   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.bool_value)
2542 }
2543 
2544 // uint64 uint_value = 3;
_internal_has_uint_value()2545 inline bool ChromeTraceEvent_Arg::_internal_has_uint_value() const {
2546   return value_case() == kUintValue;
2547 }
has_uint_value()2548 inline bool ChromeTraceEvent_Arg::has_uint_value() const {
2549   return _internal_has_uint_value();
2550 }
set_has_uint_value()2551 inline void ChromeTraceEvent_Arg::set_has_uint_value() {
2552   _impl_._oneof_case_[0] = kUintValue;
2553 }
clear_uint_value()2554 inline void ChromeTraceEvent_Arg::clear_uint_value() {
2555   if (_internal_has_uint_value()) {
2556     _impl_.value_.uint_value_ = ::uint64_t{0u};
2557     clear_has_value();
2558   }
2559 }
_internal_uint_value()2560 inline ::uint64_t ChromeTraceEvent_Arg::_internal_uint_value() const {
2561   if (_internal_has_uint_value()) {
2562     return _impl_.value_.uint_value_;
2563   }
2564   return ::uint64_t{0u};
2565 }
_internal_set_uint_value(::uint64_t value)2566 inline void ChromeTraceEvent_Arg::_internal_set_uint_value(::uint64_t value) {
2567   if (!_internal_has_uint_value()) {
2568     clear_value();
2569     set_has_uint_value();
2570   }
2571   _impl_.value_.uint_value_ = value;
2572 }
uint_value()2573 inline ::uint64_t ChromeTraceEvent_Arg::uint_value() const {
2574   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.uint_value)
2575   return _internal_uint_value();
2576 }
set_uint_value(::uint64_t value)2577 inline void ChromeTraceEvent_Arg::set_uint_value(::uint64_t value) {
2578   _internal_set_uint_value(value);
2579   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.uint_value)
2580 }
2581 
2582 // int64 int_value = 4;
_internal_has_int_value()2583 inline bool ChromeTraceEvent_Arg::_internal_has_int_value() const {
2584   return value_case() == kIntValue;
2585 }
has_int_value()2586 inline bool ChromeTraceEvent_Arg::has_int_value() const {
2587   return _internal_has_int_value();
2588 }
set_has_int_value()2589 inline void ChromeTraceEvent_Arg::set_has_int_value() {
2590   _impl_._oneof_case_[0] = kIntValue;
2591 }
clear_int_value()2592 inline void ChromeTraceEvent_Arg::clear_int_value() {
2593   if (_internal_has_int_value()) {
2594     _impl_.value_.int_value_ = ::int64_t{0};
2595     clear_has_value();
2596   }
2597 }
_internal_int_value()2598 inline ::int64_t ChromeTraceEvent_Arg::_internal_int_value() const {
2599   if (_internal_has_int_value()) {
2600     return _impl_.value_.int_value_;
2601   }
2602   return ::int64_t{0};
2603 }
_internal_set_int_value(::int64_t value)2604 inline void ChromeTraceEvent_Arg::_internal_set_int_value(::int64_t value) {
2605   if (!_internal_has_int_value()) {
2606     clear_value();
2607     set_has_int_value();
2608   }
2609   _impl_.value_.int_value_ = value;
2610 }
int_value()2611 inline ::int64_t ChromeTraceEvent_Arg::int_value() const {
2612   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.int_value)
2613   return _internal_int_value();
2614 }
set_int_value(::int64_t value)2615 inline void ChromeTraceEvent_Arg::set_int_value(::int64_t value) {
2616   _internal_set_int_value(value);
2617   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.int_value)
2618 }
2619 
2620 // double double_value = 5;
_internal_has_double_value()2621 inline bool ChromeTraceEvent_Arg::_internal_has_double_value() const {
2622   return value_case() == kDoubleValue;
2623 }
has_double_value()2624 inline bool ChromeTraceEvent_Arg::has_double_value() const {
2625   return _internal_has_double_value();
2626 }
set_has_double_value()2627 inline void ChromeTraceEvent_Arg::set_has_double_value() {
2628   _impl_._oneof_case_[0] = kDoubleValue;
2629 }
clear_double_value()2630 inline void ChromeTraceEvent_Arg::clear_double_value() {
2631   if (_internal_has_double_value()) {
2632     _impl_.value_.double_value_ = 0;
2633     clear_has_value();
2634   }
2635 }
_internal_double_value()2636 inline double ChromeTraceEvent_Arg::_internal_double_value() const {
2637   if (_internal_has_double_value()) {
2638     return _impl_.value_.double_value_;
2639   }
2640   return 0;
2641 }
_internal_set_double_value(double value)2642 inline void ChromeTraceEvent_Arg::_internal_set_double_value(double value) {
2643   if (!_internal_has_double_value()) {
2644     clear_value();
2645     set_has_double_value();
2646   }
2647   _impl_.value_.double_value_ = value;
2648 }
double_value()2649 inline double ChromeTraceEvent_Arg::double_value() const {
2650   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.double_value)
2651   return _internal_double_value();
2652 }
set_double_value(double value)2653 inline void ChromeTraceEvent_Arg::set_double_value(double value) {
2654   _internal_set_double_value(value);
2655   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.double_value)
2656 }
2657 
2658 // string string_value = 6;
_internal_has_string_value()2659 inline bool ChromeTraceEvent_Arg::_internal_has_string_value() const {
2660   return value_case() == kStringValue;
2661 }
has_string_value()2662 inline bool ChromeTraceEvent_Arg::has_string_value() const {
2663   return _internal_has_string_value();
2664 }
set_has_string_value()2665 inline void ChromeTraceEvent_Arg::set_has_string_value() {
2666   _impl_._oneof_case_[0] = kStringValue;
2667 }
clear_string_value()2668 inline void ChromeTraceEvent_Arg::clear_string_value() {
2669   if (_internal_has_string_value()) {
2670     _impl_.value_.string_value_.Destroy();
2671     clear_has_value();
2672   }
2673 }
string_value()2674 inline const std::string& ChromeTraceEvent_Arg::string_value() const {
2675   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.string_value)
2676   return _internal_string_value();
2677 }
2678 template <typename ArgT0, typename... ArgT>
set_string_value(ArgT0 && arg0,ArgT...args)2679 inline void ChromeTraceEvent_Arg::set_string_value(ArgT0&& arg0, ArgT... args) {
2680   if (!_internal_has_string_value()) {
2681     clear_value();
2682     set_has_string_value();
2683     _impl_.value_.string_value_.InitDefault();
2684   }
2685   _impl_.value_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2686   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.string_value)
2687 }
mutable_string_value()2688 inline std::string* ChromeTraceEvent_Arg::mutable_string_value() {
2689   std::string* _s = _internal_mutable_string_value();
2690   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.Arg.string_value)
2691   return _s;
2692 }
_internal_string_value()2693 inline const std::string& ChromeTraceEvent_Arg::_internal_string_value() const {
2694   if (_internal_has_string_value()) {
2695     return _impl_.value_.string_value_.Get();
2696   }
2697   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
2698 }
_internal_set_string_value(const std::string & value)2699 inline void ChromeTraceEvent_Arg::_internal_set_string_value(const std::string& value) {
2700   if (!_internal_has_string_value()) {
2701     clear_value();
2702     set_has_string_value();
2703     _impl_.value_.string_value_.InitDefault();
2704   }
2705   _impl_.value_.string_value_.Set(value, GetArenaForAllocation());
2706 }
_internal_mutable_string_value()2707 inline std::string* ChromeTraceEvent_Arg::_internal_mutable_string_value() {
2708   if (!_internal_has_string_value()) {
2709     clear_value();
2710     set_has_string_value();
2711     _impl_.value_.string_value_.InitDefault();
2712   }
2713   return _impl_.value_.string_value_.Mutable(      GetArenaForAllocation());
2714 }
release_string_value()2715 inline std::string* ChromeTraceEvent_Arg::release_string_value() {
2716   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.Arg.string_value)
2717   if (_internal_has_string_value()) {
2718     clear_has_value();
2719     return _impl_.value_.string_value_.Release();
2720   } else {
2721     return nullptr;
2722   }
2723 }
set_allocated_string_value(std::string * string_value)2724 inline void ChromeTraceEvent_Arg::set_allocated_string_value(std::string* string_value) {
2725   if (has_value()) {
2726     clear_value();
2727   }
2728   if (string_value != nullptr) {
2729     set_has_string_value();
2730     _impl_.value_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
2731   }
2732   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.Arg.string_value)
2733 }
2734 
2735 // uint64 pointer_value = 7;
_internal_has_pointer_value()2736 inline bool ChromeTraceEvent_Arg::_internal_has_pointer_value() const {
2737   return value_case() == kPointerValue;
2738 }
has_pointer_value()2739 inline bool ChromeTraceEvent_Arg::has_pointer_value() const {
2740   return _internal_has_pointer_value();
2741 }
set_has_pointer_value()2742 inline void ChromeTraceEvent_Arg::set_has_pointer_value() {
2743   _impl_._oneof_case_[0] = kPointerValue;
2744 }
clear_pointer_value()2745 inline void ChromeTraceEvent_Arg::clear_pointer_value() {
2746   if (_internal_has_pointer_value()) {
2747     _impl_.value_.pointer_value_ = ::uint64_t{0u};
2748     clear_has_value();
2749   }
2750 }
_internal_pointer_value()2751 inline ::uint64_t ChromeTraceEvent_Arg::_internal_pointer_value() const {
2752   if (_internal_has_pointer_value()) {
2753     return _impl_.value_.pointer_value_;
2754   }
2755   return ::uint64_t{0u};
2756 }
_internal_set_pointer_value(::uint64_t value)2757 inline void ChromeTraceEvent_Arg::_internal_set_pointer_value(::uint64_t value) {
2758   if (!_internal_has_pointer_value()) {
2759     clear_value();
2760     set_has_pointer_value();
2761   }
2762   _impl_.value_.pointer_value_ = value;
2763 }
pointer_value()2764 inline ::uint64_t ChromeTraceEvent_Arg::pointer_value() const {
2765   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.pointer_value)
2766   return _internal_pointer_value();
2767 }
set_pointer_value(::uint64_t value)2768 inline void ChromeTraceEvent_Arg::set_pointer_value(::uint64_t value) {
2769   _internal_set_pointer_value(value);
2770   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.pointer_value)
2771 }
2772 
2773 // string json_value = 8;
_internal_has_json_value()2774 inline bool ChromeTraceEvent_Arg::_internal_has_json_value() const {
2775   return value_case() == kJsonValue;
2776 }
has_json_value()2777 inline bool ChromeTraceEvent_Arg::has_json_value() const {
2778   return _internal_has_json_value();
2779 }
set_has_json_value()2780 inline void ChromeTraceEvent_Arg::set_has_json_value() {
2781   _impl_._oneof_case_[0] = kJsonValue;
2782 }
clear_json_value()2783 inline void ChromeTraceEvent_Arg::clear_json_value() {
2784   if (_internal_has_json_value()) {
2785     _impl_.value_.json_value_.Destroy();
2786     clear_has_value();
2787   }
2788 }
json_value()2789 inline const std::string& ChromeTraceEvent_Arg::json_value() const {
2790   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.json_value)
2791   return _internal_json_value();
2792 }
2793 template <typename ArgT0, typename... ArgT>
set_json_value(ArgT0 && arg0,ArgT...args)2794 inline void ChromeTraceEvent_Arg::set_json_value(ArgT0&& arg0, ArgT... args) {
2795   if (!_internal_has_json_value()) {
2796     clear_value();
2797     set_has_json_value();
2798     _impl_.value_.json_value_.InitDefault();
2799   }
2800   _impl_.value_.json_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2801   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.json_value)
2802 }
mutable_json_value()2803 inline std::string* ChromeTraceEvent_Arg::mutable_json_value() {
2804   std::string* _s = _internal_mutable_json_value();
2805   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.Arg.json_value)
2806   return _s;
2807 }
_internal_json_value()2808 inline const std::string& ChromeTraceEvent_Arg::_internal_json_value() const {
2809   if (_internal_has_json_value()) {
2810     return _impl_.value_.json_value_.Get();
2811   }
2812   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
2813 }
_internal_set_json_value(const std::string & value)2814 inline void ChromeTraceEvent_Arg::_internal_set_json_value(const std::string& value) {
2815   if (!_internal_has_json_value()) {
2816     clear_value();
2817     set_has_json_value();
2818     _impl_.value_.json_value_.InitDefault();
2819   }
2820   _impl_.value_.json_value_.Set(value, GetArenaForAllocation());
2821 }
_internal_mutable_json_value()2822 inline std::string* ChromeTraceEvent_Arg::_internal_mutable_json_value() {
2823   if (!_internal_has_json_value()) {
2824     clear_value();
2825     set_has_json_value();
2826     _impl_.value_.json_value_.InitDefault();
2827   }
2828   return _impl_.value_.json_value_.Mutable(      GetArenaForAllocation());
2829 }
release_json_value()2830 inline std::string* ChromeTraceEvent_Arg::release_json_value() {
2831   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.Arg.json_value)
2832   if (_internal_has_json_value()) {
2833     clear_has_value();
2834     return _impl_.value_.json_value_.Release();
2835   } else {
2836     return nullptr;
2837   }
2838 }
set_allocated_json_value(std::string * json_value)2839 inline void ChromeTraceEvent_Arg::set_allocated_json_value(std::string* json_value) {
2840   if (has_value()) {
2841     clear_value();
2842   }
2843   if (json_value != nullptr) {
2844     set_has_json_value();
2845     _impl_.value_.json_value_.InitAllocated(json_value, GetArenaForAllocation());
2846   }
2847   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.Arg.json_value)
2848 }
2849 
2850 // .perfetto.protos.ChromeTracedValue traced_value = 10;
_internal_has_traced_value()2851 inline bool ChromeTraceEvent_Arg::_internal_has_traced_value() const {
2852   return value_case() == kTracedValue;
2853 }
has_traced_value()2854 inline bool ChromeTraceEvent_Arg::has_traced_value() const {
2855   return _internal_has_traced_value();
2856 }
set_has_traced_value()2857 inline void ChromeTraceEvent_Arg::set_has_traced_value() {
2858   _impl_._oneof_case_[0] = kTracedValue;
2859 }
clear_traced_value()2860 inline void ChromeTraceEvent_Arg::clear_traced_value() {
2861   if (_internal_has_traced_value()) {
2862     if (GetArenaForAllocation() == nullptr) {
2863       delete _impl_.value_.traced_value_;
2864     }
2865     clear_has_value();
2866   }
2867 }
release_traced_value()2868 inline ::perfetto::protos::ChromeTracedValue* ChromeTraceEvent_Arg::release_traced_value() {
2869   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.Arg.traced_value)
2870   if (_internal_has_traced_value()) {
2871     clear_has_value();
2872     ::perfetto::protos::ChromeTracedValue* temp = _impl_.value_.traced_value_;
2873     if (GetArenaForAllocation() != nullptr) {
2874       temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2875     }
2876     _impl_.value_.traced_value_ = nullptr;
2877     return temp;
2878   } else {
2879     return nullptr;
2880   }
2881 }
_internal_traced_value()2882 inline const ::perfetto::protos::ChromeTracedValue& ChromeTraceEvent_Arg::_internal_traced_value() const {
2883   return _internal_has_traced_value()
2884       ? *_impl_.value_.traced_value_
2885       : reinterpret_cast< ::perfetto::protos::ChromeTracedValue&>(::perfetto::protos::_ChromeTracedValue_default_instance_);
2886 }
traced_value()2887 inline const ::perfetto::protos::ChromeTracedValue& ChromeTraceEvent_Arg::traced_value() const {
2888   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.traced_value)
2889   return _internal_traced_value();
2890 }
unsafe_arena_release_traced_value()2891 inline ::perfetto::protos::ChromeTracedValue* ChromeTraceEvent_Arg::unsafe_arena_release_traced_value() {
2892   // @@protoc_insertion_point(field_unsafe_arena_release:perfetto.protos.ChromeTraceEvent.Arg.traced_value)
2893   if (_internal_has_traced_value()) {
2894     clear_has_value();
2895     ::perfetto::protos::ChromeTracedValue* temp = _impl_.value_.traced_value_;
2896     _impl_.value_.traced_value_ = nullptr;
2897     return temp;
2898   } else {
2899     return nullptr;
2900   }
2901 }
unsafe_arena_set_allocated_traced_value(::perfetto::protos::ChromeTracedValue * traced_value)2902 inline void ChromeTraceEvent_Arg::unsafe_arena_set_allocated_traced_value(::perfetto::protos::ChromeTracedValue* traced_value) {
2903   clear_value();
2904   if (traced_value) {
2905     set_has_traced_value();
2906     _impl_.value_.traced_value_ = traced_value;
2907   }
2908   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.ChromeTraceEvent.Arg.traced_value)
2909 }
_internal_mutable_traced_value()2910 inline ::perfetto::protos::ChromeTracedValue* ChromeTraceEvent_Arg::_internal_mutable_traced_value() {
2911   if (!_internal_has_traced_value()) {
2912     clear_value();
2913     set_has_traced_value();
2914     _impl_.value_.traced_value_ = CreateMaybeMessage< ::perfetto::protos::ChromeTracedValue >(GetArenaForAllocation());
2915   }
2916   return _impl_.value_.traced_value_;
2917 }
mutable_traced_value()2918 inline ::perfetto::protos::ChromeTracedValue* ChromeTraceEvent_Arg::mutable_traced_value() {
2919   ::perfetto::protos::ChromeTracedValue* _msg = _internal_mutable_traced_value();
2920   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.Arg.traced_value)
2921   return _msg;
2922 }
2923 
2924 // optional uint32 name_index = 9;
_internal_has_name_index()2925 inline bool ChromeTraceEvent_Arg::_internal_has_name_index() const {
2926   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2927   return value;
2928 }
has_name_index()2929 inline bool ChromeTraceEvent_Arg::has_name_index() const {
2930   return _internal_has_name_index();
2931 }
clear_name_index()2932 inline void ChromeTraceEvent_Arg::clear_name_index() {
2933   _impl_.name_index_ = 0u;
2934   _impl_._has_bits_[0] &= ~0x00000002u;
2935 }
_internal_name_index()2936 inline ::uint32_t ChromeTraceEvent_Arg::_internal_name_index() const {
2937   return _impl_.name_index_;
2938 }
name_index()2939 inline ::uint32_t ChromeTraceEvent_Arg::name_index() const {
2940   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.Arg.name_index)
2941   return _internal_name_index();
2942 }
_internal_set_name_index(::uint32_t value)2943 inline void ChromeTraceEvent_Arg::_internal_set_name_index(::uint32_t value) {
2944   _impl_._has_bits_[0] |= 0x00000002u;
2945   _impl_.name_index_ = value;
2946 }
set_name_index(::uint32_t value)2947 inline void ChromeTraceEvent_Arg::set_name_index(::uint32_t value) {
2948   _internal_set_name_index(value);
2949   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.Arg.name_index)
2950 }
2951 
has_value()2952 inline bool ChromeTraceEvent_Arg::has_value() const {
2953   return value_case() != VALUE_NOT_SET;
2954 }
clear_has_value()2955 inline void ChromeTraceEvent_Arg::clear_has_value() {
2956   _impl_._oneof_case_[0] = VALUE_NOT_SET;
2957 }
value_case()2958 inline ChromeTraceEvent_Arg::ValueCase ChromeTraceEvent_Arg::value_case() const {
2959   return ChromeTraceEvent_Arg::ValueCase(_impl_._oneof_case_[0]);
2960 }
2961 // -------------------------------------------------------------------
2962 
2963 // ChromeTraceEvent
2964 
2965 // optional string name = 1;
_internal_has_name()2966 inline bool ChromeTraceEvent::_internal_has_name() const {
2967   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2968   return value;
2969 }
has_name()2970 inline bool ChromeTraceEvent::has_name() const {
2971   return _internal_has_name();
2972 }
clear_name()2973 inline void ChromeTraceEvent::clear_name() {
2974   _impl_.name_.ClearToEmpty();
2975   _impl_._has_bits_[0] &= ~0x00000001u;
2976 }
name()2977 inline const std::string& ChromeTraceEvent::name() const {
2978   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.name)
2979   return _internal_name();
2980 }
2981 template <typename ArgT0, typename... ArgT>
2982 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)2983 void ChromeTraceEvent::set_name(ArgT0&& arg0, ArgT... args) {
2984  _impl_._has_bits_[0] |= 0x00000001u;
2985  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2986   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.name)
2987 }
mutable_name()2988 inline std::string* ChromeTraceEvent::mutable_name() {
2989   std::string* _s = _internal_mutable_name();
2990   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.name)
2991   return _s;
2992 }
_internal_name()2993 inline const std::string& ChromeTraceEvent::_internal_name() const {
2994   return _impl_.name_.Get();
2995 }
_internal_set_name(const std::string & value)2996 inline void ChromeTraceEvent::_internal_set_name(const std::string& value) {
2997   _impl_._has_bits_[0] |= 0x00000001u;
2998   _impl_.name_.Set(value, GetArenaForAllocation());
2999 }
_internal_mutable_name()3000 inline std::string* ChromeTraceEvent::_internal_mutable_name() {
3001   _impl_._has_bits_[0] |= 0x00000001u;
3002   return _impl_.name_.Mutable(GetArenaForAllocation());
3003 }
release_name()3004 inline std::string* ChromeTraceEvent::release_name() {
3005   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.name)
3006   if (!_internal_has_name()) {
3007     return nullptr;
3008   }
3009   _impl_._has_bits_[0] &= ~0x00000001u;
3010   auto* p = _impl_.name_.Release();
3011 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3012   if (_impl_.name_.IsDefault()) {
3013     _impl_.name_.Set("", GetArenaForAllocation());
3014   }
3015 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3016   return p;
3017 }
set_allocated_name(std::string * name)3018 inline void ChromeTraceEvent::set_allocated_name(std::string* name) {
3019   if (name != nullptr) {
3020     _impl_._has_bits_[0] |= 0x00000001u;
3021   } else {
3022     _impl_._has_bits_[0] &= ~0x00000001u;
3023   }
3024   _impl_.name_.SetAllocated(name, GetArenaForAllocation());
3025 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3026   if (_impl_.name_.IsDefault()) {
3027     _impl_.name_.Set("", GetArenaForAllocation());
3028   }
3029 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3030   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.name)
3031 }
3032 
3033 // optional int64 timestamp = 2;
_internal_has_timestamp()3034 inline bool ChromeTraceEvent::_internal_has_timestamp() const {
3035   bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3036   return value;
3037 }
has_timestamp()3038 inline bool ChromeTraceEvent::has_timestamp() const {
3039   return _internal_has_timestamp();
3040 }
clear_timestamp()3041 inline void ChromeTraceEvent::clear_timestamp() {
3042   _impl_.timestamp_ = ::int64_t{0};
3043   _impl_._has_bits_[0] &= ~0x00000008u;
3044 }
_internal_timestamp()3045 inline ::int64_t ChromeTraceEvent::_internal_timestamp() const {
3046   return _impl_.timestamp_;
3047 }
timestamp()3048 inline ::int64_t ChromeTraceEvent::timestamp() const {
3049   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.timestamp)
3050   return _internal_timestamp();
3051 }
_internal_set_timestamp(::int64_t value)3052 inline void ChromeTraceEvent::_internal_set_timestamp(::int64_t value) {
3053   _impl_._has_bits_[0] |= 0x00000008u;
3054   _impl_.timestamp_ = value;
3055 }
set_timestamp(::int64_t value)3056 inline void ChromeTraceEvent::set_timestamp(::int64_t value) {
3057   _internal_set_timestamp(value);
3058   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.timestamp)
3059 }
3060 
3061 // optional int32 phase = 3;
_internal_has_phase()3062 inline bool ChromeTraceEvent::_internal_has_phase() const {
3063   bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
3064   return value;
3065 }
has_phase()3066 inline bool ChromeTraceEvent::has_phase() const {
3067   return _internal_has_phase();
3068 }
clear_phase()3069 inline void ChromeTraceEvent::clear_phase() {
3070   _impl_.phase_ = 0;
3071   _impl_._has_bits_[0] &= ~0x00000010u;
3072 }
_internal_phase()3073 inline ::int32_t ChromeTraceEvent::_internal_phase() const {
3074   return _impl_.phase_;
3075 }
phase()3076 inline ::int32_t ChromeTraceEvent::phase() const {
3077   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.phase)
3078   return _internal_phase();
3079 }
_internal_set_phase(::int32_t value)3080 inline void ChromeTraceEvent::_internal_set_phase(::int32_t value) {
3081   _impl_._has_bits_[0] |= 0x00000010u;
3082   _impl_.phase_ = value;
3083 }
set_phase(::int32_t value)3084 inline void ChromeTraceEvent::set_phase(::int32_t value) {
3085   _internal_set_phase(value);
3086   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.phase)
3087 }
3088 
3089 // optional int32 thread_id = 4;
_internal_has_thread_id()3090 inline bool ChromeTraceEvent::_internal_has_thread_id() const {
3091   bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
3092   return value;
3093 }
has_thread_id()3094 inline bool ChromeTraceEvent::has_thread_id() const {
3095   return _internal_has_thread_id();
3096 }
clear_thread_id()3097 inline void ChromeTraceEvent::clear_thread_id() {
3098   _impl_.thread_id_ = 0;
3099   _impl_._has_bits_[0] &= ~0x00000020u;
3100 }
_internal_thread_id()3101 inline ::int32_t ChromeTraceEvent::_internal_thread_id() const {
3102   return _impl_.thread_id_;
3103 }
thread_id()3104 inline ::int32_t ChromeTraceEvent::thread_id() const {
3105   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.thread_id)
3106   return _internal_thread_id();
3107 }
_internal_set_thread_id(::int32_t value)3108 inline void ChromeTraceEvent::_internal_set_thread_id(::int32_t value) {
3109   _impl_._has_bits_[0] |= 0x00000020u;
3110   _impl_.thread_id_ = value;
3111 }
set_thread_id(::int32_t value)3112 inline void ChromeTraceEvent::set_thread_id(::int32_t value) {
3113   _internal_set_thread_id(value);
3114   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.thread_id)
3115 }
3116 
3117 // optional int64 duration = 5;
_internal_has_duration()3118 inline bool ChromeTraceEvent::_internal_has_duration() const {
3119   bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
3120   return value;
3121 }
has_duration()3122 inline bool ChromeTraceEvent::has_duration() const {
3123   return _internal_has_duration();
3124 }
clear_duration()3125 inline void ChromeTraceEvent::clear_duration() {
3126   _impl_.duration_ = ::int64_t{0};
3127   _impl_._has_bits_[0] &= ~0x00000040u;
3128 }
_internal_duration()3129 inline ::int64_t ChromeTraceEvent::_internal_duration() const {
3130   return _impl_.duration_;
3131 }
duration()3132 inline ::int64_t ChromeTraceEvent::duration() const {
3133   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.duration)
3134   return _internal_duration();
3135 }
_internal_set_duration(::int64_t value)3136 inline void ChromeTraceEvent::_internal_set_duration(::int64_t value) {
3137   _impl_._has_bits_[0] |= 0x00000040u;
3138   _impl_.duration_ = value;
3139 }
set_duration(::int64_t value)3140 inline void ChromeTraceEvent::set_duration(::int64_t value) {
3141   _internal_set_duration(value);
3142   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.duration)
3143 }
3144 
3145 // optional int64 thread_duration = 6;
_internal_has_thread_duration()3146 inline bool ChromeTraceEvent::_internal_has_thread_duration() const {
3147   bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
3148   return value;
3149 }
has_thread_duration()3150 inline bool ChromeTraceEvent::has_thread_duration() const {
3151   return _internal_has_thread_duration();
3152 }
clear_thread_duration()3153 inline void ChromeTraceEvent::clear_thread_duration() {
3154   _impl_.thread_duration_ = ::int64_t{0};
3155   _impl_._has_bits_[0] &= ~0x00000080u;
3156 }
_internal_thread_duration()3157 inline ::int64_t ChromeTraceEvent::_internal_thread_duration() const {
3158   return _impl_.thread_duration_;
3159 }
thread_duration()3160 inline ::int64_t ChromeTraceEvent::thread_duration() const {
3161   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.thread_duration)
3162   return _internal_thread_duration();
3163 }
_internal_set_thread_duration(::int64_t value)3164 inline void ChromeTraceEvent::_internal_set_thread_duration(::int64_t value) {
3165   _impl_._has_bits_[0] |= 0x00000080u;
3166   _impl_.thread_duration_ = value;
3167 }
set_thread_duration(::int64_t value)3168 inline void ChromeTraceEvent::set_thread_duration(::int64_t value) {
3169   _internal_set_thread_duration(value);
3170   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.thread_duration)
3171 }
3172 
3173 // optional string scope = 7;
_internal_has_scope()3174 inline bool ChromeTraceEvent::_internal_has_scope() const {
3175   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3176   return value;
3177 }
has_scope()3178 inline bool ChromeTraceEvent::has_scope() const {
3179   return _internal_has_scope();
3180 }
clear_scope()3181 inline void ChromeTraceEvent::clear_scope() {
3182   _impl_.scope_.ClearToEmpty();
3183   _impl_._has_bits_[0] &= ~0x00000002u;
3184 }
scope()3185 inline const std::string& ChromeTraceEvent::scope() const {
3186   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.scope)
3187   return _internal_scope();
3188 }
3189 template <typename ArgT0, typename... ArgT>
3190 inline PROTOBUF_ALWAYS_INLINE
set_scope(ArgT0 && arg0,ArgT...args)3191 void ChromeTraceEvent::set_scope(ArgT0&& arg0, ArgT... args) {
3192  _impl_._has_bits_[0] |= 0x00000002u;
3193  _impl_.scope_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3194   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.scope)
3195 }
mutable_scope()3196 inline std::string* ChromeTraceEvent::mutable_scope() {
3197   std::string* _s = _internal_mutable_scope();
3198   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.scope)
3199   return _s;
3200 }
_internal_scope()3201 inline const std::string& ChromeTraceEvent::_internal_scope() const {
3202   return _impl_.scope_.Get();
3203 }
_internal_set_scope(const std::string & value)3204 inline void ChromeTraceEvent::_internal_set_scope(const std::string& value) {
3205   _impl_._has_bits_[0] |= 0x00000002u;
3206   _impl_.scope_.Set(value, GetArenaForAllocation());
3207 }
_internal_mutable_scope()3208 inline std::string* ChromeTraceEvent::_internal_mutable_scope() {
3209   _impl_._has_bits_[0] |= 0x00000002u;
3210   return _impl_.scope_.Mutable(GetArenaForAllocation());
3211 }
release_scope()3212 inline std::string* ChromeTraceEvent::release_scope() {
3213   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.scope)
3214   if (!_internal_has_scope()) {
3215     return nullptr;
3216   }
3217   _impl_._has_bits_[0] &= ~0x00000002u;
3218   auto* p = _impl_.scope_.Release();
3219 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3220   if (_impl_.scope_.IsDefault()) {
3221     _impl_.scope_.Set("", GetArenaForAllocation());
3222   }
3223 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3224   return p;
3225 }
set_allocated_scope(std::string * scope)3226 inline void ChromeTraceEvent::set_allocated_scope(std::string* scope) {
3227   if (scope != nullptr) {
3228     _impl_._has_bits_[0] |= 0x00000002u;
3229   } else {
3230     _impl_._has_bits_[0] &= ~0x00000002u;
3231   }
3232   _impl_.scope_.SetAllocated(scope, GetArenaForAllocation());
3233 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3234   if (_impl_.scope_.IsDefault()) {
3235     _impl_.scope_.Set("", GetArenaForAllocation());
3236   }
3237 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3238   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.scope)
3239 }
3240 
3241 // optional uint64 id = 8;
_internal_has_id()3242 inline bool ChromeTraceEvent::_internal_has_id() const {
3243   bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
3244   return value;
3245 }
has_id()3246 inline bool ChromeTraceEvent::has_id() const {
3247   return _internal_has_id();
3248 }
clear_id()3249 inline void ChromeTraceEvent::clear_id() {
3250   _impl_.id_ = ::uint64_t{0u};
3251   _impl_._has_bits_[0] &= ~0x00000100u;
3252 }
_internal_id()3253 inline ::uint64_t ChromeTraceEvent::_internal_id() const {
3254   return _impl_.id_;
3255 }
id()3256 inline ::uint64_t ChromeTraceEvent::id() const {
3257   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.id)
3258   return _internal_id();
3259 }
_internal_set_id(::uint64_t value)3260 inline void ChromeTraceEvent::_internal_set_id(::uint64_t value) {
3261   _impl_._has_bits_[0] |= 0x00000100u;
3262   _impl_.id_ = value;
3263 }
set_id(::uint64_t value)3264 inline void ChromeTraceEvent::set_id(::uint64_t value) {
3265   _internal_set_id(value);
3266   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.id)
3267 }
3268 
3269 // optional uint32 flags = 9;
_internal_has_flags()3270 inline bool ChromeTraceEvent::_internal_has_flags() const {
3271   bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
3272   return value;
3273 }
has_flags()3274 inline bool ChromeTraceEvent::has_flags() const {
3275   return _internal_has_flags();
3276 }
clear_flags()3277 inline void ChromeTraceEvent::clear_flags() {
3278   _impl_.flags_ = 0u;
3279   _impl_._has_bits_[0] &= ~0x00000200u;
3280 }
_internal_flags()3281 inline ::uint32_t ChromeTraceEvent::_internal_flags() const {
3282   return _impl_.flags_;
3283 }
flags()3284 inline ::uint32_t ChromeTraceEvent::flags() const {
3285   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.flags)
3286   return _internal_flags();
3287 }
_internal_set_flags(::uint32_t value)3288 inline void ChromeTraceEvent::_internal_set_flags(::uint32_t value) {
3289   _impl_._has_bits_[0] |= 0x00000200u;
3290   _impl_.flags_ = value;
3291 }
set_flags(::uint32_t value)3292 inline void ChromeTraceEvent::set_flags(::uint32_t value) {
3293   _internal_set_flags(value);
3294   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.flags)
3295 }
3296 
3297 // optional string category_group_name = 10;
_internal_has_category_group_name()3298 inline bool ChromeTraceEvent::_internal_has_category_group_name() const {
3299   bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3300   return value;
3301 }
has_category_group_name()3302 inline bool ChromeTraceEvent::has_category_group_name() const {
3303   return _internal_has_category_group_name();
3304 }
clear_category_group_name()3305 inline void ChromeTraceEvent::clear_category_group_name() {
3306   _impl_.category_group_name_.ClearToEmpty();
3307   _impl_._has_bits_[0] &= ~0x00000004u;
3308 }
category_group_name()3309 inline const std::string& ChromeTraceEvent::category_group_name() const {
3310   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.category_group_name)
3311   return _internal_category_group_name();
3312 }
3313 template <typename ArgT0, typename... ArgT>
3314 inline PROTOBUF_ALWAYS_INLINE
set_category_group_name(ArgT0 && arg0,ArgT...args)3315 void ChromeTraceEvent::set_category_group_name(ArgT0&& arg0, ArgT... args) {
3316  _impl_._has_bits_[0] |= 0x00000004u;
3317  _impl_.category_group_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3318   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.category_group_name)
3319 }
mutable_category_group_name()3320 inline std::string* ChromeTraceEvent::mutable_category_group_name() {
3321   std::string* _s = _internal_mutable_category_group_name();
3322   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.category_group_name)
3323   return _s;
3324 }
_internal_category_group_name()3325 inline const std::string& ChromeTraceEvent::_internal_category_group_name() const {
3326   return _impl_.category_group_name_.Get();
3327 }
_internal_set_category_group_name(const std::string & value)3328 inline void ChromeTraceEvent::_internal_set_category_group_name(const std::string& value) {
3329   _impl_._has_bits_[0] |= 0x00000004u;
3330   _impl_.category_group_name_.Set(value, GetArenaForAllocation());
3331 }
_internal_mutable_category_group_name()3332 inline std::string* ChromeTraceEvent::_internal_mutable_category_group_name() {
3333   _impl_._has_bits_[0] |= 0x00000004u;
3334   return _impl_.category_group_name_.Mutable(GetArenaForAllocation());
3335 }
release_category_group_name()3336 inline std::string* ChromeTraceEvent::release_category_group_name() {
3337   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeTraceEvent.category_group_name)
3338   if (!_internal_has_category_group_name()) {
3339     return nullptr;
3340   }
3341   _impl_._has_bits_[0] &= ~0x00000004u;
3342   auto* p = _impl_.category_group_name_.Release();
3343 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3344   if (_impl_.category_group_name_.IsDefault()) {
3345     _impl_.category_group_name_.Set("", GetArenaForAllocation());
3346   }
3347 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3348   return p;
3349 }
set_allocated_category_group_name(std::string * category_group_name)3350 inline void ChromeTraceEvent::set_allocated_category_group_name(std::string* category_group_name) {
3351   if (category_group_name != nullptr) {
3352     _impl_._has_bits_[0] |= 0x00000004u;
3353   } else {
3354     _impl_._has_bits_[0] &= ~0x00000004u;
3355   }
3356   _impl_.category_group_name_.SetAllocated(category_group_name, GetArenaForAllocation());
3357 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3358   if (_impl_.category_group_name_.IsDefault()) {
3359     _impl_.category_group_name_.Set("", GetArenaForAllocation());
3360   }
3361 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3362   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.category_group_name)
3363 }
3364 
3365 // optional int32 process_id = 11;
_internal_has_process_id()3366 inline bool ChromeTraceEvent::_internal_has_process_id() const {
3367   bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
3368   return value;
3369 }
has_process_id()3370 inline bool ChromeTraceEvent::has_process_id() const {
3371   return _internal_has_process_id();
3372 }
clear_process_id()3373 inline void ChromeTraceEvent::clear_process_id() {
3374   _impl_.process_id_ = 0;
3375   _impl_._has_bits_[0] &= ~0x00000400u;
3376 }
_internal_process_id()3377 inline ::int32_t ChromeTraceEvent::_internal_process_id() const {
3378   return _impl_.process_id_;
3379 }
process_id()3380 inline ::int32_t ChromeTraceEvent::process_id() const {
3381   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.process_id)
3382   return _internal_process_id();
3383 }
_internal_set_process_id(::int32_t value)3384 inline void ChromeTraceEvent::_internal_set_process_id(::int32_t value) {
3385   _impl_._has_bits_[0] |= 0x00000400u;
3386   _impl_.process_id_ = value;
3387 }
set_process_id(::int32_t value)3388 inline void ChromeTraceEvent::set_process_id(::int32_t value) {
3389   _internal_set_process_id(value);
3390   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.process_id)
3391 }
3392 
3393 // optional int64 thread_timestamp = 12;
_internal_has_thread_timestamp()3394 inline bool ChromeTraceEvent::_internal_has_thread_timestamp() const {
3395   bool value = (_impl_._has_bits_[0] & 0x00000800u) != 0;
3396   return value;
3397 }
has_thread_timestamp()3398 inline bool ChromeTraceEvent::has_thread_timestamp() const {
3399   return _internal_has_thread_timestamp();
3400 }
clear_thread_timestamp()3401 inline void ChromeTraceEvent::clear_thread_timestamp() {
3402   _impl_.thread_timestamp_ = ::int64_t{0};
3403   _impl_._has_bits_[0] &= ~0x00000800u;
3404 }
_internal_thread_timestamp()3405 inline ::int64_t ChromeTraceEvent::_internal_thread_timestamp() const {
3406   return _impl_.thread_timestamp_;
3407 }
thread_timestamp()3408 inline ::int64_t ChromeTraceEvent::thread_timestamp() const {
3409   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.thread_timestamp)
3410   return _internal_thread_timestamp();
3411 }
_internal_set_thread_timestamp(::int64_t value)3412 inline void ChromeTraceEvent::_internal_set_thread_timestamp(::int64_t value) {
3413   _impl_._has_bits_[0] |= 0x00000800u;
3414   _impl_.thread_timestamp_ = value;
3415 }
set_thread_timestamp(::int64_t value)3416 inline void ChromeTraceEvent::set_thread_timestamp(::int64_t value) {
3417   _internal_set_thread_timestamp(value);
3418   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.thread_timestamp)
3419 }
3420 
3421 // optional uint64 bind_id = 13;
_internal_has_bind_id()3422 inline bool ChromeTraceEvent::_internal_has_bind_id() const {
3423   bool value = (_impl_._has_bits_[0] & 0x00001000u) != 0;
3424   return value;
3425 }
has_bind_id()3426 inline bool ChromeTraceEvent::has_bind_id() const {
3427   return _internal_has_bind_id();
3428 }
clear_bind_id()3429 inline void ChromeTraceEvent::clear_bind_id() {
3430   _impl_.bind_id_ = ::uint64_t{0u};
3431   _impl_._has_bits_[0] &= ~0x00001000u;
3432 }
_internal_bind_id()3433 inline ::uint64_t ChromeTraceEvent::_internal_bind_id() const {
3434   return _impl_.bind_id_;
3435 }
bind_id()3436 inline ::uint64_t ChromeTraceEvent::bind_id() const {
3437   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.bind_id)
3438   return _internal_bind_id();
3439 }
_internal_set_bind_id(::uint64_t value)3440 inline void ChromeTraceEvent::_internal_set_bind_id(::uint64_t value) {
3441   _impl_._has_bits_[0] |= 0x00001000u;
3442   _impl_.bind_id_ = value;
3443 }
set_bind_id(::uint64_t value)3444 inline void ChromeTraceEvent::set_bind_id(::uint64_t value) {
3445   _internal_set_bind_id(value);
3446   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.bind_id)
3447 }
3448 
3449 // repeated .perfetto.protos.ChromeTraceEvent.Arg args = 14;
_internal_args_size()3450 inline int ChromeTraceEvent::_internal_args_size() const {
3451   return _impl_.args_.size();
3452 }
args_size()3453 inline int ChromeTraceEvent::args_size() const {
3454   return _internal_args_size();
3455 }
clear_args()3456 inline void ChromeTraceEvent::clear_args() {
3457   _impl_.args_.Clear();
3458 }
mutable_args(int index)3459 inline ::perfetto::protos::ChromeTraceEvent_Arg* ChromeTraceEvent::mutable_args(int index) {
3460   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeTraceEvent.args)
3461   return _impl_.args_.Mutable(index);
3462 }
3463 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent_Arg >*
mutable_args()3464 ChromeTraceEvent::mutable_args() {
3465   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeTraceEvent.args)
3466   return &_impl_.args_;
3467 }
_internal_args(int index)3468 inline const ::perfetto::protos::ChromeTraceEvent_Arg& ChromeTraceEvent::_internal_args(int index) const {
3469   return _impl_.args_.Get(index);
3470 }
args(int index)3471 inline const ::perfetto::protos::ChromeTraceEvent_Arg& ChromeTraceEvent::args(int index) const {
3472   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.args)
3473   return _internal_args(index);
3474 }
_internal_add_args()3475 inline ::perfetto::protos::ChromeTraceEvent_Arg* ChromeTraceEvent::_internal_add_args() {
3476   return _impl_.args_.Add();
3477 }
add_args()3478 inline ::perfetto::protos::ChromeTraceEvent_Arg* ChromeTraceEvent::add_args() {
3479   ::perfetto::protos::ChromeTraceEvent_Arg* _add = _internal_add_args();
3480   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeTraceEvent.args)
3481   return _add;
3482 }
3483 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent_Arg >&
args()3484 ChromeTraceEvent::args() const {
3485   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeTraceEvent.args)
3486   return _impl_.args_;
3487 }
3488 
3489 // optional uint32 name_index = 15;
_internal_has_name_index()3490 inline bool ChromeTraceEvent::_internal_has_name_index() const {
3491   bool value = (_impl_._has_bits_[0] & 0x00002000u) != 0;
3492   return value;
3493 }
has_name_index()3494 inline bool ChromeTraceEvent::has_name_index() const {
3495   return _internal_has_name_index();
3496 }
clear_name_index()3497 inline void ChromeTraceEvent::clear_name_index() {
3498   _impl_.name_index_ = 0u;
3499   _impl_._has_bits_[0] &= ~0x00002000u;
3500 }
_internal_name_index()3501 inline ::uint32_t ChromeTraceEvent::_internal_name_index() const {
3502   return _impl_.name_index_;
3503 }
name_index()3504 inline ::uint32_t ChromeTraceEvent::name_index() const {
3505   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.name_index)
3506   return _internal_name_index();
3507 }
_internal_set_name_index(::uint32_t value)3508 inline void ChromeTraceEvent::_internal_set_name_index(::uint32_t value) {
3509   _impl_._has_bits_[0] |= 0x00002000u;
3510   _impl_.name_index_ = value;
3511 }
set_name_index(::uint32_t value)3512 inline void ChromeTraceEvent::set_name_index(::uint32_t value) {
3513   _internal_set_name_index(value);
3514   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.name_index)
3515 }
3516 
3517 // optional uint32 category_group_name_index = 16;
_internal_has_category_group_name_index()3518 inline bool ChromeTraceEvent::_internal_has_category_group_name_index() const {
3519   bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
3520   return value;
3521 }
has_category_group_name_index()3522 inline bool ChromeTraceEvent::has_category_group_name_index() const {
3523   return _internal_has_category_group_name_index();
3524 }
clear_category_group_name_index()3525 inline void ChromeTraceEvent::clear_category_group_name_index() {
3526   _impl_.category_group_name_index_ = 0u;
3527   _impl_._has_bits_[0] &= ~0x00004000u;
3528 }
_internal_category_group_name_index()3529 inline ::uint32_t ChromeTraceEvent::_internal_category_group_name_index() const {
3530   return _impl_.category_group_name_index_;
3531 }
category_group_name_index()3532 inline ::uint32_t ChromeTraceEvent::category_group_name_index() const {
3533   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeTraceEvent.category_group_name_index)
3534   return _internal_category_group_name_index();
3535 }
_internal_set_category_group_name_index(::uint32_t value)3536 inline void ChromeTraceEvent::_internal_set_category_group_name_index(::uint32_t value) {
3537   _impl_._has_bits_[0] |= 0x00004000u;
3538   _impl_.category_group_name_index_ = value;
3539 }
set_category_group_name_index(::uint32_t value)3540 inline void ChromeTraceEvent::set_category_group_name_index(::uint32_t value) {
3541   _internal_set_category_group_name_index(value);
3542   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeTraceEvent.category_group_name_index)
3543 }
3544 
3545 // -------------------------------------------------------------------
3546 
3547 // ChromeMetadata
3548 
3549 // optional string name = 1;
_internal_has_name()3550 inline bool ChromeMetadata::_internal_has_name() const {
3551   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3552   return value;
3553 }
has_name()3554 inline bool ChromeMetadata::has_name() const {
3555   return _internal_has_name();
3556 }
clear_name()3557 inline void ChromeMetadata::clear_name() {
3558   _impl_.name_.ClearToEmpty();
3559   _impl_._has_bits_[0] &= ~0x00000001u;
3560 }
name()3561 inline const std::string& ChromeMetadata::name() const {
3562   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadata.name)
3563   return _internal_name();
3564 }
3565 template <typename ArgT0, typename... ArgT>
3566 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)3567 void ChromeMetadata::set_name(ArgT0&& arg0, ArgT... args) {
3568  _impl_._has_bits_[0] |= 0x00000001u;
3569  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3570   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadata.name)
3571 }
mutable_name()3572 inline std::string* ChromeMetadata::mutable_name() {
3573   std::string* _s = _internal_mutable_name();
3574   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeMetadata.name)
3575   return _s;
3576 }
_internal_name()3577 inline const std::string& ChromeMetadata::_internal_name() const {
3578   return _impl_.name_.Get();
3579 }
_internal_set_name(const std::string & value)3580 inline void ChromeMetadata::_internal_set_name(const std::string& value) {
3581   _impl_._has_bits_[0] |= 0x00000001u;
3582   _impl_.name_.Set(value, GetArenaForAllocation());
3583 }
_internal_mutable_name()3584 inline std::string* ChromeMetadata::_internal_mutable_name() {
3585   _impl_._has_bits_[0] |= 0x00000001u;
3586   return _impl_.name_.Mutable(GetArenaForAllocation());
3587 }
release_name()3588 inline std::string* ChromeMetadata::release_name() {
3589   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeMetadata.name)
3590   if (!_internal_has_name()) {
3591     return nullptr;
3592   }
3593   _impl_._has_bits_[0] &= ~0x00000001u;
3594   auto* p = _impl_.name_.Release();
3595 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3596   if (_impl_.name_.IsDefault()) {
3597     _impl_.name_.Set("", GetArenaForAllocation());
3598   }
3599 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3600   return p;
3601 }
set_allocated_name(std::string * name)3602 inline void ChromeMetadata::set_allocated_name(std::string* name) {
3603   if (name != nullptr) {
3604     _impl_._has_bits_[0] |= 0x00000001u;
3605   } else {
3606     _impl_._has_bits_[0] &= ~0x00000001u;
3607   }
3608   _impl_.name_.SetAllocated(name, GetArenaForAllocation());
3609 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3610   if (_impl_.name_.IsDefault()) {
3611     _impl_.name_.Set("", GetArenaForAllocation());
3612   }
3613 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3614   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeMetadata.name)
3615 }
3616 
3617 // string string_value = 2;
_internal_has_string_value()3618 inline bool ChromeMetadata::_internal_has_string_value() const {
3619   return value_case() == kStringValue;
3620 }
has_string_value()3621 inline bool ChromeMetadata::has_string_value() const {
3622   return _internal_has_string_value();
3623 }
set_has_string_value()3624 inline void ChromeMetadata::set_has_string_value() {
3625   _impl_._oneof_case_[0] = kStringValue;
3626 }
clear_string_value()3627 inline void ChromeMetadata::clear_string_value() {
3628   if (_internal_has_string_value()) {
3629     _impl_.value_.string_value_.Destroy();
3630     clear_has_value();
3631   }
3632 }
string_value()3633 inline const std::string& ChromeMetadata::string_value() const {
3634   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadata.string_value)
3635   return _internal_string_value();
3636 }
3637 template <typename ArgT0, typename... ArgT>
set_string_value(ArgT0 && arg0,ArgT...args)3638 inline void ChromeMetadata::set_string_value(ArgT0&& arg0, ArgT... args) {
3639   if (!_internal_has_string_value()) {
3640     clear_value();
3641     set_has_string_value();
3642     _impl_.value_.string_value_.InitDefault();
3643   }
3644   _impl_.value_.string_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3645   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadata.string_value)
3646 }
mutable_string_value()3647 inline std::string* ChromeMetadata::mutable_string_value() {
3648   std::string* _s = _internal_mutable_string_value();
3649   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeMetadata.string_value)
3650   return _s;
3651 }
_internal_string_value()3652 inline const std::string& ChromeMetadata::_internal_string_value() const {
3653   if (_internal_has_string_value()) {
3654     return _impl_.value_.string_value_.Get();
3655   }
3656   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3657 }
_internal_set_string_value(const std::string & value)3658 inline void ChromeMetadata::_internal_set_string_value(const std::string& value) {
3659   if (!_internal_has_string_value()) {
3660     clear_value();
3661     set_has_string_value();
3662     _impl_.value_.string_value_.InitDefault();
3663   }
3664   _impl_.value_.string_value_.Set(value, GetArenaForAllocation());
3665 }
_internal_mutable_string_value()3666 inline std::string* ChromeMetadata::_internal_mutable_string_value() {
3667   if (!_internal_has_string_value()) {
3668     clear_value();
3669     set_has_string_value();
3670     _impl_.value_.string_value_.InitDefault();
3671   }
3672   return _impl_.value_.string_value_.Mutable(      GetArenaForAllocation());
3673 }
release_string_value()3674 inline std::string* ChromeMetadata::release_string_value() {
3675   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeMetadata.string_value)
3676   if (_internal_has_string_value()) {
3677     clear_has_value();
3678     return _impl_.value_.string_value_.Release();
3679   } else {
3680     return nullptr;
3681   }
3682 }
set_allocated_string_value(std::string * string_value)3683 inline void ChromeMetadata::set_allocated_string_value(std::string* string_value) {
3684   if (has_value()) {
3685     clear_value();
3686   }
3687   if (string_value != nullptr) {
3688     set_has_string_value();
3689     _impl_.value_.string_value_.InitAllocated(string_value, GetArenaForAllocation());
3690   }
3691   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeMetadata.string_value)
3692 }
3693 
3694 // bool bool_value = 3;
_internal_has_bool_value()3695 inline bool ChromeMetadata::_internal_has_bool_value() const {
3696   return value_case() == kBoolValue;
3697 }
has_bool_value()3698 inline bool ChromeMetadata::has_bool_value() const {
3699   return _internal_has_bool_value();
3700 }
set_has_bool_value()3701 inline void ChromeMetadata::set_has_bool_value() {
3702   _impl_._oneof_case_[0] = kBoolValue;
3703 }
clear_bool_value()3704 inline void ChromeMetadata::clear_bool_value() {
3705   if (_internal_has_bool_value()) {
3706     _impl_.value_.bool_value_ = false;
3707     clear_has_value();
3708   }
3709 }
_internal_bool_value()3710 inline bool ChromeMetadata::_internal_bool_value() const {
3711   if (_internal_has_bool_value()) {
3712     return _impl_.value_.bool_value_;
3713   }
3714   return false;
3715 }
_internal_set_bool_value(bool value)3716 inline void ChromeMetadata::_internal_set_bool_value(bool value) {
3717   if (!_internal_has_bool_value()) {
3718     clear_value();
3719     set_has_bool_value();
3720   }
3721   _impl_.value_.bool_value_ = value;
3722 }
bool_value()3723 inline bool ChromeMetadata::bool_value() const {
3724   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadata.bool_value)
3725   return _internal_bool_value();
3726 }
set_bool_value(bool value)3727 inline void ChromeMetadata::set_bool_value(bool value) {
3728   _internal_set_bool_value(value);
3729   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadata.bool_value)
3730 }
3731 
3732 // int64 int_value = 4;
_internal_has_int_value()3733 inline bool ChromeMetadata::_internal_has_int_value() const {
3734   return value_case() == kIntValue;
3735 }
has_int_value()3736 inline bool ChromeMetadata::has_int_value() const {
3737   return _internal_has_int_value();
3738 }
set_has_int_value()3739 inline void ChromeMetadata::set_has_int_value() {
3740   _impl_._oneof_case_[0] = kIntValue;
3741 }
clear_int_value()3742 inline void ChromeMetadata::clear_int_value() {
3743   if (_internal_has_int_value()) {
3744     _impl_.value_.int_value_ = ::int64_t{0};
3745     clear_has_value();
3746   }
3747 }
_internal_int_value()3748 inline ::int64_t ChromeMetadata::_internal_int_value() const {
3749   if (_internal_has_int_value()) {
3750     return _impl_.value_.int_value_;
3751   }
3752   return ::int64_t{0};
3753 }
_internal_set_int_value(::int64_t value)3754 inline void ChromeMetadata::_internal_set_int_value(::int64_t value) {
3755   if (!_internal_has_int_value()) {
3756     clear_value();
3757     set_has_int_value();
3758   }
3759   _impl_.value_.int_value_ = value;
3760 }
int_value()3761 inline ::int64_t ChromeMetadata::int_value() const {
3762   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadata.int_value)
3763   return _internal_int_value();
3764 }
set_int_value(::int64_t value)3765 inline void ChromeMetadata::set_int_value(::int64_t value) {
3766   _internal_set_int_value(value);
3767   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadata.int_value)
3768 }
3769 
3770 // string json_value = 5;
_internal_has_json_value()3771 inline bool ChromeMetadata::_internal_has_json_value() const {
3772   return value_case() == kJsonValue;
3773 }
has_json_value()3774 inline bool ChromeMetadata::has_json_value() const {
3775   return _internal_has_json_value();
3776 }
set_has_json_value()3777 inline void ChromeMetadata::set_has_json_value() {
3778   _impl_._oneof_case_[0] = kJsonValue;
3779 }
clear_json_value()3780 inline void ChromeMetadata::clear_json_value() {
3781   if (_internal_has_json_value()) {
3782     _impl_.value_.json_value_.Destroy();
3783     clear_has_value();
3784   }
3785 }
json_value()3786 inline const std::string& ChromeMetadata::json_value() const {
3787   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadata.json_value)
3788   return _internal_json_value();
3789 }
3790 template <typename ArgT0, typename... ArgT>
set_json_value(ArgT0 && arg0,ArgT...args)3791 inline void ChromeMetadata::set_json_value(ArgT0&& arg0, ArgT... args) {
3792   if (!_internal_has_json_value()) {
3793     clear_value();
3794     set_has_json_value();
3795     _impl_.value_.json_value_.InitDefault();
3796   }
3797   _impl_.value_.json_value_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3798   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadata.json_value)
3799 }
mutable_json_value()3800 inline std::string* ChromeMetadata::mutable_json_value() {
3801   std::string* _s = _internal_mutable_json_value();
3802   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeMetadata.json_value)
3803   return _s;
3804 }
_internal_json_value()3805 inline const std::string& ChromeMetadata::_internal_json_value() const {
3806   if (_internal_has_json_value()) {
3807     return _impl_.value_.json_value_.Get();
3808   }
3809   return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3810 }
_internal_set_json_value(const std::string & value)3811 inline void ChromeMetadata::_internal_set_json_value(const std::string& value) {
3812   if (!_internal_has_json_value()) {
3813     clear_value();
3814     set_has_json_value();
3815     _impl_.value_.json_value_.InitDefault();
3816   }
3817   _impl_.value_.json_value_.Set(value, GetArenaForAllocation());
3818 }
_internal_mutable_json_value()3819 inline std::string* ChromeMetadata::_internal_mutable_json_value() {
3820   if (!_internal_has_json_value()) {
3821     clear_value();
3822     set_has_json_value();
3823     _impl_.value_.json_value_.InitDefault();
3824   }
3825   return _impl_.value_.json_value_.Mutable(      GetArenaForAllocation());
3826 }
release_json_value()3827 inline std::string* ChromeMetadata::release_json_value() {
3828   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeMetadata.json_value)
3829   if (_internal_has_json_value()) {
3830     clear_has_value();
3831     return _impl_.value_.json_value_.Release();
3832   } else {
3833     return nullptr;
3834   }
3835 }
set_allocated_json_value(std::string * json_value)3836 inline void ChromeMetadata::set_allocated_json_value(std::string* json_value) {
3837   if (has_value()) {
3838     clear_value();
3839   }
3840   if (json_value != nullptr) {
3841     set_has_json_value();
3842     _impl_.value_.json_value_.InitAllocated(json_value, GetArenaForAllocation());
3843   }
3844   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeMetadata.json_value)
3845 }
3846 
has_value()3847 inline bool ChromeMetadata::has_value() const {
3848   return value_case() != VALUE_NOT_SET;
3849 }
clear_has_value()3850 inline void ChromeMetadata::clear_has_value() {
3851   _impl_._oneof_case_[0] = VALUE_NOT_SET;
3852 }
value_case()3853 inline ChromeMetadata::ValueCase ChromeMetadata::value_case() const {
3854   return ChromeMetadata::ValueCase(_impl_._oneof_case_[0]);
3855 }
3856 // -------------------------------------------------------------------
3857 
3858 // ChromeLegacyJsonTrace
3859 
3860 // optional .perfetto.protos.ChromeLegacyJsonTrace.TraceType type = 1;
_internal_has_type()3861 inline bool ChromeLegacyJsonTrace::_internal_has_type() const {
3862   bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3863   return value;
3864 }
has_type()3865 inline bool ChromeLegacyJsonTrace::has_type() const {
3866   return _internal_has_type();
3867 }
clear_type()3868 inline void ChromeLegacyJsonTrace::clear_type() {
3869   _impl_.type_ = 0;
3870   _impl_._has_bits_[0] &= ~0x00000002u;
3871 }
_internal_type()3872 inline ::perfetto::protos::ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace::_internal_type() const {
3873   return static_cast< ::perfetto::protos::ChromeLegacyJsonTrace_TraceType >(_impl_.type_);
3874 }
type()3875 inline ::perfetto::protos::ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace::type() const {
3876   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeLegacyJsonTrace.type)
3877   return _internal_type();
3878 }
_internal_set_type(::perfetto::protos::ChromeLegacyJsonTrace_TraceType value)3879 inline void ChromeLegacyJsonTrace::_internal_set_type(::perfetto::protos::ChromeLegacyJsonTrace_TraceType value) {
3880   assert(::perfetto::protos::ChromeLegacyJsonTrace_TraceType_IsValid(value));
3881   _impl_._has_bits_[0] |= 0x00000002u;
3882   _impl_.type_ = value;
3883 }
set_type(::perfetto::protos::ChromeLegacyJsonTrace_TraceType value)3884 inline void ChromeLegacyJsonTrace::set_type(::perfetto::protos::ChromeLegacyJsonTrace_TraceType value) {
3885   _internal_set_type(value);
3886   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeLegacyJsonTrace.type)
3887 }
3888 
3889 // optional string data = 2;
_internal_has_data()3890 inline bool ChromeLegacyJsonTrace::_internal_has_data() const {
3891   bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3892   return value;
3893 }
has_data()3894 inline bool ChromeLegacyJsonTrace::has_data() const {
3895   return _internal_has_data();
3896 }
clear_data()3897 inline void ChromeLegacyJsonTrace::clear_data() {
3898   _impl_.data_.ClearToEmpty();
3899   _impl_._has_bits_[0] &= ~0x00000001u;
3900 }
data()3901 inline const std::string& ChromeLegacyJsonTrace::data() const {
3902   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeLegacyJsonTrace.data)
3903   return _internal_data();
3904 }
3905 template <typename ArgT0, typename... ArgT>
3906 inline PROTOBUF_ALWAYS_INLINE
set_data(ArgT0 && arg0,ArgT...args)3907 void ChromeLegacyJsonTrace::set_data(ArgT0&& arg0, ArgT... args) {
3908  _impl_._has_bits_[0] |= 0x00000001u;
3909  _impl_.data_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3910   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeLegacyJsonTrace.data)
3911 }
mutable_data()3912 inline std::string* ChromeLegacyJsonTrace::mutable_data() {
3913   std::string* _s = _internal_mutable_data();
3914   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeLegacyJsonTrace.data)
3915   return _s;
3916 }
_internal_data()3917 inline const std::string& ChromeLegacyJsonTrace::_internal_data() const {
3918   return _impl_.data_.Get();
3919 }
_internal_set_data(const std::string & value)3920 inline void ChromeLegacyJsonTrace::_internal_set_data(const std::string& value) {
3921   _impl_._has_bits_[0] |= 0x00000001u;
3922   _impl_.data_.Set(value, GetArenaForAllocation());
3923 }
_internal_mutable_data()3924 inline std::string* ChromeLegacyJsonTrace::_internal_mutable_data() {
3925   _impl_._has_bits_[0] |= 0x00000001u;
3926   return _impl_.data_.Mutable(GetArenaForAllocation());
3927 }
release_data()3928 inline std::string* ChromeLegacyJsonTrace::release_data() {
3929   // @@protoc_insertion_point(field_release:perfetto.protos.ChromeLegacyJsonTrace.data)
3930   if (!_internal_has_data()) {
3931     return nullptr;
3932   }
3933   _impl_._has_bits_[0] &= ~0x00000001u;
3934   auto* p = _impl_.data_.Release();
3935 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3936   if (_impl_.data_.IsDefault()) {
3937     _impl_.data_.Set("", GetArenaForAllocation());
3938   }
3939 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3940   return p;
3941 }
set_allocated_data(std::string * data)3942 inline void ChromeLegacyJsonTrace::set_allocated_data(std::string* data) {
3943   if (data != nullptr) {
3944     _impl_._has_bits_[0] |= 0x00000001u;
3945   } else {
3946     _impl_._has_bits_[0] &= ~0x00000001u;
3947   }
3948   _impl_.data_.SetAllocated(data, GetArenaForAllocation());
3949 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3950   if (_impl_.data_.IsDefault()) {
3951     _impl_.data_.Set("", GetArenaForAllocation());
3952   }
3953 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3954   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeLegacyJsonTrace.data)
3955 }
3956 
3957 // -------------------------------------------------------------------
3958 
3959 // ChromeEventBundle
3960 
3961 // repeated .perfetto.protos.ChromeTraceEvent trace_events = 1 [deprecated = true];
_internal_trace_events_size()3962 inline int ChromeEventBundle::_internal_trace_events_size() const {
3963   return _impl_.trace_events_.size();
3964 }
trace_events_size()3965 inline int ChromeEventBundle::trace_events_size() const {
3966   return _internal_trace_events_size();
3967 }
clear_trace_events()3968 inline void ChromeEventBundle::clear_trace_events() {
3969   _impl_.trace_events_.Clear();
3970 }
mutable_trace_events(int index)3971 inline ::perfetto::protos::ChromeTraceEvent* ChromeEventBundle::mutable_trace_events(int index) {
3972   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeEventBundle.trace_events)
3973   return _impl_.trace_events_.Mutable(index);
3974 }
3975 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent >*
mutable_trace_events()3976 ChromeEventBundle::mutable_trace_events() {
3977   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeEventBundle.trace_events)
3978   return &_impl_.trace_events_;
3979 }
_internal_trace_events(int index)3980 inline const ::perfetto::protos::ChromeTraceEvent& ChromeEventBundle::_internal_trace_events(int index) const {
3981   return _impl_.trace_events_.Get(index);
3982 }
trace_events(int index)3983 inline const ::perfetto::protos::ChromeTraceEvent& ChromeEventBundle::trace_events(int index) const {
3984   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeEventBundle.trace_events)
3985   return _internal_trace_events(index);
3986 }
_internal_add_trace_events()3987 inline ::perfetto::protos::ChromeTraceEvent* ChromeEventBundle::_internal_add_trace_events() {
3988   return _impl_.trace_events_.Add();
3989 }
add_trace_events()3990 inline ::perfetto::protos::ChromeTraceEvent* ChromeEventBundle::add_trace_events() {
3991   ::perfetto::protos::ChromeTraceEvent* _add = _internal_add_trace_events();
3992   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeEventBundle.trace_events)
3993   return _add;
3994 }
3995 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeTraceEvent >&
trace_events()3996 ChromeEventBundle::trace_events() const {
3997   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeEventBundle.trace_events)
3998   return _impl_.trace_events_;
3999 }
4000 
4001 // repeated .perfetto.protos.ChromeMetadata metadata = 2;
_internal_metadata_size()4002 inline int ChromeEventBundle::_internal_metadata_size() const {
4003   return _impl_.metadata_.size();
4004 }
metadata_size()4005 inline int ChromeEventBundle::metadata_size() const {
4006   return _internal_metadata_size();
4007 }
clear_metadata()4008 inline void ChromeEventBundle::clear_metadata() {
4009   _impl_.metadata_.Clear();
4010 }
mutable_metadata(int index)4011 inline ::perfetto::protos::ChromeMetadata* ChromeEventBundle::mutable_metadata(int index) {
4012   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeEventBundle.metadata)
4013   return _impl_.metadata_.Mutable(index);
4014 }
4015 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadata >*
mutable_metadata()4016 ChromeEventBundle::mutable_metadata() {
4017   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeEventBundle.metadata)
4018   return &_impl_.metadata_;
4019 }
_internal_metadata(int index)4020 inline const ::perfetto::protos::ChromeMetadata& ChromeEventBundle::_internal_metadata(int index) const {
4021   return _impl_.metadata_.Get(index);
4022 }
metadata(int index)4023 inline const ::perfetto::protos::ChromeMetadata& ChromeEventBundle::metadata(int index) const {
4024   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeEventBundle.metadata)
4025   return _internal_metadata(index);
4026 }
_internal_add_metadata()4027 inline ::perfetto::protos::ChromeMetadata* ChromeEventBundle::_internal_add_metadata() {
4028   return _impl_.metadata_.Add();
4029 }
add_metadata()4030 inline ::perfetto::protos::ChromeMetadata* ChromeEventBundle::add_metadata() {
4031   ::perfetto::protos::ChromeMetadata* _add = _internal_add_metadata();
4032   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeEventBundle.metadata)
4033   return _add;
4034 }
4035 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadata >&
metadata()4036 ChromeEventBundle::metadata() const {
4037   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeEventBundle.metadata)
4038   return _impl_.metadata_;
4039 }
4040 
4041 // repeated string legacy_ftrace_output = 4;
_internal_legacy_ftrace_output_size()4042 inline int ChromeEventBundle::_internal_legacy_ftrace_output_size() const {
4043   return _impl_.legacy_ftrace_output_.size();
4044 }
legacy_ftrace_output_size()4045 inline int ChromeEventBundle::legacy_ftrace_output_size() const {
4046   return _internal_legacy_ftrace_output_size();
4047 }
clear_legacy_ftrace_output()4048 inline void ChromeEventBundle::clear_legacy_ftrace_output() {
4049   _impl_.legacy_ftrace_output_.Clear();
4050 }
add_legacy_ftrace_output()4051 inline std::string* ChromeEventBundle::add_legacy_ftrace_output() {
4052   std::string* _s = _internal_add_legacy_ftrace_output();
4053   // @@protoc_insertion_point(field_add_mutable:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4054   return _s;
4055 }
_internal_legacy_ftrace_output(int index)4056 inline const std::string& ChromeEventBundle::_internal_legacy_ftrace_output(int index) const {
4057   return _impl_.legacy_ftrace_output_.Get(index);
4058 }
legacy_ftrace_output(int index)4059 inline const std::string& ChromeEventBundle::legacy_ftrace_output(int index) const {
4060   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4061   return _internal_legacy_ftrace_output(index);
4062 }
mutable_legacy_ftrace_output(int index)4063 inline std::string* ChromeEventBundle::mutable_legacy_ftrace_output(int index) {
4064   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4065   return _impl_.legacy_ftrace_output_.Mutable(index);
4066 }
set_legacy_ftrace_output(int index,const std::string & value)4067 inline void ChromeEventBundle::set_legacy_ftrace_output(int index, const std::string& value) {
4068   _impl_.legacy_ftrace_output_.Mutable(index)->assign(value);
4069   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4070 }
set_legacy_ftrace_output(int index,std::string && value)4071 inline void ChromeEventBundle::set_legacy_ftrace_output(int index, std::string&& value) {
4072   _impl_.legacy_ftrace_output_.Mutable(index)->assign(std::move(value));
4073   // @@protoc_insertion_point(field_set:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4074 }
set_legacy_ftrace_output(int index,const char * value)4075 inline void ChromeEventBundle::set_legacy_ftrace_output(int index, const char* value) {
4076   GOOGLE_DCHECK(value != nullptr);
4077   _impl_.legacy_ftrace_output_.Mutable(index)->assign(value);
4078   // @@protoc_insertion_point(field_set_char:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4079 }
set_legacy_ftrace_output(int index,const char * value,size_t size)4080 inline void ChromeEventBundle::set_legacy_ftrace_output(int index, const char* value, size_t size) {
4081   _impl_.legacy_ftrace_output_.Mutable(index)->assign(
4082     reinterpret_cast<const char*>(value), size);
4083   // @@protoc_insertion_point(field_set_pointer:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4084 }
_internal_add_legacy_ftrace_output()4085 inline std::string* ChromeEventBundle::_internal_add_legacy_ftrace_output() {
4086   return _impl_.legacy_ftrace_output_.Add();
4087 }
add_legacy_ftrace_output(const std::string & value)4088 inline void ChromeEventBundle::add_legacy_ftrace_output(const std::string& value) {
4089   _impl_.legacy_ftrace_output_.Add()->assign(value);
4090   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4091 }
add_legacy_ftrace_output(std::string && value)4092 inline void ChromeEventBundle::add_legacy_ftrace_output(std::string&& value) {
4093   _impl_.legacy_ftrace_output_.Add(std::move(value));
4094   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4095 }
add_legacy_ftrace_output(const char * value)4096 inline void ChromeEventBundle::add_legacy_ftrace_output(const char* value) {
4097   GOOGLE_DCHECK(value != nullptr);
4098   _impl_.legacy_ftrace_output_.Add()->assign(value);
4099   // @@protoc_insertion_point(field_add_char:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4100 }
add_legacy_ftrace_output(const char * value,size_t size)4101 inline void ChromeEventBundle::add_legacy_ftrace_output(const char* value, size_t size) {
4102   _impl_.legacy_ftrace_output_.Add()->assign(reinterpret_cast<const char*>(value), size);
4103   // @@protoc_insertion_point(field_add_pointer:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4104 }
4105 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
legacy_ftrace_output()4106 ChromeEventBundle::legacy_ftrace_output() const {
4107   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4108   return _impl_.legacy_ftrace_output_;
4109 }
4110 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_legacy_ftrace_output()4111 ChromeEventBundle::mutable_legacy_ftrace_output() {
4112   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeEventBundle.legacy_ftrace_output)
4113   return &_impl_.legacy_ftrace_output_;
4114 }
4115 
4116 // repeated .perfetto.protos.ChromeLegacyJsonTrace legacy_json_trace = 5;
_internal_legacy_json_trace_size()4117 inline int ChromeEventBundle::_internal_legacy_json_trace_size() const {
4118   return _impl_.legacy_json_trace_.size();
4119 }
legacy_json_trace_size()4120 inline int ChromeEventBundle::legacy_json_trace_size() const {
4121   return _internal_legacy_json_trace_size();
4122 }
clear_legacy_json_trace()4123 inline void ChromeEventBundle::clear_legacy_json_trace() {
4124   _impl_.legacy_json_trace_.Clear();
4125 }
mutable_legacy_json_trace(int index)4126 inline ::perfetto::protos::ChromeLegacyJsonTrace* ChromeEventBundle::mutable_legacy_json_trace(int index) {
4127   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeEventBundle.legacy_json_trace)
4128   return _impl_.legacy_json_trace_.Mutable(index);
4129 }
4130 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeLegacyJsonTrace >*
mutable_legacy_json_trace()4131 ChromeEventBundle::mutable_legacy_json_trace() {
4132   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeEventBundle.legacy_json_trace)
4133   return &_impl_.legacy_json_trace_;
4134 }
_internal_legacy_json_trace(int index)4135 inline const ::perfetto::protos::ChromeLegacyJsonTrace& ChromeEventBundle::_internal_legacy_json_trace(int index) const {
4136   return _impl_.legacy_json_trace_.Get(index);
4137 }
legacy_json_trace(int index)4138 inline const ::perfetto::protos::ChromeLegacyJsonTrace& ChromeEventBundle::legacy_json_trace(int index) const {
4139   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeEventBundle.legacy_json_trace)
4140   return _internal_legacy_json_trace(index);
4141 }
_internal_add_legacy_json_trace()4142 inline ::perfetto::protos::ChromeLegacyJsonTrace* ChromeEventBundle::_internal_add_legacy_json_trace() {
4143   return _impl_.legacy_json_trace_.Add();
4144 }
add_legacy_json_trace()4145 inline ::perfetto::protos::ChromeLegacyJsonTrace* ChromeEventBundle::add_legacy_json_trace() {
4146   ::perfetto::protos::ChromeLegacyJsonTrace* _add = _internal_add_legacy_json_trace();
4147   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeEventBundle.legacy_json_trace)
4148   return _add;
4149 }
4150 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeLegacyJsonTrace >&
legacy_json_trace()4151 ChromeEventBundle::legacy_json_trace() const {
4152   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeEventBundle.legacy_json_trace)
4153   return _impl_.legacy_json_trace_;
4154 }
4155 
4156 // repeated .perfetto.protos.ChromeStringTableEntry string_table = 3 [deprecated = true];
_internal_string_table_size()4157 inline int ChromeEventBundle::_internal_string_table_size() const {
4158   return _impl_.string_table_.size();
4159 }
string_table_size()4160 inline int ChromeEventBundle::string_table_size() const {
4161   return _internal_string_table_size();
4162 }
clear_string_table()4163 inline void ChromeEventBundle::clear_string_table() {
4164   _impl_.string_table_.Clear();
4165 }
mutable_string_table(int index)4166 inline ::perfetto::protos::ChromeStringTableEntry* ChromeEventBundle::mutable_string_table(int index) {
4167   // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeEventBundle.string_table)
4168   return _impl_.string_table_.Mutable(index);
4169 }
4170 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeStringTableEntry >*
mutable_string_table()4171 ChromeEventBundle::mutable_string_table() {
4172   // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeEventBundle.string_table)
4173   return &_impl_.string_table_;
4174 }
_internal_string_table(int index)4175 inline const ::perfetto::protos::ChromeStringTableEntry& ChromeEventBundle::_internal_string_table(int index) const {
4176   return _impl_.string_table_.Get(index);
4177 }
string_table(int index)4178 inline const ::perfetto::protos::ChromeStringTableEntry& ChromeEventBundle::string_table(int index) const {
4179   // @@protoc_insertion_point(field_get:perfetto.protos.ChromeEventBundle.string_table)
4180   return _internal_string_table(index);
4181 }
_internal_add_string_table()4182 inline ::perfetto::protos::ChromeStringTableEntry* ChromeEventBundle::_internal_add_string_table() {
4183   return _impl_.string_table_.Add();
4184 }
add_string_table()4185 inline ::perfetto::protos::ChromeStringTableEntry* ChromeEventBundle::add_string_table() {
4186   ::perfetto::protos::ChromeStringTableEntry* _add = _internal_add_string_table();
4187   // @@protoc_insertion_point(field_add:perfetto.protos.ChromeEventBundle.string_table)
4188   return _add;
4189 }
4190 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeStringTableEntry >&
string_table()4191 ChromeEventBundle::string_table() const {
4192   // @@protoc_insertion_point(field_list:perfetto.protos.ChromeEventBundle.string_table)
4193   return _impl_.string_table_;
4194 }
4195 
4196 #ifdef __GNUC__
4197   #pragma GCC diagnostic pop
4198 #endif  // __GNUC__
4199 // -------------------------------------------------------------------
4200 
4201 // -------------------------------------------------------------------
4202 
4203 // -------------------------------------------------------------------
4204 
4205 // -------------------------------------------------------------------
4206 
4207 // -------------------------------------------------------------------
4208 
4209 // -------------------------------------------------------------------
4210 
4211 
4212 // @@protoc_insertion_point(namespace_scope)
4213 
4214 }  // namespace protos
4215 }  // namespace perfetto
4216 
4217 PROTOBUF_NAMESPACE_OPEN
4218 
4219 template <> struct is_proto_enum< ::perfetto::protos::ChromeTracedValue_NestedType> : ::std::true_type {};
4220 template <> struct is_proto_enum< ::perfetto::protos::ChromeLegacyJsonTrace_TraceType> : ::std::true_type {};
4221 
4222 PROTOBUF_NAMESPACE_CLOSE
4223 
4224 // @@protoc_insertion_point(global_scope)
4225 
4226 #include <google/protobuf/port_undef.inc>
4227 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5ftrace_5fevent_2eproto
4228