1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/chrome/chrome_trace_event.proto
3
4 #include "protos/perfetto/trace/chrome/chrome_trace_event.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace perfetto {
22 namespace protos {
ChromeTracedValue(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR ChromeTracedValue::ChromeTracedValue(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.dict_keys_)*/{}
28 , /*decltype(_impl_.dict_values_)*/{}
29 , /*decltype(_impl_.array_values_)*/{}
30 , /*decltype(_impl_.string_value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
31 , /*decltype(_impl_.nested_type_)*/0
32 , /*decltype(_impl_.int_value_)*/0
33 , /*decltype(_impl_.double_value_)*/0
34 , /*decltype(_impl_.bool_value_)*/false} {}
35 struct ChromeTracedValueDefaultTypeInternal {
ChromeTracedValueDefaultTypeInternalperfetto::protos::ChromeTracedValueDefaultTypeInternal36 PROTOBUF_CONSTEXPR ChromeTracedValueDefaultTypeInternal()
37 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeTracedValueDefaultTypeInternalperfetto::protos::ChromeTracedValueDefaultTypeInternal38 ~ChromeTracedValueDefaultTypeInternal() {}
39 union { // NOLINT(misc-non-private-member-variables-in-classes)
40 ChromeTracedValue _instance;
41 };
42 };
43 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeTracedValueDefaultTypeInternal _ChromeTracedValue_default_instance_;
ChromeStringTableEntry(::_pbi::ConstantInitialized)44 PROTOBUF_CONSTEXPR ChromeStringTableEntry::ChromeStringTableEntry(
45 ::_pbi::ConstantInitialized): _impl_{
46 /*decltype(_impl_._has_bits_)*/{}
47 , /*decltype(_impl_._cached_size_)*/{}
48 , /*decltype(_impl_.value_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
49 , /*decltype(_impl_.index_)*/0} {}
50 struct ChromeStringTableEntryDefaultTypeInternal {
ChromeStringTableEntryDefaultTypeInternalperfetto::protos::ChromeStringTableEntryDefaultTypeInternal51 PROTOBUF_CONSTEXPR ChromeStringTableEntryDefaultTypeInternal()
52 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeStringTableEntryDefaultTypeInternalperfetto::protos::ChromeStringTableEntryDefaultTypeInternal53 ~ChromeStringTableEntryDefaultTypeInternal() {}
54 union { // NOLINT(misc-non-private-member-variables-in-classes)
55 ChromeStringTableEntry _instance;
56 };
57 };
58 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeStringTableEntryDefaultTypeInternal _ChromeStringTableEntry_default_instance_;
ChromeTraceEvent_Arg(::_pbi::ConstantInitialized)59 PROTOBUF_CONSTEXPR ChromeTraceEvent_Arg::ChromeTraceEvent_Arg(
60 ::_pbi::ConstantInitialized): _impl_{
61 /*decltype(_impl_._has_bits_)*/{}
62 , /*decltype(_impl_._cached_size_)*/{}
63 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
64 , /*decltype(_impl_.name_index_)*/0u
65 , /*decltype(_impl_.value_)*/{}
66 , /*decltype(_impl_._oneof_case_)*/{}} {}
67 struct ChromeTraceEvent_ArgDefaultTypeInternal {
ChromeTraceEvent_ArgDefaultTypeInternalperfetto::protos::ChromeTraceEvent_ArgDefaultTypeInternal68 PROTOBUF_CONSTEXPR ChromeTraceEvent_ArgDefaultTypeInternal()
69 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeTraceEvent_ArgDefaultTypeInternalperfetto::protos::ChromeTraceEvent_ArgDefaultTypeInternal70 ~ChromeTraceEvent_ArgDefaultTypeInternal() {}
71 union { // NOLINT(misc-non-private-member-variables-in-classes)
72 ChromeTraceEvent_Arg _instance;
73 };
74 };
75 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeTraceEvent_ArgDefaultTypeInternal _ChromeTraceEvent_Arg_default_instance_;
ChromeTraceEvent(::_pbi::ConstantInitialized)76 PROTOBUF_CONSTEXPR ChromeTraceEvent::ChromeTraceEvent(
77 ::_pbi::ConstantInitialized): _impl_{
78 /*decltype(_impl_._has_bits_)*/{}
79 , /*decltype(_impl_._cached_size_)*/{}
80 , /*decltype(_impl_.args_)*/{}
81 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
82 , /*decltype(_impl_.scope_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
83 , /*decltype(_impl_.category_group_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
84 , /*decltype(_impl_.timestamp_)*/::int64_t{0}
85 , /*decltype(_impl_.phase_)*/0
86 , /*decltype(_impl_.thread_id_)*/0
87 , /*decltype(_impl_.duration_)*/::int64_t{0}
88 , /*decltype(_impl_.thread_duration_)*/::int64_t{0}
89 , /*decltype(_impl_.id_)*/::uint64_t{0u}
90 , /*decltype(_impl_.flags_)*/0u
91 , /*decltype(_impl_.process_id_)*/0
92 , /*decltype(_impl_.thread_timestamp_)*/::int64_t{0}
93 , /*decltype(_impl_.bind_id_)*/::uint64_t{0u}
94 , /*decltype(_impl_.name_index_)*/0u
95 , /*decltype(_impl_.category_group_name_index_)*/0u} {}
96 struct ChromeTraceEventDefaultTypeInternal {
ChromeTraceEventDefaultTypeInternalperfetto::protos::ChromeTraceEventDefaultTypeInternal97 PROTOBUF_CONSTEXPR ChromeTraceEventDefaultTypeInternal()
98 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeTraceEventDefaultTypeInternalperfetto::protos::ChromeTraceEventDefaultTypeInternal99 ~ChromeTraceEventDefaultTypeInternal() {}
100 union { // NOLINT(misc-non-private-member-variables-in-classes)
101 ChromeTraceEvent _instance;
102 };
103 };
104 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeTraceEventDefaultTypeInternal _ChromeTraceEvent_default_instance_;
ChromeMetadata(::_pbi::ConstantInitialized)105 PROTOBUF_CONSTEXPR ChromeMetadata::ChromeMetadata(
106 ::_pbi::ConstantInitialized): _impl_{
107 /*decltype(_impl_._has_bits_)*/{}
108 , /*decltype(_impl_._cached_size_)*/{}
109 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
110 , /*decltype(_impl_.value_)*/{}
111 , /*decltype(_impl_._oneof_case_)*/{}} {}
112 struct ChromeMetadataDefaultTypeInternal {
ChromeMetadataDefaultTypeInternalperfetto::protos::ChromeMetadataDefaultTypeInternal113 PROTOBUF_CONSTEXPR ChromeMetadataDefaultTypeInternal()
114 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeMetadataDefaultTypeInternalperfetto::protos::ChromeMetadataDefaultTypeInternal115 ~ChromeMetadataDefaultTypeInternal() {}
116 union { // NOLINT(misc-non-private-member-variables-in-classes)
117 ChromeMetadata _instance;
118 };
119 };
120 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeMetadataDefaultTypeInternal _ChromeMetadata_default_instance_;
ChromeLegacyJsonTrace(::_pbi::ConstantInitialized)121 PROTOBUF_CONSTEXPR ChromeLegacyJsonTrace::ChromeLegacyJsonTrace(
122 ::_pbi::ConstantInitialized): _impl_{
123 /*decltype(_impl_._has_bits_)*/{}
124 , /*decltype(_impl_._cached_size_)*/{}
125 , /*decltype(_impl_.data_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
126 , /*decltype(_impl_.type_)*/0} {}
127 struct ChromeLegacyJsonTraceDefaultTypeInternal {
ChromeLegacyJsonTraceDefaultTypeInternalperfetto::protos::ChromeLegacyJsonTraceDefaultTypeInternal128 PROTOBUF_CONSTEXPR ChromeLegacyJsonTraceDefaultTypeInternal()
129 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeLegacyJsonTraceDefaultTypeInternalperfetto::protos::ChromeLegacyJsonTraceDefaultTypeInternal130 ~ChromeLegacyJsonTraceDefaultTypeInternal() {}
131 union { // NOLINT(misc-non-private-member-variables-in-classes)
132 ChromeLegacyJsonTrace _instance;
133 };
134 };
135 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeLegacyJsonTraceDefaultTypeInternal _ChromeLegacyJsonTrace_default_instance_;
ChromeEventBundle(::_pbi::ConstantInitialized)136 PROTOBUF_CONSTEXPR ChromeEventBundle::ChromeEventBundle(
137 ::_pbi::ConstantInitialized): _impl_{
138 /*decltype(_impl_.trace_events_)*/{}
139 , /*decltype(_impl_.metadata_)*/{}
140 , /*decltype(_impl_.string_table_)*/{}
141 , /*decltype(_impl_.legacy_ftrace_output_)*/{}
142 , /*decltype(_impl_.legacy_json_trace_)*/{}
143 , /*decltype(_impl_._cached_size_)*/{}} {}
144 struct ChromeEventBundleDefaultTypeInternal {
ChromeEventBundleDefaultTypeInternalperfetto::protos::ChromeEventBundleDefaultTypeInternal145 PROTOBUF_CONSTEXPR ChromeEventBundleDefaultTypeInternal()
146 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeEventBundleDefaultTypeInternalperfetto::protos::ChromeEventBundleDefaultTypeInternal147 ~ChromeEventBundleDefaultTypeInternal() {}
148 union { // NOLINT(misc-non-private-member-variables-in-classes)
149 ChromeEventBundle _instance;
150 };
151 };
152 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeEventBundleDefaultTypeInternal _ChromeEventBundle_default_instance_;
153 } // namespace protos
154 } // namespace perfetto
155 namespace perfetto {
156 namespace protos {
ChromeTracedValue_NestedType_IsValid(int value)157 bool ChromeTracedValue_NestedType_IsValid(int value) {
158 switch (value) {
159 case 0:
160 case 1:
161 return true;
162 default:
163 return false;
164 }
165 }
166
167 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeTracedValue_NestedType_strings[2] = {};
168
169 static const char ChromeTracedValue_NestedType_names[] =
170 "ARRAY"
171 "DICT";
172
173 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeTracedValue_NestedType_entries[] = {
174 { {ChromeTracedValue_NestedType_names + 0, 5}, 1 },
175 { {ChromeTracedValue_NestedType_names + 5, 4}, 0 },
176 };
177
178 static const int ChromeTracedValue_NestedType_entries_by_number[] = {
179 1, // 0 -> DICT
180 0, // 1 -> ARRAY
181 };
182
ChromeTracedValue_NestedType_Name(ChromeTracedValue_NestedType value)183 const std::string& ChromeTracedValue_NestedType_Name(
184 ChromeTracedValue_NestedType value) {
185 static const bool dummy =
186 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
187 ChromeTracedValue_NestedType_entries,
188 ChromeTracedValue_NestedType_entries_by_number,
189 2, ChromeTracedValue_NestedType_strings);
190 (void) dummy;
191 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
192 ChromeTracedValue_NestedType_entries,
193 ChromeTracedValue_NestedType_entries_by_number,
194 2, value);
195 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
196 ChromeTracedValue_NestedType_strings[idx].get();
197 }
ChromeTracedValue_NestedType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeTracedValue_NestedType * value)198 bool ChromeTracedValue_NestedType_Parse(
199 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeTracedValue_NestedType* value) {
200 int int_value;
201 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
202 ChromeTracedValue_NestedType_entries, 2, name, &int_value);
203 if (success) {
204 *value = static_cast<ChromeTracedValue_NestedType>(int_value);
205 }
206 return success;
207 }
208 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
209 constexpr ChromeTracedValue_NestedType ChromeTracedValue::DICT;
210 constexpr ChromeTracedValue_NestedType ChromeTracedValue::ARRAY;
211 constexpr ChromeTracedValue_NestedType ChromeTracedValue::NestedType_MIN;
212 constexpr ChromeTracedValue_NestedType ChromeTracedValue::NestedType_MAX;
213 constexpr int ChromeTracedValue::NestedType_ARRAYSIZE;
214 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
ChromeLegacyJsonTrace_TraceType_IsValid(int value)215 bool ChromeLegacyJsonTrace_TraceType_IsValid(int value) {
216 switch (value) {
217 case 0:
218 case 1:
219 return true;
220 default:
221 return false;
222 }
223 }
224
225 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeLegacyJsonTrace_TraceType_strings[2] = {};
226
227 static const char ChromeLegacyJsonTrace_TraceType_names[] =
228 "SYSTEM_TRACE"
229 "USER_TRACE";
230
231 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeLegacyJsonTrace_TraceType_entries[] = {
232 { {ChromeLegacyJsonTrace_TraceType_names + 0, 12}, 1 },
233 { {ChromeLegacyJsonTrace_TraceType_names + 12, 10}, 0 },
234 };
235
236 static const int ChromeLegacyJsonTrace_TraceType_entries_by_number[] = {
237 1, // 0 -> USER_TRACE
238 0, // 1 -> SYSTEM_TRACE
239 };
240
ChromeLegacyJsonTrace_TraceType_Name(ChromeLegacyJsonTrace_TraceType value)241 const std::string& ChromeLegacyJsonTrace_TraceType_Name(
242 ChromeLegacyJsonTrace_TraceType value) {
243 static const bool dummy =
244 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
245 ChromeLegacyJsonTrace_TraceType_entries,
246 ChromeLegacyJsonTrace_TraceType_entries_by_number,
247 2, ChromeLegacyJsonTrace_TraceType_strings);
248 (void) dummy;
249 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
250 ChromeLegacyJsonTrace_TraceType_entries,
251 ChromeLegacyJsonTrace_TraceType_entries_by_number,
252 2, value);
253 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
254 ChromeLegacyJsonTrace_TraceType_strings[idx].get();
255 }
ChromeLegacyJsonTrace_TraceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeLegacyJsonTrace_TraceType * value)256 bool ChromeLegacyJsonTrace_TraceType_Parse(
257 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeLegacyJsonTrace_TraceType* value) {
258 int int_value;
259 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
260 ChromeLegacyJsonTrace_TraceType_entries, 2, name, &int_value);
261 if (success) {
262 *value = static_cast<ChromeLegacyJsonTrace_TraceType>(int_value);
263 }
264 return success;
265 }
266 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
267 constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace::USER_TRACE;
268 constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace::SYSTEM_TRACE;
269 constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace::TraceType_MIN;
270 constexpr ChromeLegacyJsonTrace_TraceType ChromeLegacyJsonTrace::TraceType_MAX;
271 constexpr int ChromeLegacyJsonTrace::TraceType_ARRAYSIZE;
272 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
273
274 // ===================================================================
275
276 class ChromeTracedValue::_Internal {
277 public:
278 using HasBits = decltype(std::declval<ChromeTracedValue>()._impl_._has_bits_);
set_has_nested_type(HasBits * has_bits)279 static void set_has_nested_type(HasBits* has_bits) {
280 (*has_bits)[0] |= 2u;
281 }
set_has_int_value(HasBits * has_bits)282 static void set_has_int_value(HasBits* has_bits) {
283 (*has_bits)[0] |= 4u;
284 }
set_has_double_value(HasBits * has_bits)285 static void set_has_double_value(HasBits* has_bits) {
286 (*has_bits)[0] |= 8u;
287 }
set_has_bool_value(HasBits * has_bits)288 static void set_has_bool_value(HasBits* has_bits) {
289 (*has_bits)[0] |= 16u;
290 }
set_has_string_value(HasBits * has_bits)291 static void set_has_string_value(HasBits* has_bits) {
292 (*has_bits)[0] |= 1u;
293 }
294 };
295
ChromeTracedValue(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)296 ChromeTracedValue::ChromeTracedValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
297 bool is_message_owned)
298 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
299 SharedCtor(arena, is_message_owned);
300 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeTracedValue)
301 }
ChromeTracedValue(const ChromeTracedValue & from)302 ChromeTracedValue::ChromeTracedValue(const ChromeTracedValue& from)
303 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
304 ChromeTracedValue* const _this = this; (void)_this;
305 new (&_impl_) Impl_{
306 decltype(_impl_._has_bits_){from._impl_._has_bits_}
307 , /*decltype(_impl_._cached_size_)*/{}
308 , decltype(_impl_.dict_keys_){from._impl_.dict_keys_}
309 , decltype(_impl_.dict_values_){from._impl_.dict_values_}
310 , decltype(_impl_.array_values_){from._impl_.array_values_}
311 , decltype(_impl_.string_value_){}
312 , decltype(_impl_.nested_type_){}
313 , decltype(_impl_.int_value_){}
314 , decltype(_impl_.double_value_){}
315 , decltype(_impl_.bool_value_){}};
316
317 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
318 _impl_.string_value_.InitDefault();
319 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
320 _impl_.string_value_.Set("", GetArenaForAllocation());
321 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
322 if (from._internal_has_string_value()) {
323 _this->_impl_.string_value_.Set(from._internal_string_value(),
324 _this->GetArenaForAllocation());
325 }
326 ::memcpy(&_impl_.nested_type_, &from._impl_.nested_type_,
327 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bool_value_) -
328 reinterpret_cast<char*>(&_impl_.nested_type_)) + sizeof(_impl_.bool_value_));
329 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeTracedValue)
330 }
331
SharedCtor(::_pb::Arena * arena,bool is_message_owned)332 inline void ChromeTracedValue::SharedCtor(
333 ::_pb::Arena* arena, bool is_message_owned) {
334 (void)arena;
335 (void)is_message_owned;
336 new (&_impl_) Impl_{
337 decltype(_impl_._has_bits_){}
338 , /*decltype(_impl_._cached_size_)*/{}
339 , decltype(_impl_.dict_keys_){arena}
340 , decltype(_impl_.dict_values_){arena}
341 , decltype(_impl_.array_values_){arena}
342 , decltype(_impl_.string_value_){}
343 , decltype(_impl_.nested_type_){0}
344 , decltype(_impl_.int_value_){0}
345 , decltype(_impl_.double_value_){0}
346 , decltype(_impl_.bool_value_){false}
347 };
348 _impl_.string_value_.InitDefault();
349 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
350 _impl_.string_value_.Set("", GetArenaForAllocation());
351 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
352 }
353
~ChromeTracedValue()354 ChromeTracedValue::~ChromeTracedValue() {
355 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeTracedValue)
356 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
357 (void)arena;
358 return;
359 }
360 SharedDtor();
361 }
362
SharedDtor()363 inline void ChromeTracedValue::SharedDtor() {
364 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
365 _impl_.dict_keys_.~RepeatedPtrField();
366 _impl_.dict_values_.~RepeatedPtrField();
367 _impl_.array_values_.~RepeatedPtrField();
368 _impl_.string_value_.Destroy();
369 }
370
SetCachedSize(int size) const371 void ChromeTracedValue::SetCachedSize(int size) const {
372 _impl_._cached_size_.Set(size);
373 }
374
Clear()375 void ChromeTracedValue::Clear() {
376 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeTracedValue)
377 ::uint32_t cached_has_bits = 0;
378 // Prevent compiler warnings about cached_has_bits being unused
379 (void) cached_has_bits;
380
381 _impl_.dict_keys_.Clear();
382 _impl_.dict_values_.Clear();
383 _impl_.array_values_.Clear();
384 cached_has_bits = _impl_._has_bits_[0];
385 if (cached_has_bits & 0x00000001u) {
386 _impl_.string_value_.ClearNonDefaultToEmpty();
387 }
388 if (cached_has_bits & 0x0000001eu) {
389 ::memset(&_impl_.nested_type_, 0, static_cast<size_t>(
390 reinterpret_cast<char*>(&_impl_.bool_value_) -
391 reinterpret_cast<char*>(&_impl_.nested_type_)) + sizeof(_impl_.bool_value_));
392 }
393 _impl_._has_bits_.Clear();
394 _internal_metadata_.Clear<std::string>();
395 }
396
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)397 const char* ChromeTracedValue::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
398 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
399 _Internal::HasBits has_bits{};
400 while (!ctx->Done(&ptr)) {
401 ::uint32_t tag;
402 ptr = ::_pbi::ReadTag(ptr, &tag);
403 switch (tag >> 3) {
404 // optional .perfetto.protos.ChromeTracedValue.NestedType nested_type = 1;
405 case 1:
406 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
407 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
408 CHK_(ptr);
409 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeTracedValue_NestedType_IsValid(val))) {
410 _internal_set_nested_type(static_cast<::perfetto::protos::ChromeTracedValue_NestedType>(val));
411 } else {
412 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
413 }
414 } else {
415 goto handle_unusual;
416 }
417 continue;
418 // repeated string dict_keys = 2;
419 case 2:
420 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
421 ptr -= 1;
422 do {
423 ptr += 1;
424 auto str = _internal_add_dict_keys();
425 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
426 CHK_(ptr);
427 if (!ctx->DataAvailable(ptr)) break;
428 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
429 } else {
430 goto handle_unusual;
431 }
432 continue;
433 // repeated .perfetto.protos.ChromeTracedValue dict_values = 3;
434 case 3:
435 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
436 ptr -= 1;
437 do {
438 ptr += 1;
439 ptr = ctx->ParseMessage(_internal_add_dict_values(), ptr);
440 CHK_(ptr);
441 if (!ctx->DataAvailable(ptr)) break;
442 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
443 } else {
444 goto handle_unusual;
445 }
446 continue;
447 // repeated .perfetto.protos.ChromeTracedValue array_values = 4;
448 case 4:
449 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
450 ptr -= 1;
451 do {
452 ptr += 1;
453 ptr = ctx->ParseMessage(_internal_add_array_values(), ptr);
454 CHK_(ptr);
455 if (!ctx->DataAvailable(ptr)) break;
456 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
457 } else {
458 goto handle_unusual;
459 }
460 continue;
461 // optional int32 int_value = 5;
462 case 5:
463 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
464 _Internal::set_has_int_value(&has_bits);
465 _impl_.int_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
466 CHK_(ptr);
467 } else {
468 goto handle_unusual;
469 }
470 continue;
471 // optional double double_value = 6;
472 case 6:
473 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 49)) {
474 _Internal::set_has_double_value(&has_bits);
475 _impl_.double_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
476 ptr += sizeof(double);
477 } else {
478 goto handle_unusual;
479 }
480 continue;
481 // optional bool bool_value = 7;
482 case 7:
483 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
484 _Internal::set_has_bool_value(&has_bits);
485 _impl_.bool_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
486 CHK_(ptr);
487 } else {
488 goto handle_unusual;
489 }
490 continue;
491 // optional string string_value = 8;
492 case 8:
493 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
494 auto str = _internal_mutable_string_value();
495 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
496 CHK_(ptr);
497 } else {
498 goto handle_unusual;
499 }
500 continue;
501 default:
502 goto handle_unusual;
503 } // switch
504 handle_unusual:
505 if ((tag == 0) || ((tag & 7) == 4)) {
506 CHK_(ptr);
507 ctx->SetLastTag(tag);
508 goto message_done;
509 }
510 ptr = UnknownFieldParse(
511 tag,
512 _internal_metadata_.mutable_unknown_fields<std::string>(),
513 ptr, ctx);
514 CHK_(ptr != nullptr);
515 } // while
516 message_done:
517 _impl_._has_bits_.Or(has_bits);
518 return ptr;
519 failure:
520 ptr = nullptr;
521 goto message_done;
522 #undef CHK_
523 }
524
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const525 ::uint8_t* ChromeTracedValue::_InternalSerialize(
526 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
527 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeTracedValue)
528 ::uint32_t cached_has_bits = 0;
529 (void) cached_has_bits;
530
531 cached_has_bits = _impl_._has_bits_[0];
532 // optional .perfetto.protos.ChromeTracedValue.NestedType nested_type = 1;
533 if (cached_has_bits & 0x00000002u) {
534 target = stream->EnsureSpace(target);
535 target = ::_pbi::WireFormatLite::WriteEnumToArray(
536 1, this->_internal_nested_type(), target);
537 }
538
539 // repeated string dict_keys = 2;
540 for (int i = 0, n = this->_internal_dict_keys_size(); i < n; i++) {
541 const auto& s = this->_internal_dict_keys(i);
542 target = stream->WriteString(2, s, target);
543 }
544
545 // repeated .perfetto.protos.ChromeTracedValue dict_values = 3;
546 for (unsigned i = 0,
547 n = static_cast<unsigned>(this->_internal_dict_values_size()); i < n; i++) {
548 const auto& repfield = this->_internal_dict_values(i);
549 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
550 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
551 }
552
553 // repeated .perfetto.protos.ChromeTracedValue array_values = 4;
554 for (unsigned i = 0,
555 n = static_cast<unsigned>(this->_internal_array_values_size()); i < n; i++) {
556 const auto& repfield = this->_internal_array_values(i);
557 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
558 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
559 }
560
561 // optional int32 int_value = 5;
562 if (cached_has_bits & 0x00000004u) {
563 target = stream->EnsureSpace(target);
564 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_int_value(), target);
565 }
566
567 // optional double double_value = 6;
568 if (cached_has_bits & 0x00000008u) {
569 target = stream->EnsureSpace(target);
570 target = ::_pbi::WireFormatLite::WriteDoubleToArray(6, this->_internal_double_value(), target);
571 }
572
573 // optional bool bool_value = 7;
574 if (cached_has_bits & 0x00000010u) {
575 target = stream->EnsureSpace(target);
576 target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_bool_value(), target);
577 }
578
579 // optional string string_value = 8;
580 if (cached_has_bits & 0x00000001u) {
581 target = stream->WriteStringMaybeAliased(
582 8, this->_internal_string_value(), target);
583 }
584
585 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
586 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
587 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
588 }
589 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeTracedValue)
590 return target;
591 }
592
ByteSizeLong() const593 size_t ChromeTracedValue::ByteSizeLong() const {
594 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeTracedValue)
595 size_t total_size = 0;
596
597 ::uint32_t cached_has_bits = 0;
598 // Prevent compiler warnings about cached_has_bits being unused
599 (void) cached_has_bits;
600
601 // repeated string dict_keys = 2;
602 total_size += 1 *
603 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.dict_keys_.size());
604 for (int i = 0, n = _impl_.dict_keys_.size(); i < n; i++) {
605 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
606 _impl_.dict_keys_.Get(i));
607 }
608
609 // repeated .perfetto.protos.ChromeTracedValue dict_values = 3;
610 total_size += 1UL * this->_internal_dict_values_size();
611 for (const auto& msg : this->_impl_.dict_values_) {
612 total_size +=
613 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
614 }
615
616 // repeated .perfetto.protos.ChromeTracedValue array_values = 4;
617 total_size += 1UL * this->_internal_array_values_size();
618 for (const auto& msg : this->_impl_.array_values_) {
619 total_size +=
620 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
621 }
622
623 cached_has_bits = _impl_._has_bits_[0];
624 if (cached_has_bits & 0x0000001fu) {
625 // optional string string_value = 8;
626 if (cached_has_bits & 0x00000001u) {
627 total_size += 1 +
628 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
629 this->_internal_string_value());
630 }
631
632 // optional .perfetto.protos.ChromeTracedValue.NestedType nested_type = 1;
633 if (cached_has_bits & 0x00000002u) {
634 total_size += 1 +
635 ::_pbi::WireFormatLite::EnumSize(this->_internal_nested_type());
636 }
637
638 // optional int32 int_value = 5;
639 if (cached_has_bits & 0x00000004u) {
640 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_int_value());
641 }
642
643 // optional double double_value = 6;
644 if (cached_has_bits & 0x00000008u) {
645 total_size += 1 + 8;
646 }
647
648 // optional bool bool_value = 7;
649 if (cached_has_bits & 0x00000010u) {
650 total_size += 1 + 1;
651 }
652
653 }
654 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
655 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
656 }
657 int cached_size = ::_pbi::ToCachedSize(total_size);
658 SetCachedSize(cached_size);
659 return total_size;
660 }
661
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)662 void ChromeTracedValue::CheckTypeAndMergeFrom(
663 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
664 MergeFrom(*::_pbi::DownCast<const ChromeTracedValue*>(
665 &from));
666 }
667
MergeFrom(const ChromeTracedValue & from)668 void ChromeTracedValue::MergeFrom(const ChromeTracedValue& from) {
669 ChromeTracedValue* const _this = this;
670 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeTracedValue)
671 GOOGLE_DCHECK_NE(&from, _this);
672 ::uint32_t cached_has_bits = 0;
673 (void) cached_has_bits;
674
675 _this->_impl_.dict_keys_.MergeFrom(from._impl_.dict_keys_);
676 _this->_impl_.dict_values_.MergeFrom(from._impl_.dict_values_);
677 _this->_impl_.array_values_.MergeFrom(from._impl_.array_values_);
678 cached_has_bits = from._impl_._has_bits_[0];
679 if (cached_has_bits & 0x0000001fu) {
680 if (cached_has_bits & 0x00000001u) {
681 _this->_internal_set_string_value(from._internal_string_value());
682 }
683 if (cached_has_bits & 0x00000002u) {
684 _this->_impl_.nested_type_ = from._impl_.nested_type_;
685 }
686 if (cached_has_bits & 0x00000004u) {
687 _this->_impl_.int_value_ = from._impl_.int_value_;
688 }
689 if (cached_has_bits & 0x00000008u) {
690 _this->_impl_.double_value_ = from._impl_.double_value_;
691 }
692 if (cached_has_bits & 0x00000010u) {
693 _this->_impl_.bool_value_ = from._impl_.bool_value_;
694 }
695 _this->_impl_._has_bits_[0] |= cached_has_bits;
696 }
697 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
698 }
699
CopyFrom(const ChromeTracedValue & from)700 void ChromeTracedValue::CopyFrom(const ChromeTracedValue& from) {
701 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeTracedValue)
702 if (&from == this) return;
703 Clear();
704 MergeFrom(from);
705 }
706
IsInitialized() const707 bool ChromeTracedValue::IsInitialized() const {
708 return true;
709 }
710
InternalSwap(ChromeTracedValue * other)711 void ChromeTracedValue::InternalSwap(ChromeTracedValue* other) {
712 using std::swap;
713 auto* lhs_arena = GetArenaForAllocation();
714 auto* rhs_arena = other->GetArenaForAllocation();
715 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
716 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
717 _impl_.dict_keys_.InternalSwap(&other->_impl_.dict_keys_);
718 _impl_.dict_values_.InternalSwap(&other->_impl_.dict_values_);
719 _impl_.array_values_.InternalSwap(&other->_impl_.array_values_);
720 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
721 &_impl_.string_value_, lhs_arena,
722 &other->_impl_.string_value_, rhs_arena
723 );
724 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
725 PROTOBUF_FIELD_OFFSET(ChromeTracedValue, _impl_.bool_value_)
726 + sizeof(ChromeTracedValue::_impl_.bool_value_) // NOLINT
727 - PROTOBUF_FIELD_OFFSET(ChromeTracedValue, _impl_.nested_type_)>(
728 reinterpret_cast<char*>(&_impl_.nested_type_),
729 reinterpret_cast<char*>(&other->_impl_.nested_type_));
730 }
731
GetTypeName() const732 std::string ChromeTracedValue::GetTypeName() const {
733 return "perfetto.protos.ChromeTracedValue";
734 }
735
736
737 // ===================================================================
738
739 class ChromeStringTableEntry::_Internal {
740 public:
741 using HasBits = decltype(std::declval<ChromeStringTableEntry>()._impl_._has_bits_);
set_has_value(HasBits * has_bits)742 static void set_has_value(HasBits* has_bits) {
743 (*has_bits)[0] |= 1u;
744 }
set_has_index(HasBits * has_bits)745 static void set_has_index(HasBits* has_bits) {
746 (*has_bits)[0] |= 2u;
747 }
748 };
749
ChromeStringTableEntry(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)750 ChromeStringTableEntry::ChromeStringTableEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
751 bool is_message_owned)
752 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
753 SharedCtor(arena, is_message_owned);
754 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeStringTableEntry)
755 }
ChromeStringTableEntry(const ChromeStringTableEntry & from)756 ChromeStringTableEntry::ChromeStringTableEntry(const ChromeStringTableEntry& from)
757 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
758 ChromeStringTableEntry* const _this = this; (void)_this;
759 new (&_impl_) Impl_{
760 decltype(_impl_._has_bits_){from._impl_._has_bits_}
761 , /*decltype(_impl_._cached_size_)*/{}
762 , decltype(_impl_.value_){}
763 , decltype(_impl_.index_){}};
764
765 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
766 _impl_.value_.InitDefault();
767 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
768 _impl_.value_.Set("", GetArenaForAllocation());
769 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
770 if (from._internal_has_value()) {
771 _this->_impl_.value_.Set(from._internal_value(),
772 _this->GetArenaForAllocation());
773 }
774 _this->_impl_.index_ = from._impl_.index_;
775 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeStringTableEntry)
776 }
777
SharedCtor(::_pb::Arena * arena,bool is_message_owned)778 inline void ChromeStringTableEntry::SharedCtor(
779 ::_pb::Arena* arena, bool is_message_owned) {
780 (void)arena;
781 (void)is_message_owned;
782 new (&_impl_) Impl_{
783 decltype(_impl_._has_bits_){}
784 , /*decltype(_impl_._cached_size_)*/{}
785 , decltype(_impl_.value_){}
786 , decltype(_impl_.index_){0}
787 };
788 _impl_.value_.InitDefault();
789 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
790 _impl_.value_.Set("", GetArenaForAllocation());
791 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
792 }
793
~ChromeStringTableEntry()794 ChromeStringTableEntry::~ChromeStringTableEntry() {
795 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeStringTableEntry)
796 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
797 (void)arena;
798 return;
799 }
800 SharedDtor();
801 }
802
SharedDtor()803 inline void ChromeStringTableEntry::SharedDtor() {
804 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
805 _impl_.value_.Destroy();
806 }
807
SetCachedSize(int size) const808 void ChromeStringTableEntry::SetCachedSize(int size) const {
809 _impl_._cached_size_.Set(size);
810 }
811
Clear()812 void ChromeStringTableEntry::Clear() {
813 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeStringTableEntry)
814 ::uint32_t cached_has_bits = 0;
815 // Prevent compiler warnings about cached_has_bits being unused
816 (void) cached_has_bits;
817
818 cached_has_bits = _impl_._has_bits_[0];
819 if (cached_has_bits & 0x00000001u) {
820 _impl_.value_.ClearNonDefaultToEmpty();
821 }
822 _impl_.index_ = 0;
823 _impl_._has_bits_.Clear();
824 _internal_metadata_.Clear<std::string>();
825 }
826
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)827 const char* ChromeStringTableEntry::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
828 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
829 _Internal::HasBits has_bits{};
830 while (!ctx->Done(&ptr)) {
831 ::uint32_t tag;
832 ptr = ::_pbi::ReadTag(ptr, &tag);
833 switch (tag >> 3) {
834 // optional string value = 1;
835 case 1:
836 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
837 auto str = _internal_mutable_value();
838 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
839 CHK_(ptr);
840 } else {
841 goto handle_unusual;
842 }
843 continue;
844 // optional int32 index = 2;
845 case 2:
846 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
847 _Internal::set_has_index(&has_bits);
848 _impl_.index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
849 CHK_(ptr);
850 } else {
851 goto handle_unusual;
852 }
853 continue;
854 default:
855 goto handle_unusual;
856 } // switch
857 handle_unusual:
858 if ((tag == 0) || ((tag & 7) == 4)) {
859 CHK_(ptr);
860 ctx->SetLastTag(tag);
861 goto message_done;
862 }
863 ptr = UnknownFieldParse(
864 tag,
865 _internal_metadata_.mutable_unknown_fields<std::string>(),
866 ptr, ctx);
867 CHK_(ptr != nullptr);
868 } // while
869 message_done:
870 _impl_._has_bits_.Or(has_bits);
871 return ptr;
872 failure:
873 ptr = nullptr;
874 goto message_done;
875 #undef CHK_
876 }
877
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const878 ::uint8_t* ChromeStringTableEntry::_InternalSerialize(
879 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
880 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeStringTableEntry)
881 ::uint32_t cached_has_bits = 0;
882 (void) cached_has_bits;
883
884 cached_has_bits = _impl_._has_bits_[0];
885 // optional string value = 1;
886 if (cached_has_bits & 0x00000001u) {
887 target = stream->WriteStringMaybeAliased(
888 1, this->_internal_value(), target);
889 }
890
891 // optional int32 index = 2;
892 if (cached_has_bits & 0x00000002u) {
893 target = stream->EnsureSpace(target);
894 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_index(), target);
895 }
896
897 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
898 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
899 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
900 }
901 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeStringTableEntry)
902 return target;
903 }
904
ByteSizeLong() const905 size_t ChromeStringTableEntry::ByteSizeLong() const {
906 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeStringTableEntry)
907 size_t total_size = 0;
908
909 ::uint32_t cached_has_bits = 0;
910 // Prevent compiler warnings about cached_has_bits being unused
911 (void) cached_has_bits;
912
913 cached_has_bits = _impl_._has_bits_[0];
914 if (cached_has_bits & 0x00000003u) {
915 // optional string value = 1;
916 if (cached_has_bits & 0x00000001u) {
917 total_size += 1 +
918 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
919 this->_internal_value());
920 }
921
922 // optional int32 index = 2;
923 if (cached_has_bits & 0x00000002u) {
924 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_index());
925 }
926
927 }
928 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
929 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
930 }
931 int cached_size = ::_pbi::ToCachedSize(total_size);
932 SetCachedSize(cached_size);
933 return total_size;
934 }
935
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)936 void ChromeStringTableEntry::CheckTypeAndMergeFrom(
937 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
938 MergeFrom(*::_pbi::DownCast<const ChromeStringTableEntry*>(
939 &from));
940 }
941
MergeFrom(const ChromeStringTableEntry & from)942 void ChromeStringTableEntry::MergeFrom(const ChromeStringTableEntry& from) {
943 ChromeStringTableEntry* const _this = this;
944 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeStringTableEntry)
945 GOOGLE_DCHECK_NE(&from, _this);
946 ::uint32_t cached_has_bits = 0;
947 (void) cached_has_bits;
948
949 cached_has_bits = from._impl_._has_bits_[0];
950 if (cached_has_bits & 0x00000003u) {
951 if (cached_has_bits & 0x00000001u) {
952 _this->_internal_set_value(from._internal_value());
953 }
954 if (cached_has_bits & 0x00000002u) {
955 _this->_impl_.index_ = from._impl_.index_;
956 }
957 _this->_impl_._has_bits_[0] |= cached_has_bits;
958 }
959 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
960 }
961
CopyFrom(const ChromeStringTableEntry & from)962 void ChromeStringTableEntry::CopyFrom(const ChromeStringTableEntry& from) {
963 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeStringTableEntry)
964 if (&from == this) return;
965 Clear();
966 MergeFrom(from);
967 }
968
IsInitialized() const969 bool ChromeStringTableEntry::IsInitialized() const {
970 return true;
971 }
972
InternalSwap(ChromeStringTableEntry * other)973 void ChromeStringTableEntry::InternalSwap(ChromeStringTableEntry* other) {
974 using std::swap;
975 auto* lhs_arena = GetArenaForAllocation();
976 auto* rhs_arena = other->GetArenaForAllocation();
977 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
978 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
979 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
980 &_impl_.value_, lhs_arena,
981 &other->_impl_.value_, rhs_arena
982 );
983 swap(_impl_.index_, other->_impl_.index_);
984 }
985
GetTypeName() const986 std::string ChromeStringTableEntry::GetTypeName() const {
987 return "perfetto.protos.ChromeStringTableEntry";
988 }
989
990
991 // ===================================================================
992
993 class ChromeTraceEvent_Arg::_Internal {
994 public:
995 using HasBits = decltype(std::declval<ChromeTraceEvent_Arg>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)996 static void set_has_name(HasBits* has_bits) {
997 (*has_bits)[0] |= 1u;
998 }
999 static const ::perfetto::protos::ChromeTracedValue& traced_value(const ChromeTraceEvent_Arg* msg);
set_has_name_index(HasBits * has_bits)1000 static void set_has_name_index(HasBits* has_bits) {
1001 (*has_bits)[0] |= 2u;
1002 }
1003 };
1004
1005 const ::perfetto::protos::ChromeTracedValue&
traced_value(const ChromeTraceEvent_Arg * msg)1006 ChromeTraceEvent_Arg::_Internal::traced_value(const ChromeTraceEvent_Arg* msg) {
1007 return *msg->_impl_.value_.traced_value_;
1008 }
set_allocated_traced_value(::perfetto::protos::ChromeTracedValue * traced_value)1009 void ChromeTraceEvent_Arg::set_allocated_traced_value(::perfetto::protos::ChromeTracedValue* traced_value) {
1010 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1011 clear_value();
1012 if (traced_value) {
1013 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1014 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(traced_value);
1015 if (message_arena != submessage_arena) {
1016 traced_value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1017 message_arena, traced_value, submessage_arena);
1018 }
1019 set_has_traced_value();
1020 _impl_.value_.traced_value_ = traced_value;
1021 }
1022 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeTraceEvent.Arg.traced_value)
1023 }
ChromeTraceEvent_Arg(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1024 ChromeTraceEvent_Arg::ChromeTraceEvent_Arg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1025 bool is_message_owned)
1026 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1027 SharedCtor(arena, is_message_owned);
1028 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeTraceEvent.Arg)
1029 }
ChromeTraceEvent_Arg(const ChromeTraceEvent_Arg & from)1030 ChromeTraceEvent_Arg::ChromeTraceEvent_Arg(const ChromeTraceEvent_Arg& from)
1031 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1032 ChromeTraceEvent_Arg* const _this = this; (void)_this;
1033 new (&_impl_) Impl_{
1034 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1035 , /*decltype(_impl_._cached_size_)*/{}
1036 , decltype(_impl_.name_){}
1037 , decltype(_impl_.name_index_){}
1038 , decltype(_impl_.value_){}
1039 , /*decltype(_impl_._oneof_case_)*/{}};
1040
1041 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1042 _impl_.name_.InitDefault();
1043 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1044 _impl_.name_.Set("", GetArenaForAllocation());
1045 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1046 if (from._internal_has_name()) {
1047 _this->_impl_.name_.Set(from._internal_name(),
1048 _this->GetArenaForAllocation());
1049 }
1050 _this->_impl_.name_index_ = from._impl_.name_index_;
1051 clear_has_value();
1052 switch (from.value_case()) {
1053 case kBoolValue: {
1054 _this->_internal_set_bool_value(from._internal_bool_value());
1055 break;
1056 }
1057 case kUintValue: {
1058 _this->_internal_set_uint_value(from._internal_uint_value());
1059 break;
1060 }
1061 case kIntValue: {
1062 _this->_internal_set_int_value(from._internal_int_value());
1063 break;
1064 }
1065 case kDoubleValue: {
1066 _this->_internal_set_double_value(from._internal_double_value());
1067 break;
1068 }
1069 case kStringValue: {
1070 _this->_internal_set_string_value(from._internal_string_value());
1071 break;
1072 }
1073 case kPointerValue: {
1074 _this->_internal_set_pointer_value(from._internal_pointer_value());
1075 break;
1076 }
1077 case kJsonValue: {
1078 _this->_internal_set_json_value(from._internal_json_value());
1079 break;
1080 }
1081 case kTracedValue: {
1082 _this->_internal_mutable_traced_value()->::perfetto::protos::ChromeTracedValue::MergeFrom(
1083 from._internal_traced_value());
1084 break;
1085 }
1086 case VALUE_NOT_SET: {
1087 break;
1088 }
1089 }
1090 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeTraceEvent.Arg)
1091 }
1092
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1093 inline void ChromeTraceEvent_Arg::SharedCtor(
1094 ::_pb::Arena* arena, bool is_message_owned) {
1095 (void)arena;
1096 (void)is_message_owned;
1097 new (&_impl_) Impl_{
1098 decltype(_impl_._has_bits_){}
1099 , /*decltype(_impl_._cached_size_)*/{}
1100 , decltype(_impl_.name_){}
1101 , decltype(_impl_.name_index_){0u}
1102 , decltype(_impl_.value_){}
1103 , /*decltype(_impl_._oneof_case_)*/{}
1104 };
1105 _impl_.name_.InitDefault();
1106 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1107 _impl_.name_.Set("", GetArenaForAllocation());
1108 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1109 clear_has_value();
1110 }
1111
~ChromeTraceEvent_Arg()1112 ChromeTraceEvent_Arg::~ChromeTraceEvent_Arg() {
1113 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeTraceEvent.Arg)
1114 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1115 (void)arena;
1116 return;
1117 }
1118 SharedDtor();
1119 }
1120
SharedDtor()1121 inline void ChromeTraceEvent_Arg::SharedDtor() {
1122 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1123 _impl_.name_.Destroy();
1124 if (has_value()) {
1125 clear_value();
1126 }
1127 }
1128
SetCachedSize(int size) const1129 void ChromeTraceEvent_Arg::SetCachedSize(int size) const {
1130 _impl_._cached_size_.Set(size);
1131 }
1132
clear_value()1133 void ChromeTraceEvent_Arg::clear_value() {
1134 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.ChromeTraceEvent.Arg)
1135 switch (value_case()) {
1136 case kBoolValue: {
1137 // No need to clear
1138 break;
1139 }
1140 case kUintValue: {
1141 // No need to clear
1142 break;
1143 }
1144 case kIntValue: {
1145 // No need to clear
1146 break;
1147 }
1148 case kDoubleValue: {
1149 // No need to clear
1150 break;
1151 }
1152 case kStringValue: {
1153 _impl_.value_.string_value_.Destroy();
1154 break;
1155 }
1156 case kPointerValue: {
1157 // No need to clear
1158 break;
1159 }
1160 case kJsonValue: {
1161 _impl_.value_.json_value_.Destroy();
1162 break;
1163 }
1164 case kTracedValue: {
1165 if (GetArenaForAllocation() == nullptr) {
1166 delete _impl_.value_.traced_value_;
1167 }
1168 break;
1169 }
1170 case VALUE_NOT_SET: {
1171 break;
1172 }
1173 }
1174 _impl_._oneof_case_[0] = VALUE_NOT_SET;
1175 }
1176
1177
Clear()1178 void ChromeTraceEvent_Arg::Clear() {
1179 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeTraceEvent.Arg)
1180 ::uint32_t cached_has_bits = 0;
1181 // Prevent compiler warnings about cached_has_bits being unused
1182 (void) cached_has_bits;
1183
1184 cached_has_bits = _impl_._has_bits_[0];
1185 if (cached_has_bits & 0x00000001u) {
1186 _impl_.name_.ClearNonDefaultToEmpty();
1187 }
1188 _impl_.name_index_ = 0u;
1189 clear_value();
1190 _impl_._has_bits_.Clear();
1191 _internal_metadata_.Clear<std::string>();
1192 }
1193
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1194 const char* ChromeTraceEvent_Arg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1195 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1196 _Internal::HasBits has_bits{};
1197 while (!ctx->Done(&ptr)) {
1198 ::uint32_t tag;
1199 ptr = ::_pbi::ReadTag(ptr, &tag);
1200 switch (tag >> 3) {
1201 // optional string name = 1;
1202 case 1:
1203 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1204 auto str = _internal_mutable_name();
1205 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1206 CHK_(ptr);
1207 } else {
1208 goto handle_unusual;
1209 }
1210 continue;
1211 // bool bool_value = 2;
1212 case 2:
1213 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1214 _internal_set_bool_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1215 CHK_(ptr);
1216 } else {
1217 goto handle_unusual;
1218 }
1219 continue;
1220 // uint64 uint_value = 3;
1221 case 3:
1222 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1223 _internal_set_uint_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1224 CHK_(ptr);
1225 } else {
1226 goto handle_unusual;
1227 }
1228 continue;
1229 // int64 int_value = 4;
1230 case 4:
1231 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1232 _internal_set_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1233 CHK_(ptr);
1234 } else {
1235 goto handle_unusual;
1236 }
1237 continue;
1238 // double double_value = 5;
1239 case 5:
1240 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 41)) {
1241 _internal_set_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
1242 ptr += sizeof(double);
1243 } else {
1244 goto handle_unusual;
1245 }
1246 continue;
1247 // string string_value = 6;
1248 case 6:
1249 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1250 auto str = _internal_mutable_string_value();
1251 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1252 CHK_(ptr);
1253 } else {
1254 goto handle_unusual;
1255 }
1256 continue;
1257 // uint64 pointer_value = 7;
1258 case 7:
1259 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1260 _internal_set_pointer_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1261 CHK_(ptr);
1262 } else {
1263 goto handle_unusual;
1264 }
1265 continue;
1266 // string json_value = 8;
1267 case 8:
1268 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
1269 auto str = _internal_mutable_json_value();
1270 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1271 CHK_(ptr);
1272 } else {
1273 goto handle_unusual;
1274 }
1275 continue;
1276 // optional uint32 name_index = 9;
1277 case 9:
1278 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1279 _Internal::set_has_name_index(&has_bits);
1280 _impl_.name_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1281 CHK_(ptr);
1282 } else {
1283 goto handle_unusual;
1284 }
1285 continue;
1286 // .perfetto.protos.ChromeTracedValue traced_value = 10;
1287 case 10:
1288 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
1289 ptr = ctx->ParseMessage(_internal_mutable_traced_value(), ptr);
1290 CHK_(ptr);
1291 } else {
1292 goto handle_unusual;
1293 }
1294 continue;
1295 default:
1296 goto handle_unusual;
1297 } // switch
1298 handle_unusual:
1299 if ((tag == 0) || ((tag & 7) == 4)) {
1300 CHK_(ptr);
1301 ctx->SetLastTag(tag);
1302 goto message_done;
1303 }
1304 ptr = UnknownFieldParse(
1305 tag,
1306 _internal_metadata_.mutable_unknown_fields<std::string>(),
1307 ptr, ctx);
1308 CHK_(ptr != nullptr);
1309 } // while
1310 message_done:
1311 _impl_._has_bits_.Or(has_bits);
1312 return ptr;
1313 failure:
1314 ptr = nullptr;
1315 goto message_done;
1316 #undef CHK_
1317 }
1318
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1319 ::uint8_t* ChromeTraceEvent_Arg::_InternalSerialize(
1320 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1321 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeTraceEvent.Arg)
1322 ::uint32_t cached_has_bits = 0;
1323 (void) cached_has_bits;
1324
1325 cached_has_bits = _impl_._has_bits_[0];
1326 // optional string name = 1;
1327 if (cached_has_bits & 0x00000001u) {
1328 target = stream->WriteStringMaybeAliased(
1329 1, this->_internal_name(), target);
1330 }
1331
1332 switch (value_case()) {
1333 case kBoolValue: {
1334 target = stream->EnsureSpace(target);
1335 target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_bool_value(), target);
1336 break;
1337 }
1338 case kUintValue: {
1339 target = stream->EnsureSpace(target);
1340 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_uint_value(), target);
1341 break;
1342 }
1343 case kIntValue: {
1344 target = stream->EnsureSpace(target);
1345 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_int_value(), target);
1346 break;
1347 }
1348 case kDoubleValue: {
1349 target = stream->EnsureSpace(target);
1350 target = ::_pbi::WireFormatLite::WriteDoubleToArray(5, this->_internal_double_value(), target);
1351 break;
1352 }
1353 case kStringValue: {
1354 target = stream->WriteStringMaybeAliased(
1355 6, this->_internal_string_value(), target);
1356 break;
1357 }
1358 case kPointerValue: {
1359 target = stream->EnsureSpace(target);
1360 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_pointer_value(), target);
1361 break;
1362 }
1363 case kJsonValue: {
1364 target = stream->WriteStringMaybeAliased(
1365 8, this->_internal_json_value(), target);
1366 break;
1367 }
1368 default: ;
1369 }
1370 // optional uint32 name_index = 9;
1371 if (cached_has_bits & 0x00000002u) {
1372 target = stream->EnsureSpace(target);
1373 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_name_index(), target);
1374 }
1375
1376 // .perfetto.protos.ChromeTracedValue traced_value = 10;
1377 if (_internal_has_traced_value()) {
1378 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1379 InternalWriteMessage(10, _Internal::traced_value(this),
1380 _Internal::traced_value(this).GetCachedSize(), target, stream);
1381 }
1382
1383 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1384 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1385 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1386 }
1387 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeTraceEvent.Arg)
1388 return target;
1389 }
1390
ByteSizeLong() const1391 size_t ChromeTraceEvent_Arg::ByteSizeLong() const {
1392 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeTraceEvent.Arg)
1393 size_t total_size = 0;
1394
1395 ::uint32_t cached_has_bits = 0;
1396 // Prevent compiler warnings about cached_has_bits being unused
1397 (void) cached_has_bits;
1398
1399 cached_has_bits = _impl_._has_bits_[0];
1400 if (cached_has_bits & 0x00000003u) {
1401 // optional string name = 1;
1402 if (cached_has_bits & 0x00000001u) {
1403 total_size += 1 +
1404 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1405 this->_internal_name());
1406 }
1407
1408 // optional uint32 name_index = 9;
1409 if (cached_has_bits & 0x00000002u) {
1410 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_name_index());
1411 }
1412
1413 }
1414 switch (value_case()) {
1415 // bool bool_value = 2;
1416 case kBoolValue: {
1417 total_size += 1 + 1;
1418 break;
1419 }
1420 // uint64 uint_value = 3;
1421 case kUintValue: {
1422 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_uint_value());
1423 break;
1424 }
1425 // int64 int_value = 4;
1426 case kIntValue: {
1427 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_int_value());
1428 break;
1429 }
1430 // double double_value = 5;
1431 case kDoubleValue: {
1432 total_size += 1 + 8;
1433 break;
1434 }
1435 // string string_value = 6;
1436 case kStringValue: {
1437 total_size += 1 +
1438 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1439 this->_internal_string_value());
1440 break;
1441 }
1442 // uint64 pointer_value = 7;
1443 case kPointerValue: {
1444 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_pointer_value());
1445 break;
1446 }
1447 // string json_value = 8;
1448 case kJsonValue: {
1449 total_size += 1 +
1450 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1451 this->_internal_json_value());
1452 break;
1453 }
1454 // .perfetto.protos.ChromeTracedValue traced_value = 10;
1455 case kTracedValue: {
1456 total_size += 1 +
1457 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1458 *_impl_.value_.traced_value_);
1459 break;
1460 }
1461 case VALUE_NOT_SET: {
1462 break;
1463 }
1464 }
1465 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1466 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1467 }
1468 int cached_size = ::_pbi::ToCachedSize(total_size);
1469 SetCachedSize(cached_size);
1470 return total_size;
1471 }
1472
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1473 void ChromeTraceEvent_Arg::CheckTypeAndMergeFrom(
1474 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1475 MergeFrom(*::_pbi::DownCast<const ChromeTraceEvent_Arg*>(
1476 &from));
1477 }
1478
MergeFrom(const ChromeTraceEvent_Arg & from)1479 void ChromeTraceEvent_Arg::MergeFrom(const ChromeTraceEvent_Arg& from) {
1480 ChromeTraceEvent_Arg* const _this = this;
1481 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeTraceEvent.Arg)
1482 GOOGLE_DCHECK_NE(&from, _this);
1483 ::uint32_t cached_has_bits = 0;
1484 (void) cached_has_bits;
1485
1486 cached_has_bits = from._impl_._has_bits_[0];
1487 if (cached_has_bits & 0x00000003u) {
1488 if (cached_has_bits & 0x00000001u) {
1489 _this->_internal_set_name(from._internal_name());
1490 }
1491 if (cached_has_bits & 0x00000002u) {
1492 _this->_impl_.name_index_ = from._impl_.name_index_;
1493 }
1494 _this->_impl_._has_bits_[0] |= cached_has_bits;
1495 }
1496 switch (from.value_case()) {
1497 case kBoolValue: {
1498 _this->_internal_set_bool_value(from._internal_bool_value());
1499 break;
1500 }
1501 case kUintValue: {
1502 _this->_internal_set_uint_value(from._internal_uint_value());
1503 break;
1504 }
1505 case kIntValue: {
1506 _this->_internal_set_int_value(from._internal_int_value());
1507 break;
1508 }
1509 case kDoubleValue: {
1510 _this->_internal_set_double_value(from._internal_double_value());
1511 break;
1512 }
1513 case kStringValue: {
1514 _this->_internal_set_string_value(from._internal_string_value());
1515 break;
1516 }
1517 case kPointerValue: {
1518 _this->_internal_set_pointer_value(from._internal_pointer_value());
1519 break;
1520 }
1521 case kJsonValue: {
1522 _this->_internal_set_json_value(from._internal_json_value());
1523 break;
1524 }
1525 case kTracedValue: {
1526 _this->_internal_mutable_traced_value()->::perfetto::protos::ChromeTracedValue::MergeFrom(
1527 from._internal_traced_value());
1528 break;
1529 }
1530 case VALUE_NOT_SET: {
1531 break;
1532 }
1533 }
1534 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1535 }
1536
CopyFrom(const ChromeTraceEvent_Arg & from)1537 void ChromeTraceEvent_Arg::CopyFrom(const ChromeTraceEvent_Arg& from) {
1538 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeTraceEvent.Arg)
1539 if (&from == this) return;
1540 Clear();
1541 MergeFrom(from);
1542 }
1543
IsInitialized() const1544 bool ChromeTraceEvent_Arg::IsInitialized() const {
1545 return true;
1546 }
1547
InternalSwap(ChromeTraceEvent_Arg * other)1548 void ChromeTraceEvent_Arg::InternalSwap(ChromeTraceEvent_Arg* other) {
1549 using std::swap;
1550 auto* lhs_arena = GetArenaForAllocation();
1551 auto* rhs_arena = other->GetArenaForAllocation();
1552 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1553 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1554 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1555 &_impl_.name_, lhs_arena,
1556 &other->_impl_.name_, rhs_arena
1557 );
1558 swap(_impl_.name_index_, other->_impl_.name_index_);
1559 swap(_impl_.value_, other->_impl_.value_);
1560 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1561 }
1562
GetTypeName() const1563 std::string ChromeTraceEvent_Arg::GetTypeName() const {
1564 return "perfetto.protos.ChromeTraceEvent.Arg";
1565 }
1566
1567
1568 // ===================================================================
1569
1570 class ChromeTraceEvent::_Internal {
1571 public:
1572 using HasBits = decltype(std::declval<ChromeTraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)1573 static void set_has_name(HasBits* has_bits) {
1574 (*has_bits)[0] |= 1u;
1575 }
set_has_timestamp(HasBits * has_bits)1576 static void set_has_timestamp(HasBits* has_bits) {
1577 (*has_bits)[0] |= 8u;
1578 }
set_has_phase(HasBits * has_bits)1579 static void set_has_phase(HasBits* has_bits) {
1580 (*has_bits)[0] |= 16u;
1581 }
set_has_thread_id(HasBits * has_bits)1582 static void set_has_thread_id(HasBits* has_bits) {
1583 (*has_bits)[0] |= 32u;
1584 }
set_has_duration(HasBits * has_bits)1585 static void set_has_duration(HasBits* has_bits) {
1586 (*has_bits)[0] |= 64u;
1587 }
set_has_thread_duration(HasBits * has_bits)1588 static void set_has_thread_duration(HasBits* has_bits) {
1589 (*has_bits)[0] |= 128u;
1590 }
set_has_scope(HasBits * has_bits)1591 static void set_has_scope(HasBits* has_bits) {
1592 (*has_bits)[0] |= 2u;
1593 }
set_has_id(HasBits * has_bits)1594 static void set_has_id(HasBits* has_bits) {
1595 (*has_bits)[0] |= 256u;
1596 }
set_has_flags(HasBits * has_bits)1597 static void set_has_flags(HasBits* has_bits) {
1598 (*has_bits)[0] |= 512u;
1599 }
set_has_category_group_name(HasBits * has_bits)1600 static void set_has_category_group_name(HasBits* has_bits) {
1601 (*has_bits)[0] |= 4u;
1602 }
set_has_process_id(HasBits * has_bits)1603 static void set_has_process_id(HasBits* has_bits) {
1604 (*has_bits)[0] |= 1024u;
1605 }
set_has_thread_timestamp(HasBits * has_bits)1606 static void set_has_thread_timestamp(HasBits* has_bits) {
1607 (*has_bits)[0] |= 2048u;
1608 }
set_has_bind_id(HasBits * has_bits)1609 static void set_has_bind_id(HasBits* has_bits) {
1610 (*has_bits)[0] |= 4096u;
1611 }
set_has_name_index(HasBits * has_bits)1612 static void set_has_name_index(HasBits* has_bits) {
1613 (*has_bits)[0] |= 8192u;
1614 }
set_has_category_group_name_index(HasBits * has_bits)1615 static void set_has_category_group_name_index(HasBits* has_bits) {
1616 (*has_bits)[0] |= 16384u;
1617 }
1618 };
1619
ChromeTraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1620 ChromeTraceEvent::ChromeTraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1621 bool is_message_owned)
1622 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1623 SharedCtor(arena, is_message_owned);
1624 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeTraceEvent)
1625 }
ChromeTraceEvent(const ChromeTraceEvent & from)1626 ChromeTraceEvent::ChromeTraceEvent(const ChromeTraceEvent& from)
1627 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1628 ChromeTraceEvent* const _this = this; (void)_this;
1629 new (&_impl_) Impl_{
1630 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1631 , /*decltype(_impl_._cached_size_)*/{}
1632 , decltype(_impl_.args_){from._impl_.args_}
1633 , decltype(_impl_.name_){}
1634 , decltype(_impl_.scope_){}
1635 , decltype(_impl_.category_group_name_){}
1636 , decltype(_impl_.timestamp_){}
1637 , decltype(_impl_.phase_){}
1638 , decltype(_impl_.thread_id_){}
1639 , decltype(_impl_.duration_){}
1640 , decltype(_impl_.thread_duration_){}
1641 , decltype(_impl_.id_){}
1642 , decltype(_impl_.flags_){}
1643 , decltype(_impl_.process_id_){}
1644 , decltype(_impl_.thread_timestamp_){}
1645 , decltype(_impl_.bind_id_){}
1646 , decltype(_impl_.name_index_){}
1647 , decltype(_impl_.category_group_name_index_){}};
1648
1649 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1650 _impl_.name_.InitDefault();
1651 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1652 _impl_.name_.Set("", GetArenaForAllocation());
1653 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1654 if (from._internal_has_name()) {
1655 _this->_impl_.name_.Set(from._internal_name(),
1656 _this->GetArenaForAllocation());
1657 }
1658 _impl_.scope_.InitDefault();
1659 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1660 _impl_.scope_.Set("", GetArenaForAllocation());
1661 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1662 if (from._internal_has_scope()) {
1663 _this->_impl_.scope_.Set(from._internal_scope(),
1664 _this->GetArenaForAllocation());
1665 }
1666 _impl_.category_group_name_.InitDefault();
1667 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1668 _impl_.category_group_name_.Set("", GetArenaForAllocation());
1669 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1670 if (from._internal_has_category_group_name()) {
1671 _this->_impl_.category_group_name_.Set(from._internal_category_group_name(),
1672 _this->GetArenaForAllocation());
1673 }
1674 ::memcpy(&_impl_.timestamp_, &from._impl_.timestamp_,
1675 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.category_group_name_index_) -
1676 reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.category_group_name_index_));
1677 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeTraceEvent)
1678 }
1679
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1680 inline void ChromeTraceEvent::SharedCtor(
1681 ::_pb::Arena* arena, bool is_message_owned) {
1682 (void)arena;
1683 (void)is_message_owned;
1684 new (&_impl_) Impl_{
1685 decltype(_impl_._has_bits_){}
1686 , /*decltype(_impl_._cached_size_)*/{}
1687 , decltype(_impl_.args_){arena}
1688 , decltype(_impl_.name_){}
1689 , decltype(_impl_.scope_){}
1690 , decltype(_impl_.category_group_name_){}
1691 , decltype(_impl_.timestamp_){::int64_t{0}}
1692 , decltype(_impl_.phase_){0}
1693 , decltype(_impl_.thread_id_){0}
1694 , decltype(_impl_.duration_){::int64_t{0}}
1695 , decltype(_impl_.thread_duration_){::int64_t{0}}
1696 , decltype(_impl_.id_){::uint64_t{0u}}
1697 , decltype(_impl_.flags_){0u}
1698 , decltype(_impl_.process_id_){0}
1699 , decltype(_impl_.thread_timestamp_){::int64_t{0}}
1700 , decltype(_impl_.bind_id_){::uint64_t{0u}}
1701 , decltype(_impl_.name_index_){0u}
1702 , decltype(_impl_.category_group_name_index_){0u}
1703 };
1704 _impl_.name_.InitDefault();
1705 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1706 _impl_.name_.Set("", GetArenaForAllocation());
1707 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1708 _impl_.scope_.InitDefault();
1709 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1710 _impl_.scope_.Set("", GetArenaForAllocation());
1711 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1712 _impl_.category_group_name_.InitDefault();
1713 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1714 _impl_.category_group_name_.Set("", GetArenaForAllocation());
1715 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1716 }
1717
~ChromeTraceEvent()1718 ChromeTraceEvent::~ChromeTraceEvent() {
1719 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeTraceEvent)
1720 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1721 (void)arena;
1722 return;
1723 }
1724 SharedDtor();
1725 }
1726
SharedDtor()1727 inline void ChromeTraceEvent::SharedDtor() {
1728 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1729 _impl_.args_.~RepeatedPtrField();
1730 _impl_.name_.Destroy();
1731 _impl_.scope_.Destroy();
1732 _impl_.category_group_name_.Destroy();
1733 }
1734
SetCachedSize(int size) const1735 void ChromeTraceEvent::SetCachedSize(int size) const {
1736 _impl_._cached_size_.Set(size);
1737 }
1738
Clear()1739 void ChromeTraceEvent::Clear() {
1740 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeTraceEvent)
1741 ::uint32_t cached_has_bits = 0;
1742 // Prevent compiler warnings about cached_has_bits being unused
1743 (void) cached_has_bits;
1744
1745 _impl_.args_.Clear();
1746 cached_has_bits = _impl_._has_bits_[0];
1747 if (cached_has_bits & 0x00000007u) {
1748 if (cached_has_bits & 0x00000001u) {
1749 _impl_.name_.ClearNonDefaultToEmpty();
1750 }
1751 if (cached_has_bits & 0x00000002u) {
1752 _impl_.scope_.ClearNonDefaultToEmpty();
1753 }
1754 if (cached_has_bits & 0x00000004u) {
1755 _impl_.category_group_name_.ClearNonDefaultToEmpty();
1756 }
1757 }
1758 if (cached_has_bits & 0x000000f8u) {
1759 ::memset(&_impl_.timestamp_, 0, static_cast<size_t>(
1760 reinterpret_cast<char*>(&_impl_.thread_duration_) -
1761 reinterpret_cast<char*>(&_impl_.timestamp_)) + sizeof(_impl_.thread_duration_));
1762 }
1763 if (cached_has_bits & 0x00007f00u) {
1764 ::memset(&_impl_.id_, 0, static_cast<size_t>(
1765 reinterpret_cast<char*>(&_impl_.category_group_name_index_) -
1766 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.category_group_name_index_));
1767 }
1768 _impl_._has_bits_.Clear();
1769 _internal_metadata_.Clear<std::string>();
1770 }
1771
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1772 const char* ChromeTraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1773 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1774 _Internal::HasBits has_bits{};
1775 while (!ctx->Done(&ptr)) {
1776 ::uint32_t tag;
1777 ptr = ::_pbi::ReadTag(ptr, &tag);
1778 switch (tag >> 3) {
1779 // optional string name = 1;
1780 case 1:
1781 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1782 auto str = _internal_mutable_name();
1783 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1784 CHK_(ptr);
1785 } else {
1786 goto handle_unusual;
1787 }
1788 continue;
1789 // optional int64 timestamp = 2;
1790 case 2:
1791 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1792 _Internal::set_has_timestamp(&has_bits);
1793 _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1794 CHK_(ptr);
1795 } else {
1796 goto handle_unusual;
1797 }
1798 continue;
1799 // optional int32 phase = 3;
1800 case 3:
1801 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1802 _Internal::set_has_phase(&has_bits);
1803 _impl_.phase_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1804 CHK_(ptr);
1805 } else {
1806 goto handle_unusual;
1807 }
1808 continue;
1809 // optional int32 thread_id = 4;
1810 case 4:
1811 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1812 _Internal::set_has_thread_id(&has_bits);
1813 _impl_.thread_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1814 CHK_(ptr);
1815 } else {
1816 goto handle_unusual;
1817 }
1818 continue;
1819 // optional int64 duration = 5;
1820 case 5:
1821 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1822 _Internal::set_has_duration(&has_bits);
1823 _impl_.duration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1824 CHK_(ptr);
1825 } else {
1826 goto handle_unusual;
1827 }
1828 continue;
1829 // optional int64 thread_duration = 6;
1830 case 6:
1831 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1832 _Internal::set_has_thread_duration(&has_bits);
1833 _impl_.thread_duration_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1834 CHK_(ptr);
1835 } else {
1836 goto handle_unusual;
1837 }
1838 continue;
1839 // optional string scope = 7;
1840 case 7:
1841 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
1842 auto str = _internal_mutable_scope();
1843 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1844 CHK_(ptr);
1845 } else {
1846 goto handle_unusual;
1847 }
1848 continue;
1849 // optional uint64 id = 8;
1850 case 8:
1851 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1852 _Internal::set_has_id(&has_bits);
1853 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1854 CHK_(ptr);
1855 } else {
1856 goto handle_unusual;
1857 }
1858 continue;
1859 // optional uint32 flags = 9;
1860 case 9:
1861 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1862 _Internal::set_has_flags(&has_bits);
1863 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1864 CHK_(ptr);
1865 } else {
1866 goto handle_unusual;
1867 }
1868 continue;
1869 // optional string category_group_name = 10;
1870 case 10:
1871 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
1872 auto str = _internal_mutable_category_group_name();
1873 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1874 CHK_(ptr);
1875 } else {
1876 goto handle_unusual;
1877 }
1878 continue;
1879 // optional int32 process_id = 11;
1880 case 11:
1881 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1882 _Internal::set_has_process_id(&has_bits);
1883 _impl_.process_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1884 CHK_(ptr);
1885 } else {
1886 goto handle_unusual;
1887 }
1888 continue;
1889 // optional int64 thread_timestamp = 12;
1890 case 12:
1891 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
1892 _Internal::set_has_thread_timestamp(&has_bits);
1893 _impl_.thread_timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1894 CHK_(ptr);
1895 } else {
1896 goto handle_unusual;
1897 }
1898 continue;
1899 // optional uint64 bind_id = 13;
1900 case 13:
1901 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
1902 _Internal::set_has_bind_id(&has_bits);
1903 _impl_.bind_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1904 CHK_(ptr);
1905 } else {
1906 goto handle_unusual;
1907 }
1908 continue;
1909 // repeated .perfetto.protos.ChromeTraceEvent.Arg args = 14;
1910 case 14:
1911 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 114)) {
1912 ptr -= 1;
1913 do {
1914 ptr += 1;
1915 ptr = ctx->ParseMessage(_internal_add_args(), ptr);
1916 CHK_(ptr);
1917 if (!ctx->DataAvailable(ptr)) break;
1918 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
1919 } else {
1920 goto handle_unusual;
1921 }
1922 continue;
1923 // optional uint32 name_index = 15;
1924 case 15:
1925 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
1926 _Internal::set_has_name_index(&has_bits);
1927 _impl_.name_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1928 CHK_(ptr);
1929 } else {
1930 goto handle_unusual;
1931 }
1932 continue;
1933 // optional uint32 category_group_name_index = 16;
1934 case 16:
1935 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
1936 _Internal::set_has_category_group_name_index(&has_bits);
1937 _impl_.category_group_name_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1938 CHK_(ptr);
1939 } else {
1940 goto handle_unusual;
1941 }
1942 continue;
1943 default:
1944 goto handle_unusual;
1945 } // switch
1946 handle_unusual:
1947 if ((tag == 0) || ((tag & 7) == 4)) {
1948 CHK_(ptr);
1949 ctx->SetLastTag(tag);
1950 goto message_done;
1951 }
1952 ptr = UnknownFieldParse(
1953 tag,
1954 _internal_metadata_.mutable_unknown_fields<std::string>(),
1955 ptr, ctx);
1956 CHK_(ptr != nullptr);
1957 } // while
1958 message_done:
1959 _impl_._has_bits_.Or(has_bits);
1960 return ptr;
1961 failure:
1962 ptr = nullptr;
1963 goto message_done;
1964 #undef CHK_
1965 }
1966
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1967 ::uint8_t* ChromeTraceEvent::_InternalSerialize(
1968 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1969 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeTraceEvent)
1970 ::uint32_t cached_has_bits = 0;
1971 (void) cached_has_bits;
1972
1973 cached_has_bits = _impl_._has_bits_[0];
1974 // optional string name = 1;
1975 if (cached_has_bits & 0x00000001u) {
1976 target = stream->WriteStringMaybeAliased(
1977 1, this->_internal_name(), target);
1978 }
1979
1980 // optional int64 timestamp = 2;
1981 if (cached_has_bits & 0x00000008u) {
1982 target = stream->EnsureSpace(target);
1983 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_timestamp(), target);
1984 }
1985
1986 // optional int32 phase = 3;
1987 if (cached_has_bits & 0x00000010u) {
1988 target = stream->EnsureSpace(target);
1989 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_phase(), target);
1990 }
1991
1992 // optional int32 thread_id = 4;
1993 if (cached_has_bits & 0x00000020u) {
1994 target = stream->EnsureSpace(target);
1995 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_thread_id(), target);
1996 }
1997
1998 // optional int64 duration = 5;
1999 if (cached_has_bits & 0x00000040u) {
2000 target = stream->EnsureSpace(target);
2001 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_duration(), target);
2002 }
2003
2004 // optional int64 thread_duration = 6;
2005 if (cached_has_bits & 0x00000080u) {
2006 target = stream->EnsureSpace(target);
2007 target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_thread_duration(), target);
2008 }
2009
2010 // optional string scope = 7;
2011 if (cached_has_bits & 0x00000002u) {
2012 target = stream->WriteStringMaybeAliased(
2013 7, this->_internal_scope(), target);
2014 }
2015
2016 // optional uint64 id = 8;
2017 if (cached_has_bits & 0x00000100u) {
2018 target = stream->EnsureSpace(target);
2019 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_id(), target);
2020 }
2021
2022 // optional uint32 flags = 9;
2023 if (cached_has_bits & 0x00000200u) {
2024 target = stream->EnsureSpace(target);
2025 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_flags(), target);
2026 }
2027
2028 // optional string category_group_name = 10;
2029 if (cached_has_bits & 0x00000004u) {
2030 target = stream->WriteStringMaybeAliased(
2031 10, this->_internal_category_group_name(), target);
2032 }
2033
2034 // optional int32 process_id = 11;
2035 if (cached_has_bits & 0x00000400u) {
2036 target = stream->EnsureSpace(target);
2037 target = ::_pbi::WireFormatLite::WriteInt32ToArray(11, this->_internal_process_id(), target);
2038 }
2039
2040 // optional int64 thread_timestamp = 12;
2041 if (cached_has_bits & 0x00000800u) {
2042 target = stream->EnsureSpace(target);
2043 target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_thread_timestamp(), target);
2044 }
2045
2046 // optional uint64 bind_id = 13;
2047 if (cached_has_bits & 0x00001000u) {
2048 target = stream->EnsureSpace(target);
2049 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(13, this->_internal_bind_id(), target);
2050 }
2051
2052 // repeated .perfetto.protos.ChromeTraceEvent.Arg args = 14;
2053 for (unsigned i = 0,
2054 n = static_cast<unsigned>(this->_internal_args_size()); i < n; i++) {
2055 const auto& repfield = this->_internal_args(i);
2056 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2057 InternalWriteMessage(14, repfield, repfield.GetCachedSize(), target, stream);
2058 }
2059
2060 // optional uint32 name_index = 15;
2061 if (cached_has_bits & 0x00002000u) {
2062 target = stream->EnsureSpace(target);
2063 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(15, this->_internal_name_index(), target);
2064 }
2065
2066 // optional uint32 category_group_name_index = 16;
2067 if (cached_has_bits & 0x00004000u) {
2068 target = stream->EnsureSpace(target);
2069 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_category_group_name_index(), target);
2070 }
2071
2072 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2073 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2074 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2075 }
2076 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeTraceEvent)
2077 return target;
2078 }
2079
ByteSizeLong() const2080 size_t ChromeTraceEvent::ByteSizeLong() const {
2081 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeTraceEvent)
2082 size_t total_size = 0;
2083
2084 ::uint32_t cached_has_bits = 0;
2085 // Prevent compiler warnings about cached_has_bits being unused
2086 (void) cached_has_bits;
2087
2088 // repeated .perfetto.protos.ChromeTraceEvent.Arg args = 14;
2089 total_size += 1UL * this->_internal_args_size();
2090 for (const auto& msg : this->_impl_.args_) {
2091 total_size +=
2092 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2093 }
2094
2095 cached_has_bits = _impl_._has_bits_[0];
2096 if (cached_has_bits & 0x000000ffu) {
2097 // optional string name = 1;
2098 if (cached_has_bits & 0x00000001u) {
2099 total_size += 1 +
2100 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2101 this->_internal_name());
2102 }
2103
2104 // optional string scope = 7;
2105 if (cached_has_bits & 0x00000002u) {
2106 total_size += 1 +
2107 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2108 this->_internal_scope());
2109 }
2110
2111 // optional string category_group_name = 10;
2112 if (cached_has_bits & 0x00000004u) {
2113 total_size += 1 +
2114 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2115 this->_internal_category_group_name());
2116 }
2117
2118 // optional int64 timestamp = 2;
2119 if (cached_has_bits & 0x00000008u) {
2120 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp());
2121 }
2122
2123 // optional int32 phase = 3;
2124 if (cached_has_bits & 0x00000010u) {
2125 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_phase());
2126 }
2127
2128 // optional int32 thread_id = 4;
2129 if (cached_has_bits & 0x00000020u) {
2130 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_thread_id());
2131 }
2132
2133 // optional int64 duration = 5;
2134 if (cached_has_bits & 0x00000040u) {
2135 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_duration());
2136 }
2137
2138 // optional int64 thread_duration = 6;
2139 if (cached_has_bits & 0x00000080u) {
2140 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_thread_duration());
2141 }
2142
2143 }
2144 if (cached_has_bits & 0x00007f00u) {
2145 // optional uint64 id = 8;
2146 if (cached_has_bits & 0x00000100u) {
2147 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
2148 }
2149
2150 // optional uint32 flags = 9;
2151 if (cached_has_bits & 0x00000200u) {
2152 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
2153 }
2154
2155 // optional int32 process_id = 11;
2156 if (cached_has_bits & 0x00000400u) {
2157 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_process_id());
2158 }
2159
2160 // optional int64 thread_timestamp = 12;
2161 if (cached_has_bits & 0x00000800u) {
2162 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_thread_timestamp());
2163 }
2164
2165 // optional uint64 bind_id = 13;
2166 if (cached_has_bits & 0x00001000u) {
2167 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bind_id());
2168 }
2169
2170 // optional uint32 name_index = 15;
2171 if (cached_has_bits & 0x00002000u) {
2172 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_name_index());
2173 }
2174
2175 // optional uint32 category_group_name_index = 16;
2176 if (cached_has_bits & 0x00004000u) {
2177 total_size += 2 +
2178 ::_pbi::WireFormatLite::UInt32Size(
2179 this->_internal_category_group_name_index());
2180 }
2181
2182 }
2183 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2184 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2185 }
2186 int cached_size = ::_pbi::ToCachedSize(total_size);
2187 SetCachedSize(cached_size);
2188 return total_size;
2189 }
2190
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2191 void ChromeTraceEvent::CheckTypeAndMergeFrom(
2192 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2193 MergeFrom(*::_pbi::DownCast<const ChromeTraceEvent*>(
2194 &from));
2195 }
2196
MergeFrom(const ChromeTraceEvent & from)2197 void ChromeTraceEvent::MergeFrom(const ChromeTraceEvent& from) {
2198 ChromeTraceEvent* const _this = this;
2199 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeTraceEvent)
2200 GOOGLE_DCHECK_NE(&from, _this);
2201 ::uint32_t cached_has_bits = 0;
2202 (void) cached_has_bits;
2203
2204 _this->_impl_.args_.MergeFrom(from._impl_.args_);
2205 cached_has_bits = from._impl_._has_bits_[0];
2206 if (cached_has_bits & 0x000000ffu) {
2207 if (cached_has_bits & 0x00000001u) {
2208 _this->_internal_set_name(from._internal_name());
2209 }
2210 if (cached_has_bits & 0x00000002u) {
2211 _this->_internal_set_scope(from._internal_scope());
2212 }
2213 if (cached_has_bits & 0x00000004u) {
2214 _this->_internal_set_category_group_name(from._internal_category_group_name());
2215 }
2216 if (cached_has_bits & 0x00000008u) {
2217 _this->_impl_.timestamp_ = from._impl_.timestamp_;
2218 }
2219 if (cached_has_bits & 0x00000010u) {
2220 _this->_impl_.phase_ = from._impl_.phase_;
2221 }
2222 if (cached_has_bits & 0x00000020u) {
2223 _this->_impl_.thread_id_ = from._impl_.thread_id_;
2224 }
2225 if (cached_has_bits & 0x00000040u) {
2226 _this->_impl_.duration_ = from._impl_.duration_;
2227 }
2228 if (cached_has_bits & 0x00000080u) {
2229 _this->_impl_.thread_duration_ = from._impl_.thread_duration_;
2230 }
2231 _this->_impl_._has_bits_[0] |= cached_has_bits;
2232 }
2233 if (cached_has_bits & 0x00007f00u) {
2234 if (cached_has_bits & 0x00000100u) {
2235 _this->_impl_.id_ = from._impl_.id_;
2236 }
2237 if (cached_has_bits & 0x00000200u) {
2238 _this->_impl_.flags_ = from._impl_.flags_;
2239 }
2240 if (cached_has_bits & 0x00000400u) {
2241 _this->_impl_.process_id_ = from._impl_.process_id_;
2242 }
2243 if (cached_has_bits & 0x00000800u) {
2244 _this->_impl_.thread_timestamp_ = from._impl_.thread_timestamp_;
2245 }
2246 if (cached_has_bits & 0x00001000u) {
2247 _this->_impl_.bind_id_ = from._impl_.bind_id_;
2248 }
2249 if (cached_has_bits & 0x00002000u) {
2250 _this->_impl_.name_index_ = from._impl_.name_index_;
2251 }
2252 if (cached_has_bits & 0x00004000u) {
2253 _this->_impl_.category_group_name_index_ = from._impl_.category_group_name_index_;
2254 }
2255 _this->_impl_._has_bits_[0] |= cached_has_bits;
2256 }
2257 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2258 }
2259
CopyFrom(const ChromeTraceEvent & from)2260 void ChromeTraceEvent::CopyFrom(const ChromeTraceEvent& from) {
2261 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeTraceEvent)
2262 if (&from == this) return;
2263 Clear();
2264 MergeFrom(from);
2265 }
2266
IsInitialized() const2267 bool ChromeTraceEvent::IsInitialized() const {
2268 return true;
2269 }
2270
InternalSwap(ChromeTraceEvent * other)2271 void ChromeTraceEvent::InternalSwap(ChromeTraceEvent* other) {
2272 using std::swap;
2273 auto* lhs_arena = GetArenaForAllocation();
2274 auto* rhs_arena = other->GetArenaForAllocation();
2275 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2276 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2277 _impl_.args_.InternalSwap(&other->_impl_.args_);
2278 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2279 &_impl_.name_, lhs_arena,
2280 &other->_impl_.name_, rhs_arena
2281 );
2282 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2283 &_impl_.scope_, lhs_arena,
2284 &other->_impl_.scope_, rhs_arena
2285 );
2286 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2287 &_impl_.category_group_name_, lhs_arena,
2288 &other->_impl_.category_group_name_, rhs_arena
2289 );
2290 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2291 PROTOBUF_FIELD_OFFSET(ChromeTraceEvent, _impl_.category_group_name_index_)
2292 + sizeof(ChromeTraceEvent::_impl_.category_group_name_index_) // NOLINT
2293 - PROTOBUF_FIELD_OFFSET(ChromeTraceEvent, _impl_.timestamp_)>(
2294 reinterpret_cast<char*>(&_impl_.timestamp_),
2295 reinterpret_cast<char*>(&other->_impl_.timestamp_));
2296 }
2297
GetTypeName() const2298 std::string ChromeTraceEvent::GetTypeName() const {
2299 return "perfetto.protos.ChromeTraceEvent";
2300 }
2301
2302
2303 // ===================================================================
2304
2305 class ChromeMetadata::_Internal {
2306 public:
2307 using HasBits = decltype(std::declval<ChromeMetadata>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)2308 static void set_has_name(HasBits* has_bits) {
2309 (*has_bits)[0] |= 1u;
2310 }
2311 };
2312
ChromeMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2313 ChromeMetadata::ChromeMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2314 bool is_message_owned)
2315 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2316 SharedCtor(arena, is_message_owned);
2317 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeMetadata)
2318 }
ChromeMetadata(const ChromeMetadata & from)2319 ChromeMetadata::ChromeMetadata(const ChromeMetadata& from)
2320 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2321 ChromeMetadata* const _this = this; (void)_this;
2322 new (&_impl_) Impl_{
2323 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2324 , /*decltype(_impl_._cached_size_)*/{}
2325 , decltype(_impl_.name_){}
2326 , decltype(_impl_.value_){}
2327 , /*decltype(_impl_._oneof_case_)*/{}};
2328
2329 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2330 _impl_.name_.InitDefault();
2331 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2332 _impl_.name_.Set("", GetArenaForAllocation());
2333 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2334 if (from._internal_has_name()) {
2335 _this->_impl_.name_.Set(from._internal_name(),
2336 _this->GetArenaForAllocation());
2337 }
2338 clear_has_value();
2339 switch (from.value_case()) {
2340 case kStringValue: {
2341 _this->_internal_set_string_value(from._internal_string_value());
2342 break;
2343 }
2344 case kBoolValue: {
2345 _this->_internal_set_bool_value(from._internal_bool_value());
2346 break;
2347 }
2348 case kIntValue: {
2349 _this->_internal_set_int_value(from._internal_int_value());
2350 break;
2351 }
2352 case kJsonValue: {
2353 _this->_internal_set_json_value(from._internal_json_value());
2354 break;
2355 }
2356 case VALUE_NOT_SET: {
2357 break;
2358 }
2359 }
2360 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeMetadata)
2361 }
2362
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2363 inline void ChromeMetadata::SharedCtor(
2364 ::_pb::Arena* arena, bool is_message_owned) {
2365 (void)arena;
2366 (void)is_message_owned;
2367 new (&_impl_) Impl_{
2368 decltype(_impl_._has_bits_){}
2369 , /*decltype(_impl_._cached_size_)*/{}
2370 , decltype(_impl_.name_){}
2371 , decltype(_impl_.value_){}
2372 , /*decltype(_impl_._oneof_case_)*/{}
2373 };
2374 _impl_.name_.InitDefault();
2375 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2376 _impl_.name_.Set("", GetArenaForAllocation());
2377 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2378 clear_has_value();
2379 }
2380
~ChromeMetadata()2381 ChromeMetadata::~ChromeMetadata() {
2382 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeMetadata)
2383 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2384 (void)arena;
2385 return;
2386 }
2387 SharedDtor();
2388 }
2389
SharedDtor()2390 inline void ChromeMetadata::SharedDtor() {
2391 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2392 _impl_.name_.Destroy();
2393 if (has_value()) {
2394 clear_value();
2395 }
2396 }
2397
SetCachedSize(int size) const2398 void ChromeMetadata::SetCachedSize(int size) const {
2399 _impl_._cached_size_.Set(size);
2400 }
2401
clear_value()2402 void ChromeMetadata::clear_value() {
2403 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.ChromeMetadata)
2404 switch (value_case()) {
2405 case kStringValue: {
2406 _impl_.value_.string_value_.Destroy();
2407 break;
2408 }
2409 case kBoolValue: {
2410 // No need to clear
2411 break;
2412 }
2413 case kIntValue: {
2414 // No need to clear
2415 break;
2416 }
2417 case kJsonValue: {
2418 _impl_.value_.json_value_.Destroy();
2419 break;
2420 }
2421 case VALUE_NOT_SET: {
2422 break;
2423 }
2424 }
2425 _impl_._oneof_case_[0] = VALUE_NOT_SET;
2426 }
2427
2428
Clear()2429 void ChromeMetadata::Clear() {
2430 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeMetadata)
2431 ::uint32_t cached_has_bits = 0;
2432 // Prevent compiler warnings about cached_has_bits being unused
2433 (void) cached_has_bits;
2434
2435 cached_has_bits = _impl_._has_bits_[0];
2436 if (cached_has_bits & 0x00000001u) {
2437 _impl_.name_.ClearNonDefaultToEmpty();
2438 }
2439 clear_value();
2440 _impl_._has_bits_.Clear();
2441 _internal_metadata_.Clear<std::string>();
2442 }
2443
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2444 const char* ChromeMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2445 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2446 _Internal::HasBits has_bits{};
2447 while (!ctx->Done(&ptr)) {
2448 ::uint32_t tag;
2449 ptr = ::_pbi::ReadTag(ptr, &tag);
2450 switch (tag >> 3) {
2451 // optional string name = 1;
2452 case 1:
2453 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2454 auto str = _internal_mutable_name();
2455 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2456 CHK_(ptr);
2457 } else {
2458 goto handle_unusual;
2459 }
2460 continue;
2461 // string string_value = 2;
2462 case 2:
2463 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2464 auto str = _internal_mutable_string_value();
2465 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2466 CHK_(ptr);
2467 } else {
2468 goto handle_unusual;
2469 }
2470 continue;
2471 // bool bool_value = 3;
2472 case 3:
2473 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2474 _internal_set_bool_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
2475 CHK_(ptr);
2476 } else {
2477 goto handle_unusual;
2478 }
2479 continue;
2480 // int64 int_value = 4;
2481 case 4:
2482 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2483 _internal_set_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
2484 CHK_(ptr);
2485 } else {
2486 goto handle_unusual;
2487 }
2488 continue;
2489 // string json_value = 5;
2490 case 5:
2491 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2492 auto str = _internal_mutable_json_value();
2493 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2494 CHK_(ptr);
2495 } else {
2496 goto handle_unusual;
2497 }
2498 continue;
2499 default:
2500 goto handle_unusual;
2501 } // switch
2502 handle_unusual:
2503 if ((tag == 0) || ((tag & 7) == 4)) {
2504 CHK_(ptr);
2505 ctx->SetLastTag(tag);
2506 goto message_done;
2507 }
2508 ptr = UnknownFieldParse(
2509 tag,
2510 _internal_metadata_.mutable_unknown_fields<std::string>(),
2511 ptr, ctx);
2512 CHK_(ptr != nullptr);
2513 } // while
2514 message_done:
2515 _impl_._has_bits_.Or(has_bits);
2516 return ptr;
2517 failure:
2518 ptr = nullptr;
2519 goto message_done;
2520 #undef CHK_
2521 }
2522
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2523 ::uint8_t* ChromeMetadata::_InternalSerialize(
2524 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2525 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeMetadata)
2526 ::uint32_t cached_has_bits = 0;
2527 (void) cached_has_bits;
2528
2529 cached_has_bits = _impl_._has_bits_[0];
2530 // optional string name = 1;
2531 if (cached_has_bits & 0x00000001u) {
2532 target = stream->WriteStringMaybeAliased(
2533 1, this->_internal_name(), target);
2534 }
2535
2536 switch (value_case()) {
2537 case kStringValue: {
2538 target = stream->WriteStringMaybeAliased(
2539 2, this->_internal_string_value(), target);
2540 break;
2541 }
2542 case kBoolValue: {
2543 target = stream->EnsureSpace(target);
2544 target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_bool_value(), target);
2545 break;
2546 }
2547 case kIntValue: {
2548 target = stream->EnsureSpace(target);
2549 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_int_value(), target);
2550 break;
2551 }
2552 case kJsonValue: {
2553 target = stream->WriteStringMaybeAliased(
2554 5, this->_internal_json_value(), target);
2555 break;
2556 }
2557 default: ;
2558 }
2559 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2560 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2561 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2562 }
2563 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeMetadata)
2564 return target;
2565 }
2566
ByteSizeLong() const2567 size_t ChromeMetadata::ByteSizeLong() const {
2568 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeMetadata)
2569 size_t total_size = 0;
2570
2571 ::uint32_t cached_has_bits = 0;
2572 // Prevent compiler warnings about cached_has_bits being unused
2573 (void) cached_has_bits;
2574
2575 // optional string name = 1;
2576 cached_has_bits = _impl_._has_bits_[0];
2577 if (cached_has_bits & 0x00000001u) {
2578 total_size += 1 +
2579 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2580 this->_internal_name());
2581 }
2582
2583 switch (value_case()) {
2584 // string string_value = 2;
2585 case kStringValue: {
2586 total_size += 1 +
2587 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2588 this->_internal_string_value());
2589 break;
2590 }
2591 // bool bool_value = 3;
2592 case kBoolValue: {
2593 total_size += 1 + 1;
2594 break;
2595 }
2596 // int64 int_value = 4;
2597 case kIntValue: {
2598 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_int_value());
2599 break;
2600 }
2601 // string json_value = 5;
2602 case kJsonValue: {
2603 total_size += 1 +
2604 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2605 this->_internal_json_value());
2606 break;
2607 }
2608 case VALUE_NOT_SET: {
2609 break;
2610 }
2611 }
2612 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2613 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2614 }
2615 int cached_size = ::_pbi::ToCachedSize(total_size);
2616 SetCachedSize(cached_size);
2617 return total_size;
2618 }
2619
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2620 void ChromeMetadata::CheckTypeAndMergeFrom(
2621 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2622 MergeFrom(*::_pbi::DownCast<const ChromeMetadata*>(
2623 &from));
2624 }
2625
MergeFrom(const ChromeMetadata & from)2626 void ChromeMetadata::MergeFrom(const ChromeMetadata& from) {
2627 ChromeMetadata* const _this = this;
2628 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeMetadata)
2629 GOOGLE_DCHECK_NE(&from, _this);
2630 ::uint32_t cached_has_bits = 0;
2631 (void) cached_has_bits;
2632
2633 if (from._internal_has_name()) {
2634 _this->_internal_set_name(from._internal_name());
2635 }
2636 switch (from.value_case()) {
2637 case kStringValue: {
2638 _this->_internal_set_string_value(from._internal_string_value());
2639 break;
2640 }
2641 case kBoolValue: {
2642 _this->_internal_set_bool_value(from._internal_bool_value());
2643 break;
2644 }
2645 case kIntValue: {
2646 _this->_internal_set_int_value(from._internal_int_value());
2647 break;
2648 }
2649 case kJsonValue: {
2650 _this->_internal_set_json_value(from._internal_json_value());
2651 break;
2652 }
2653 case VALUE_NOT_SET: {
2654 break;
2655 }
2656 }
2657 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2658 }
2659
CopyFrom(const ChromeMetadata & from)2660 void ChromeMetadata::CopyFrom(const ChromeMetadata& from) {
2661 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeMetadata)
2662 if (&from == this) return;
2663 Clear();
2664 MergeFrom(from);
2665 }
2666
IsInitialized() const2667 bool ChromeMetadata::IsInitialized() const {
2668 return true;
2669 }
2670
InternalSwap(ChromeMetadata * other)2671 void ChromeMetadata::InternalSwap(ChromeMetadata* other) {
2672 using std::swap;
2673 auto* lhs_arena = GetArenaForAllocation();
2674 auto* rhs_arena = other->GetArenaForAllocation();
2675 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2676 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2677 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2678 &_impl_.name_, lhs_arena,
2679 &other->_impl_.name_, rhs_arena
2680 );
2681 swap(_impl_.value_, other->_impl_.value_);
2682 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
2683 }
2684
GetTypeName() const2685 std::string ChromeMetadata::GetTypeName() const {
2686 return "perfetto.protos.ChromeMetadata";
2687 }
2688
2689
2690 // ===================================================================
2691
2692 class ChromeLegacyJsonTrace::_Internal {
2693 public:
2694 using HasBits = decltype(std::declval<ChromeLegacyJsonTrace>()._impl_._has_bits_);
set_has_type(HasBits * has_bits)2695 static void set_has_type(HasBits* has_bits) {
2696 (*has_bits)[0] |= 2u;
2697 }
set_has_data(HasBits * has_bits)2698 static void set_has_data(HasBits* has_bits) {
2699 (*has_bits)[0] |= 1u;
2700 }
2701 };
2702
ChromeLegacyJsonTrace(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2703 ChromeLegacyJsonTrace::ChromeLegacyJsonTrace(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2704 bool is_message_owned)
2705 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2706 SharedCtor(arena, is_message_owned);
2707 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeLegacyJsonTrace)
2708 }
ChromeLegacyJsonTrace(const ChromeLegacyJsonTrace & from)2709 ChromeLegacyJsonTrace::ChromeLegacyJsonTrace(const ChromeLegacyJsonTrace& from)
2710 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2711 ChromeLegacyJsonTrace* const _this = this; (void)_this;
2712 new (&_impl_) Impl_{
2713 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2714 , /*decltype(_impl_._cached_size_)*/{}
2715 , decltype(_impl_.data_){}
2716 , decltype(_impl_.type_){}};
2717
2718 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2719 _impl_.data_.InitDefault();
2720 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2721 _impl_.data_.Set("", GetArenaForAllocation());
2722 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2723 if (from._internal_has_data()) {
2724 _this->_impl_.data_.Set(from._internal_data(),
2725 _this->GetArenaForAllocation());
2726 }
2727 _this->_impl_.type_ = from._impl_.type_;
2728 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeLegacyJsonTrace)
2729 }
2730
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2731 inline void ChromeLegacyJsonTrace::SharedCtor(
2732 ::_pb::Arena* arena, bool is_message_owned) {
2733 (void)arena;
2734 (void)is_message_owned;
2735 new (&_impl_) Impl_{
2736 decltype(_impl_._has_bits_){}
2737 , /*decltype(_impl_._cached_size_)*/{}
2738 , decltype(_impl_.data_){}
2739 , decltype(_impl_.type_){0}
2740 };
2741 _impl_.data_.InitDefault();
2742 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2743 _impl_.data_.Set("", GetArenaForAllocation());
2744 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2745 }
2746
~ChromeLegacyJsonTrace()2747 ChromeLegacyJsonTrace::~ChromeLegacyJsonTrace() {
2748 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeLegacyJsonTrace)
2749 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2750 (void)arena;
2751 return;
2752 }
2753 SharedDtor();
2754 }
2755
SharedDtor()2756 inline void ChromeLegacyJsonTrace::SharedDtor() {
2757 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2758 _impl_.data_.Destroy();
2759 }
2760
SetCachedSize(int size) const2761 void ChromeLegacyJsonTrace::SetCachedSize(int size) const {
2762 _impl_._cached_size_.Set(size);
2763 }
2764
Clear()2765 void ChromeLegacyJsonTrace::Clear() {
2766 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeLegacyJsonTrace)
2767 ::uint32_t cached_has_bits = 0;
2768 // Prevent compiler warnings about cached_has_bits being unused
2769 (void) cached_has_bits;
2770
2771 cached_has_bits = _impl_._has_bits_[0];
2772 if (cached_has_bits & 0x00000001u) {
2773 _impl_.data_.ClearNonDefaultToEmpty();
2774 }
2775 _impl_.type_ = 0;
2776 _impl_._has_bits_.Clear();
2777 _internal_metadata_.Clear<std::string>();
2778 }
2779
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2780 const char* ChromeLegacyJsonTrace::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2781 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2782 _Internal::HasBits has_bits{};
2783 while (!ctx->Done(&ptr)) {
2784 ::uint32_t tag;
2785 ptr = ::_pbi::ReadTag(ptr, &tag);
2786 switch (tag >> 3) {
2787 // optional .perfetto.protos.ChromeLegacyJsonTrace.TraceType type = 1;
2788 case 1:
2789 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2790 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2791 CHK_(ptr);
2792 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeLegacyJsonTrace_TraceType_IsValid(val))) {
2793 _internal_set_type(static_cast<::perfetto::protos::ChromeLegacyJsonTrace_TraceType>(val));
2794 } else {
2795 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
2796 }
2797 } else {
2798 goto handle_unusual;
2799 }
2800 continue;
2801 // optional string data = 2;
2802 case 2:
2803 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2804 auto str = _internal_mutable_data();
2805 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2806 CHK_(ptr);
2807 } else {
2808 goto handle_unusual;
2809 }
2810 continue;
2811 default:
2812 goto handle_unusual;
2813 } // switch
2814 handle_unusual:
2815 if ((tag == 0) || ((tag & 7) == 4)) {
2816 CHK_(ptr);
2817 ctx->SetLastTag(tag);
2818 goto message_done;
2819 }
2820 ptr = UnknownFieldParse(
2821 tag,
2822 _internal_metadata_.mutable_unknown_fields<std::string>(),
2823 ptr, ctx);
2824 CHK_(ptr != nullptr);
2825 } // while
2826 message_done:
2827 _impl_._has_bits_.Or(has_bits);
2828 return ptr;
2829 failure:
2830 ptr = nullptr;
2831 goto message_done;
2832 #undef CHK_
2833 }
2834
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2835 ::uint8_t* ChromeLegacyJsonTrace::_InternalSerialize(
2836 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2837 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeLegacyJsonTrace)
2838 ::uint32_t cached_has_bits = 0;
2839 (void) cached_has_bits;
2840
2841 cached_has_bits = _impl_._has_bits_[0];
2842 // optional .perfetto.protos.ChromeLegacyJsonTrace.TraceType type = 1;
2843 if (cached_has_bits & 0x00000002u) {
2844 target = stream->EnsureSpace(target);
2845 target = ::_pbi::WireFormatLite::WriteEnumToArray(
2846 1, this->_internal_type(), target);
2847 }
2848
2849 // optional string data = 2;
2850 if (cached_has_bits & 0x00000001u) {
2851 target = stream->WriteStringMaybeAliased(
2852 2, this->_internal_data(), target);
2853 }
2854
2855 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2856 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2857 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2858 }
2859 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeLegacyJsonTrace)
2860 return target;
2861 }
2862
ByteSizeLong() const2863 size_t ChromeLegacyJsonTrace::ByteSizeLong() const {
2864 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeLegacyJsonTrace)
2865 size_t total_size = 0;
2866
2867 ::uint32_t cached_has_bits = 0;
2868 // Prevent compiler warnings about cached_has_bits being unused
2869 (void) cached_has_bits;
2870
2871 cached_has_bits = _impl_._has_bits_[0];
2872 if (cached_has_bits & 0x00000003u) {
2873 // optional string data = 2;
2874 if (cached_has_bits & 0x00000001u) {
2875 total_size += 1 +
2876 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2877 this->_internal_data());
2878 }
2879
2880 // optional .perfetto.protos.ChromeLegacyJsonTrace.TraceType type = 1;
2881 if (cached_has_bits & 0x00000002u) {
2882 total_size += 1 +
2883 ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
2884 }
2885
2886 }
2887 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2888 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2889 }
2890 int cached_size = ::_pbi::ToCachedSize(total_size);
2891 SetCachedSize(cached_size);
2892 return total_size;
2893 }
2894
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2895 void ChromeLegacyJsonTrace::CheckTypeAndMergeFrom(
2896 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2897 MergeFrom(*::_pbi::DownCast<const ChromeLegacyJsonTrace*>(
2898 &from));
2899 }
2900
MergeFrom(const ChromeLegacyJsonTrace & from)2901 void ChromeLegacyJsonTrace::MergeFrom(const ChromeLegacyJsonTrace& from) {
2902 ChromeLegacyJsonTrace* const _this = this;
2903 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeLegacyJsonTrace)
2904 GOOGLE_DCHECK_NE(&from, _this);
2905 ::uint32_t cached_has_bits = 0;
2906 (void) cached_has_bits;
2907
2908 cached_has_bits = from._impl_._has_bits_[0];
2909 if (cached_has_bits & 0x00000003u) {
2910 if (cached_has_bits & 0x00000001u) {
2911 _this->_internal_set_data(from._internal_data());
2912 }
2913 if (cached_has_bits & 0x00000002u) {
2914 _this->_impl_.type_ = from._impl_.type_;
2915 }
2916 _this->_impl_._has_bits_[0] |= cached_has_bits;
2917 }
2918 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2919 }
2920
CopyFrom(const ChromeLegacyJsonTrace & from)2921 void ChromeLegacyJsonTrace::CopyFrom(const ChromeLegacyJsonTrace& from) {
2922 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeLegacyJsonTrace)
2923 if (&from == this) return;
2924 Clear();
2925 MergeFrom(from);
2926 }
2927
IsInitialized() const2928 bool ChromeLegacyJsonTrace::IsInitialized() const {
2929 return true;
2930 }
2931
InternalSwap(ChromeLegacyJsonTrace * other)2932 void ChromeLegacyJsonTrace::InternalSwap(ChromeLegacyJsonTrace* other) {
2933 using std::swap;
2934 auto* lhs_arena = GetArenaForAllocation();
2935 auto* rhs_arena = other->GetArenaForAllocation();
2936 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2937 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2938 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2939 &_impl_.data_, lhs_arena,
2940 &other->_impl_.data_, rhs_arena
2941 );
2942 swap(_impl_.type_, other->_impl_.type_);
2943 }
2944
GetTypeName() const2945 std::string ChromeLegacyJsonTrace::GetTypeName() const {
2946 return "perfetto.protos.ChromeLegacyJsonTrace";
2947 }
2948
2949
2950 // ===================================================================
2951
2952 class ChromeEventBundle::_Internal {
2953 public:
2954 };
2955
ChromeEventBundle(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2956 ChromeEventBundle::ChromeEventBundle(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2957 bool is_message_owned)
2958 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2959 SharedCtor(arena, is_message_owned);
2960 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeEventBundle)
2961 }
ChromeEventBundle(const ChromeEventBundle & from)2962 ChromeEventBundle::ChromeEventBundle(const ChromeEventBundle& from)
2963 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2964 ChromeEventBundle* const _this = this; (void)_this;
2965 new (&_impl_) Impl_{
2966 decltype(_impl_.trace_events_){from._impl_.trace_events_}
2967 , decltype(_impl_.metadata_){from._impl_.metadata_}
2968 , decltype(_impl_.string_table_){from._impl_.string_table_}
2969 , decltype(_impl_.legacy_ftrace_output_){from._impl_.legacy_ftrace_output_}
2970 , decltype(_impl_.legacy_json_trace_){from._impl_.legacy_json_trace_}
2971 , /*decltype(_impl_._cached_size_)*/{}};
2972
2973 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2974 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeEventBundle)
2975 }
2976
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2977 inline void ChromeEventBundle::SharedCtor(
2978 ::_pb::Arena* arena, bool is_message_owned) {
2979 (void)arena;
2980 (void)is_message_owned;
2981 new (&_impl_) Impl_{
2982 decltype(_impl_.trace_events_){arena}
2983 , decltype(_impl_.metadata_){arena}
2984 , decltype(_impl_.string_table_){arena}
2985 , decltype(_impl_.legacy_ftrace_output_){arena}
2986 , decltype(_impl_.legacy_json_trace_){arena}
2987 , /*decltype(_impl_._cached_size_)*/{}
2988 };
2989 }
2990
~ChromeEventBundle()2991 ChromeEventBundle::~ChromeEventBundle() {
2992 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeEventBundle)
2993 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2994 (void)arena;
2995 return;
2996 }
2997 SharedDtor();
2998 }
2999
SharedDtor()3000 inline void ChromeEventBundle::SharedDtor() {
3001 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3002 _impl_.trace_events_.~RepeatedPtrField();
3003 _impl_.metadata_.~RepeatedPtrField();
3004 _impl_.string_table_.~RepeatedPtrField();
3005 _impl_.legacy_ftrace_output_.~RepeatedPtrField();
3006 _impl_.legacy_json_trace_.~RepeatedPtrField();
3007 }
3008
SetCachedSize(int size) const3009 void ChromeEventBundle::SetCachedSize(int size) const {
3010 _impl_._cached_size_.Set(size);
3011 }
3012
Clear()3013 void ChromeEventBundle::Clear() {
3014 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeEventBundle)
3015 ::uint32_t cached_has_bits = 0;
3016 // Prevent compiler warnings about cached_has_bits being unused
3017 (void) cached_has_bits;
3018
3019 _impl_.trace_events_.Clear();
3020 _impl_.metadata_.Clear();
3021 _impl_.string_table_.Clear();
3022 _impl_.legacy_ftrace_output_.Clear();
3023 _impl_.legacy_json_trace_.Clear();
3024 _internal_metadata_.Clear<std::string>();
3025 }
3026
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3027 const char* ChromeEventBundle::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3028 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3029 while (!ctx->Done(&ptr)) {
3030 ::uint32_t tag;
3031 ptr = ::_pbi::ReadTag(ptr, &tag);
3032 switch (tag >> 3) {
3033 // repeated .perfetto.protos.ChromeTraceEvent trace_events = 1 [deprecated = true];
3034 case 1:
3035 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3036 ptr -= 1;
3037 do {
3038 ptr += 1;
3039 ptr = ctx->ParseMessage(_internal_add_trace_events(), ptr);
3040 CHK_(ptr);
3041 if (!ctx->DataAvailable(ptr)) break;
3042 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
3043 } else {
3044 goto handle_unusual;
3045 }
3046 continue;
3047 // repeated .perfetto.protos.ChromeMetadata metadata = 2;
3048 case 2:
3049 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3050 ptr -= 1;
3051 do {
3052 ptr += 1;
3053 ptr = ctx->ParseMessage(_internal_add_metadata(), ptr);
3054 CHK_(ptr);
3055 if (!ctx->DataAvailable(ptr)) break;
3056 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
3057 } else {
3058 goto handle_unusual;
3059 }
3060 continue;
3061 // repeated .perfetto.protos.ChromeStringTableEntry string_table = 3 [deprecated = true];
3062 case 3:
3063 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
3064 ptr -= 1;
3065 do {
3066 ptr += 1;
3067 ptr = ctx->ParseMessage(_internal_add_string_table(), ptr);
3068 CHK_(ptr);
3069 if (!ctx->DataAvailable(ptr)) break;
3070 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
3071 } else {
3072 goto handle_unusual;
3073 }
3074 continue;
3075 // repeated string legacy_ftrace_output = 4;
3076 case 4:
3077 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
3078 ptr -= 1;
3079 do {
3080 ptr += 1;
3081 auto str = _internal_add_legacy_ftrace_output();
3082 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3083 CHK_(ptr);
3084 if (!ctx->DataAvailable(ptr)) break;
3085 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
3086 } else {
3087 goto handle_unusual;
3088 }
3089 continue;
3090 // repeated .perfetto.protos.ChromeLegacyJsonTrace legacy_json_trace = 5;
3091 case 5:
3092 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
3093 ptr -= 1;
3094 do {
3095 ptr += 1;
3096 ptr = ctx->ParseMessage(_internal_add_legacy_json_trace(), ptr);
3097 CHK_(ptr);
3098 if (!ctx->DataAvailable(ptr)) break;
3099 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
3100 } else {
3101 goto handle_unusual;
3102 }
3103 continue;
3104 default:
3105 goto handle_unusual;
3106 } // switch
3107 handle_unusual:
3108 if ((tag == 0) || ((tag & 7) == 4)) {
3109 CHK_(ptr);
3110 ctx->SetLastTag(tag);
3111 goto message_done;
3112 }
3113 ptr = UnknownFieldParse(
3114 tag,
3115 _internal_metadata_.mutable_unknown_fields<std::string>(),
3116 ptr, ctx);
3117 CHK_(ptr != nullptr);
3118 } // while
3119 message_done:
3120 return ptr;
3121 failure:
3122 ptr = nullptr;
3123 goto message_done;
3124 #undef CHK_
3125 }
3126
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3127 ::uint8_t* ChromeEventBundle::_InternalSerialize(
3128 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3129 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeEventBundle)
3130 ::uint32_t cached_has_bits = 0;
3131 (void) cached_has_bits;
3132
3133 // repeated .perfetto.protos.ChromeTraceEvent trace_events = 1 [deprecated = true];
3134 for (unsigned i = 0,
3135 n = static_cast<unsigned>(this->_internal_trace_events_size()); i < n; i++) {
3136 const auto& repfield = this->_internal_trace_events(i);
3137 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3138 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
3139 }
3140
3141 // repeated .perfetto.protos.ChromeMetadata metadata = 2;
3142 for (unsigned i = 0,
3143 n = static_cast<unsigned>(this->_internal_metadata_size()); i < n; i++) {
3144 const auto& repfield = this->_internal_metadata(i);
3145 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3146 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
3147 }
3148
3149 // repeated .perfetto.protos.ChromeStringTableEntry string_table = 3 [deprecated = true];
3150 for (unsigned i = 0,
3151 n = static_cast<unsigned>(this->_internal_string_table_size()); i < n; i++) {
3152 const auto& repfield = this->_internal_string_table(i);
3153 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3154 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
3155 }
3156
3157 // repeated string legacy_ftrace_output = 4;
3158 for (int i = 0, n = this->_internal_legacy_ftrace_output_size(); i < n; i++) {
3159 const auto& s = this->_internal_legacy_ftrace_output(i);
3160 target = stream->WriteString(4, s, target);
3161 }
3162
3163 // repeated .perfetto.protos.ChromeLegacyJsonTrace legacy_json_trace = 5;
3164 for (unsigned i = 0,
3165 n = static_cast<unsigned>(this->_internal_legacy_json_trace_size()); i < n; i++) {
3166 const auto& repfield = this->_internal_legacy_json_trace(i);
3167 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
3168 InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
3169 }
3170
3171 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3172 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3173 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3174 }
3175 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeEventBundle)
3176 return target;
3177 }
3178
ByteSizeLong() const3179 size_t ChromeEventBundle::ByteSizeLong() const {
3180 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeEventBundle)
3181 size_t total_size = 0;
3182
3183 ::uint32_t cached_has_bits = 0;
3184 // Prevent compiler warnings about cached_has_bits being unused
3185 (void) cached_has_bits;
3186
3187 // repeated .perfetto.protos.ChromeTraceEvent trace_events = 1 [deprecated = true];
3188 total_size += 1UL * this->_internal_trace_events_size();
3189 for (const auto& msg : this->_impl_.trace_events_) {
3190 total_size +=
3191 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
3192 }
3193
3194 // repeated .perfetto.protos.ChromeMetadata metadata = 2;
3195 total_size += 1UL * this->_internal_metadata_size();
3196 for (const auto& msg : this->_impl_.metadata_) {
3197 total_size +=
3198 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
3199 }
3200
3201 // repeated .perfetto.protos.ChromeStringTableEntry string_table = 3 [deprecated = true];
3202 total_size += 1UL * this->_internal_string_table_size();
3203 for (const auto& msg : this->_impl_.string_table_) {
3204 total_size +=
3205 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
3206 }
3207
3208 // repeated string legacy_ftrace_output = 4;
3209 total_size += 1 *
3210 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.legacy_ftrace_output_.size());
3211 for (int i = 0, n = _impl_.legacy_ftrace_output_.size(); i < n; i++) {
3212 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3213 _impl_.legacy_ftrace_output_.Get(i));
3214 }
3215
3216 // repeated .perfetto.protos.ChromeLegacyJsonTrace legacy_json_trace = 5;
3217 total_size += 1UL * this->_internal_legacy_json_trace_size();
3218 for (const auto& msg : this->_impl_.legacy_json_trace_) {
3219 total_size +=
3220 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
3221 }
3222
3223 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3224 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3225 }
3226 int cached_size = ::_pbi::ToCachedSize(total_size);
3227 SetCachedSize(cached_size);
3228 return total_size;
3229 }
3230
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3231 void ChromeEventBundle::CheckTypeAndMergeFrom(
3232 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3233 MergeFrom(*::_pbi::DownCast<const ChromeEventBundle*>(
3234 &from));
3235 }
3236
MergeFrom(const ChromeEventBundle & from)3237 void ChromeEventBundle::MergeFrom(const ChromeEventBundle& from) {
3238 ChromeEventBundle* const _this = this;
3239 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeEventBundle)
3240 GOOGLE_DCHECK_NE(&from, _this);
3241 ::uint32_t cached_has_bits = 0;
3242 (void) cached_has_bits;
3243
3244 _this->_impl_.trace_events_.MergeFrom(from._impl_.trace_events_);
3245 _this->_impl_.metadata_.MergeFrom(from._impl_.metadata_);
3246 _this->_impl_.string_table_.MergeFrom(from._impl_.string_table_);
3247 _this->_impl_.legacy_ftrace_output_.MergeFrom(from._impl_.legacy_ftrace_output_);
3248 _this->_impl_.legacy_json_trace_.MergeFrom(from._impl_.legacy_json_trace_);
3249 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3250 }
3251
CopyFrom(const ChromeEventBundle & from)3252 void ChromeEventBundle::CopyFrom(const ChromeEventBundle& from) {
3253 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeEventBundle)
3254 if (&from == this) return;
3255 Clear();
3256 MergeFrom(from);
3257 }
3258
IsInitialized() const3259 bool ChromeEventBundle::IsInitialized() const {
3260 return true;
3261 }
3262
InternalSwap(ChromeEventBundle * other)3263 void ChromeEventBundle::InternalSwap(ChromeEventBundle* other) {
3264 using std::swap;
3265 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3266 _impl_.trace_events_.InternalSwap(&other->_impl_.trace_events_);
3267 _impl_.metadata_.InternalSwap(&other->_impl_.metadata_);
3268 _impl_.string_table_.InternalSwap(&other->_impl_.string_table_);
3269 _impl_.legacy_ftrace_output_.InternalSwap(&other->_impl_.legacy_ftrace_output_);
3270 _impl_.legacy_json_trace_.InternalSwap(&other->_impl_.legacy_json_trace_);
3271 }
3272
GetTypeName() const3273 std::string ChromeEventBundle::GetTypeName() const {
3274 return "perfetto.protos.ChromeEventBundle";
3275 }
3276
3277
3278 // @@protoc_insertion_point(namespace_scope)
3279 } // namespace protos
3280 } // namespace perfetto
3281 PROTOBUF_NAMESPACE_OPEN
3282 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeTracedValue*
CreateMaybeMessage(Arena * arena)3283 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeTracedValue >(Arena* arena) {
3284 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeTracedValue >(arena);
3285 }
3286 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeStringTableEntry*
CreateMaybeMessage(Arena * arena)3287 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeStringTableEntry >(Arena* arena) {
3288 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeStringTableEntry >(arena);
3289 }
3290 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeTraceEvent_Arg*
CreateMaybeMessage(Arena * arena)3291 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeTraceEvent_Arg >(Arena* arena) {
3292 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeTraceEvent_Arg >(arena);
3293 }
3294 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeTraceEvent*
CreateMaybeMessage(Arena * arena)3295 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeTraceEvent >(Arena* arena) {
3296 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeTraceEvent >(arena);
3297 }
3298 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeMetadata*
CreateMaybeMessage(Arena * arena)3299 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeMetadata >(Arena* arena) {
3300 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeMetadata >(arena);
3301 }
3302 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeLegacyJsonTrace*
CreateMaybeMessage(Arena * arena)3303 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeLegacyJsonTrace >(Arena* arena) {
3304 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeLegacyJsonTrace >(arena);
3305 }
3306 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeEventBundle*
CreateMaybeMessage(Arena * arena)3307 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeEventBundle >(Arena* arena) {
3308 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeEventBundle >(arena);
3309 }
3310 PROTOBUF_NAMESPACE_CLOSE
3311
3312 // @@protoc_insertion_point(global_scope)
3313 #include <google/protobuf/port_undef.inc>
3314