1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/chrome/chrome_metadata.proto
3
4 #include "protos/perfetto/trace/chrome/chrome_metadata.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 {
ChromeMetadataPacket_FinchHash(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR ChromeMetadataPacket_FinchHash::ChromeMetadataPacket_FinchHash(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.name_)*/0u
28 , /*decltype(_impl_.group_)*/0u} {}
29 struct ChromeMetadataPacket_FinchHashDefaultTypeInternal {
ChromeMetadataPacket_FinchHashDefaultTypeInternalperfetto::protos::ChromeMetadataPacket_FinchHashDefaultTypeInternal30 PROTOBUF_CONSTEXPR ChromeMetadataPacket_FinchHashDefaultTypeInternal()
31 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeMetadataPacket_FinchHashDefaultTypeInternalperfetto::protos::ChromeMetadataPacket_FinchHashDefaultTypeInternal32 ~ChromeMetadataPacket_FinchHashDefaultTypeInternal() {}
33 union { // NOLINT(misc-non-private-member-variables-in-classes)
34 ChromeMetadataPacket_FinchHash _instance;
35 };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeMetadataPacket_FinchHashDefaultTypeInternal _ChromeMetadataPacket_FinchHash_default_instance_;
ChromeMetadataPacket(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR ChromeMetadataPacket::ChromeMetadataPacket(
39 ::_pbi::ConstantInitialized): _impl_{
40 /*decltype(_impl_._has_bits_)*/{}
41 , /*decltype(_impl_._cached_size_)*/{}
42 , /*decltype(_impl_.field_trial_hashes_)*/{}
43 , /*decltype(_impl_.enabled_categories_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
44 , /*decltype(_impl_.background_tracing_metadata_)*/nullptr
45 , /*decltype(_impl_.chrome_version_code_)*/0} {}
46 struct ChromeMetadataPacketDefaultTypeInternal {
ChromeMetadataPacketDefaultTypeInternalperfetto::protos::ChromeMetadataPacketDefaultTypeInternal47 PROTOBUF_CONSTEXPR ChromeMetadataPacketDefaultTypeInternal()
48 : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeMetadataPacketDefaultTypeInternalperfetto::protos::ChromeMetadataPacketDefaultTypeInternal49 ~ChromeMetadataPacketDefaultTypeInternal() {}
50 union { // NOLINT(misc-non-private-member-variables-in-classes)
51 ChromeMetadataPacket _instance;
52 };
53 };
54 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeMetadataPacketDefaultTypeInternal _ChromeMetadataPacket_default_instance_;
BackgroundTracingMetadata_TriggerRule_HistogramRule(::_pbi::ConstantInitialized)55 PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule_HistogramRule::BackgroundTracingMetadata_TriggerRule_HistogramRule(
56 ::_pbi::ConstantInitialized): _impl_{
57 /*decltype(_impl_._has_bits_)*/{}
58 , /*decltype(_impl_._cached_size_)*/{}
59 , /*decltype(_impl_.histogram_name_hash_)*/::uint64_t{0u}
60 , /*decltype(_impl_.histogram_min_trigger_)*/::int64_t{0}
61 , /*decltype(_impl_.histogram_max_trigger_)*/::int64_t{0}} {}
62 struct BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal {
BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternalperfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal63 PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal()
64 : _instance(::_pbi::ConstantInitialized{}) {}
~BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternalperfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal65 ~BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal() {}
66 union { // NOLINT(misc-non-private-member-variables-in-classes)
67 BackgroundTracingMetadata_TriggerRule_HistogramRule _instance;
68 };
69 };
70 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal _BackgroundTracingMetadata_TriggerRule_HistogramRule_default_instance_;
BackgroundTracingMetadata_TriggerRule_NamedRule(::_pbi::ConstantInitialized)71 PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule_NamedRule::BackgroundTracingMetadata_TriggerRule_NamedRule(
72 ::_pbi::ConstantInitialized): _impl_{
73 /*decltype(_impl_._has_bits_)*/{}
74 , /*decltype(_impl_._cached_size_)*/{}
75 , /*decltype(_impl_.content_trigger_name_hash_)*/::uint64_t{0u}
76 , /*decltype(_impl_.event_type_)*/0} {}
77 struct BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal {
BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternalperfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal78 PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal()
79 : _instance(::_pbi::ConstantInitialized{}) {}
~BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternalperfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal80 ~BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal() {}
81 union { // NOLINT(misc-non-private-member-variables-in-classes)
82 BackgroundTracingMetadata_TriggerRule_NamedRule _instance;
83 };
84 };
85 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal _BackgroundTracingMetadata_TriggerRule_NamedRule_default_instance_;
BackgroundTracingMetadata_TriggerRule(::_pbi::ConstantInitialized)86 PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule::BackgroundTracingMetadata_TriggerRule(
87 ::_pbi::ConstantInitialized): _impl_{
88 /*decltype(_impl_._has_bits_)*/{}
89 , /*decltype(_impl_._cached_size_)*/{}
90 , /*decltype(_impl_.histogram_rule_)*/nullptr
91 , /*decltype(_impl_.named_rule_)*/nullptr
92 , /*decltype(_impl_.trigger_type_)*/0
93 , /*decltype(_impl_.name_hash_)*/0u} {}
94 struct BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal {
BackgroundTracingMetadata_TriggerRuleDefaultTypeInternalperfetto::protos::BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal95 PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal()
96 : _instance(::_pbi::ConstantInitialized{}) {}
~BackgroundTracingMetadata_TriggerRuleDefaultTypeInternalperfetto::protos::BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal97 ~BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal() {}
98 union { // NOLINT(misc-non-private-member-variables-in-classes)
99 BackgroundTracingMetadata_TriggerRule _instance;
100 };
101 };
102 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal _BackgroundTracingMetadata_TriggerRule_default_instance_;
BackgroundTracingMetadata(::_pbi::ConstantInitialized)103 PROTOBUF_CONSTEXPR BackgroundTracingMetadata::BackgroundTracingMetadata(
104 ::_pbi::ConstantInitialized): _impl_{
105 /*decltype(_impl_._has_bits_)*/{}
106 , /*decltype(_impl_._cached_size_)*/{}
107 , /*decltype(_impl_.active_rules_)*/{}
108 , /*decltype(_impl_.triggered_rule_)*/nullptr
109 , /*decltype(_impl_.scenario_name_hash_)*/0u} {}
110 struct BackgroundTracingMetadataDefaultTypeInternal {
BackgroundTracingMetadataDefaultTypeInternalperfetto::protos::BackgroundTracingMetadataDefaultTypeInternal111 PROTOBUF_CONSTEXPR BackgroundTracingMetadataDefaultTypeInternal()
112 : _instance(::_pbi::ConstantInitialized{}) {}
~BackgroundTracingMetadataDefaultTypeInternalperfetto::protos::BackgroundTracingMetadataDefaultTypeInternal113 ~BackgroundTracingMetadataDefaultTypeInternal() {}
114 union { // NOLINT(misc-non-private-member-variables-in-classes)
115 BackgroundTracingMetadata _instance;
116 };
117 };
118 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BackgroundTracingMetadataDefaultTypeInternal _BackgroundTracingMetadata_default_instance_;
119 } // namespace protos
120 } // namespace perfetto
121 namespace perfetto {
122 namespace protos {
BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_IsValid(int value)123 bool BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_IsValid(int value) {
124 switch (value) {
125 case 0:
126 case 1:
127 case 2:
128 case 3:
129 case 4:
130 case 5:
131 case 1000:
132 return true;
133 default:
134 return false;
135 }
136 }
137
138 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_strings[7] = {};
139
140 static const char BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names[] =
141 "CONTENT_TRIGGER"
142 "NAVIGATION"
143 "REACHED_CODE"
144 "SESSION_RESTORE"
145 "STARTUP"
146 "TEST_RULE"
147 "UNSPECIFIED";
148
149 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries[] = {
150 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 0, 15}, 5 },
151 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 15, 10}, 2 },
152 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 25, 12}, 4 },
153 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 37, 15}, 1 },
154 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 52, 7}, 3 },
155 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 59, 9}, 1000 },
156 { {BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_names + 68, 11}, 0 },
157 };
158
159 static const int BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries_by_number[] = {
160 6, // 0 -> UNSPECIFIED
161 3, // 1 -> SESSION_RESTORE
162 1, // 2 -> NAVIGATION
163 4, // 3 -> STARTUP
164 2, // 4 -> REACHED_CODE
165 0, // 5 -> CONTENT_TRIGGER
166 5, // 1000 -> TEST_RULE
167 };
168
BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value)169 const std::string& BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(
170 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
171 static const bool dummy =
172 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
173 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries,
174 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries_by_number,
175 7, BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_strings);
176 (void) dummy;
177 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
178 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries,
179 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries_by_number,
180 7, value);
181 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
182 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_strings[idx].get();
183 }
BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,BackgroundTracingMetadata_TriggerRule_NamedRule_EventType * value)184 bool BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Parse(
185 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BackgroundTracingMetadata_TriggerRule_NamedRule_EventType* value) {
186 int int_value;
187 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
188 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_entries, 7, name, &int_value);
189 if (success) {
190 *value = static_cast<BackgroundTracingMetadata_TriggerRule_NamedRule_EventType>(int_value);
191 }
192 return success;
193 }
194 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
195 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::UNSPECIFIED;
196 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::SESSION_RESTORE;
197 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::NAVIGATION;
198 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::STARTUP;
199 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::REACHED_CODE;
200 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::CONTENT_TRIGGER;
201 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::TEST_RULE;
202 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::EventType_MIN;
203 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::EventType_MAX;
204 constexpr int BackgroundTracingMetadata_TriggerRule_NamedRule::EventType_ARRAYSIZE;
205 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
BackgroundTracingMetadata_TriggerRule_TriggerType_IsValid(int value)206 bool BackgroundTracingMetadata_TriggerRule_TriggerType_IsValid(int value) {
207 switch (value) {
208 case 0:
209 case 1:
210 case 2:
211 return true;
212 default:
213 return false;
214 }
215 }
216
217 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> BackgroundTracingMetadata_TriggerRule_TriggerType_strings[3] = {};
218
219 static const char BackgroundTracingMetadata_TriggerRule_TriggerType_names[] =
220 "MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE"
221 "MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED"
222 "TRIGGER_UNSPECIFIED";
223
224 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry BackgroundTracingMetadata_TriggerRule_TriggerType_entries[] = {
225 { {BackgroundTracingMetadata_TriggerRule_TriggerType_names + 0, 50}, 1 },
226 { {BackgroundTracingMetadata_TriggerRule_TriggerType_names + 50, 35}, 2 },
227 { {BackgroundTracingMetadata_TriggerRule_TriggerType_names + 85, 19}, 0 },
228 };
229
230 static const int BackgroundTracingMetadata_TriggerRule_TriggerType_entries_by_number[] = {
231 2, // 0 -> TRIGGER_UNSPECIFIED
232 0, // 1 -> MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE
233 1, // 2 -> MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED
234 };
235
BackgroundTracingMetadata_TriggerRule_TriggerType_Name(BackgroundTracingMetadata_TriggerRule_TriggerType value)236 const std::string& BackgroundTracingMetadata_TriggerRule_TriggerType_Name(
237 BackgroundTracingMetadata_TriggerRule_TriggerType value) {
238 static const bool dummy =
239 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
240 BackgroundTracingMetadata_TriggerRule_TriggerType_entries,
241 BackgroundTracingMetadata_TriggerRule_TriggerType_entries_by_number,
242 3, BackgroundTracingMetadata_TriggerRule_TriggerType_strings);
243 (void) dummy;
244 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
245 BackgroundTracingMetadata_TriggerRule_TriggerType_entries,
246 BackgroundTracingMetadata_TriggerRule_TriggerType_entries_by_number,
247 3, value);
248 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
249 BackgroundTracingMetadata_TriggerRule_TriggerType_strings[idx].get();
250 }
BackgroundTracingMetadata_TriggerRule_TriggerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,BackgroundTracingMetadata_TriggerRule_TriggerType * value)251 bool BackgroundTracingMetadata_TriggerRule_TriggerType_Parse(
252 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BackgroundTracingMetadata_TriggerRule_TriggerType* value) {
253 int int_value;
254 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
255 BackgroundTracingMetadata_TriggerRule_TriggerType_entries, 3, name, &int_value);
256 if (success) {
257 *value = static_cast<BackgroundTracingMetadata_TriggerRule_TriggerType>(int_value);
258 }
259 return success;
260 }
261 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
262 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::TRIGGER_UNSPECIFIED;
263 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
264 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
265 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::TriggerType_MIN;
266 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::TriggerType_MAX;
267 constexpr int BackgroundTracingMetadata_TriggerRule::TriggerType_ARRAYSIZE;
268 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
269
270 // ===================================================================
271
272 class ChromeMetadataPacket_FinchHash::_Internal {
273 public:
274 using HasBits = decltype(std::declval<ChromeMetadataPacket_FinchHash>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)275 static void set_has_name(HasBits* has_bits) {
276 (*has_bits)[0] |= 1u;
277 }
set_has_group(HasBits * has_bits)278 static void set_has_group(HasBits* has_bits) {
279 (*has_bits)[0] |= 2u;
280 }
281 };
282
ChromeMetadataPacket_FinchHash(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)283 ChromeMetadataPacket_FinchHash::ChromeMetadataPacket_FinchHash(::PROTOBUF_NAMESPACE_ID::Arena* arena,
284 bool is_message_owned)
285 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
286 SharedCtor(arena, is_message_owned);
287 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeMetadataPacket.FinchHash)
288 }
ChromeMetadataPacket_FinchHash(const ChromeMetadataPacket_FinchHash & from)289 ChromeMetadataPacket_FinchHash::ChromeMetadataPacket_FinchHash(const ChromeMetadataPacket_FinchHash& from)
290 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
291 ChromeMetadataPacket_FinchHash* const _this = this; (void)_this;
292 new (&_impl_) Impl_{
293 decltype(_impl_._has_bits_){from._impl_._has_bits_}
294 , /*decltype(_impl_._cached_size_)*/{}
295 , decltype(_impl_.name_){}
296 , decltype(_impl_.group_){}};
297
298 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
299 ::memcpy(&_impl_.name_, &from._impl_.name_,
300 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.group_) -
301 reinterpret_cast<char*>(&_impl_.name_)) + sizeof(_impl_.group_));
302 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeMetadataPacket.FinchHash)
303 }
304
SharedCtor(::_pb::Arena * arena,bool is_message_owned)305 inline void ChromeMetadataPacket_FinchHash::SharedCtor(
306 ::_pb::Arena* arena, bool is_message_owned) {
307 (void)arena;
308 (void)is_message_owned;
309 new (&_impl_) Impl_{
310 decltype(_impl_._has_bits_){}
311 , /*decltype(_impl_._cached_size_)*/{}
312 , decltype(_impl_.name_){0u}
313 , decltype(_impl_.group_){0u}
314 };
315 }
316
~ChromeMetadataPacket_FinchHash()317 ChromeMetadataPacket_FinchHash::~ChromeMetadataPacket_FinchHash() {
318 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeMetadataPacket.FinchHash)
319 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
320 (void)arena;
321 return;
322 }
323 SharedDtor();
324 }
325
SharedDtor()326 inline void ChromeMetadataPacket_FinchHash::SharedDtor() {
327 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
328 }
329
SetCachedSize(int size) const330 void ChromeMetadataPacket_FinchHash::SetCachedSize(int size) const {
331 _impl_._cached_size_.Set(size);
332 }
333
Clear()334 void ChromeMetadataPacket_FinchHash::Clear() {
335 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeMetadataPacket.FinchHash)
336 ::uint32_t cached_has_bits = 0;
337 // Prevent compiler warnings about cached_has_bits being unused
338 (void) cached_has_bits;
339
340 cached_has_bits = _impl_._has_bits_[0];
341 if (cached_has_bits & 0x00000003u) {
342 ::memset(&_impl_.name_, 0, static_cast<size_t>(
343 reinterpret_cast<char*>(&_impl_.group_) -
344 reinterpret_cast<char*>(&_impl_.name_)) + sizeof(_impl_.group_));
345 }
346 _impl_._has_bits_.Clear();
347 _internal_metadata_.Clear<std::string>();
348 }
349
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)350 const char* ChromeMetadataPacket_FinchHash::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
351 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
352 _Internal::HasBits has_bits{};
353 while (!ctx->Done(&ptr)) {
354 ::uint32_t tag;
355 ptr = ::_pbi::ReadTag(ptr, &tag);
356 switch (tag >> 3) {
357 // optional uint32 name = 1;
358 case 1:
359 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
360 _Internal::set_has_name(&has_bits);
361 _impl_.name_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
362 CHK_(ptr);
363 } else {
364 goto handle_unusual;
365 }
366 continue;
367 // optional uint32 group = 2;
368 case 2:
369 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
370 _Internal::set_has_group(&has_bits);
371 _impl_.group_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
372 CHK_(ptr);
373 } else {
374 goto handle_unusual;
375 }
376 continue;
377 default:
378 goto handle_unusual;
379 } // switch
380 handle_unusual:
381 if ((tag == 0) || ((tag & 7) == 4)) {
382 CHK_(ptr);
383 ctx->SetLastTag(tag);
384 goto message_done;
385 }
386 ptr = UnknownFieldParse(
387 tag,
388 _internal_metadata_.mutable_unknown_fields<std::string>(),
389 ptr, ctx);
390 CHK_(ptr != nullptr);
391 } // while
392 message_done:
393 _impl_._has_bits_.Or(has_bits);
394 return ptr;
395 failure:
396 ptr = nullptr;
397 goto message_done;
398 #undef CHK_
399 }
400
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const401 ::uint8_t* ChromeMetadataPacket_FinchHash::_InternalSerialize(
402 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
403 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeMetadataPacket.FinchHash)
404 ::uint32_t cached_has_bits = 0;
405 (void) cached_has_bits;
406
407 cached_has_bits = _impl_._has_bits_[0];
408 // optional uint32 name = 1;
409 if (cached_has_bits & 0x00000001u) {
410 target = stream->EnsureSpace(target);
411 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_name(), target);
412 }
413
414 // optional uint32 group = 2;
415 if (cached_has_bits & 0x00000002u) {
416 target = stream->EnsureSpace(target);
417 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_group(), target);
418 }
419
420 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
421 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
422 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
423 }
424 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeMetadataPacket.FinchHash)
425 return target;
426 }
427
ByteSizeLong() const428 size_t ChromeMetadataPacket_FinchHash::ByteSizeLong() const {
429 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeMetadataPacket.FinchHash)
430 size_t total_size = 0;
431
432 ::uint32_t cached_has_bits = 0;
433 // Prevent compiler warnings about cached_has_bits being unused
434 (void) cached_has_bits;
435
436 cached_has_bits = _impl_._has_bits_[0];
437 if (cached_has_bits & 0x00000003u) {
438 // optional uint32 name = 1;
439 if (cached_has_bits & 0x00000001u) {
440 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_name());
441 }
442
443 // optional uint32 group = 2;
444 if (cached_has_bits & 0x00000002u) {
445 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_group());
446 }
447
448 }
449 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
450 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
451 }
452 int cached_size = ::_pbi::ToCachedSize(total_size);
453 SetCachedSize(cached_size);
454 return total_size;
455 }
456
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)457 void ChromeMetadataPacket_FinchHash::CheckTypeAndMergeFrom(
458 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
459 MergeFrom(*::_pbi::DownCast<const ChromeMetadataPacket_FinchHash*>(
460 &from));
461 }
462
MergeFrom(const ChromeMetadataPacket_FinchHash & from)463 void ChromeMetadataPacket_FinchHash::MergeFrom(const ChromeMetadataPacket_FinchHash& from) {
464 ChromeMetadataPacket_FinchHash* const _this = this;
465 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeMetadataPacket.FinchHash)
466 GOOGLE_DCHECK_NE(&from, _this);
467 ::uint32_t cached_has_bits = 0;
468 (void) cached_has_bits;
469
470 cached_has_bits = from._impl_._has_bits_[0];
471 if (cached_has_bits & 0x00000003u) {
472 if (cached_has_bits & 0x00000001u) {
473 _this->_impl_.name_ = from._impl_.name_;
474 }
475 if (cached_has_bits & 0x00000002u) {
476 _this->_impl_.group_ = from._impl_.group_;
477 }
478 _this->_impl_._has_bits_[0] |= cached_has_bits;
479 }
480 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
481 }
482
CopyFrom(const ChromeMetadataPacket_FinchHash & from)483 void ChromeMetadataPacket_FinchHash::CopyFrom(const ChromeMetadataPacket_FinchHash& from) {
484 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeMetadataPacket.FinchHash)
485 if (&from == this) return;
486 Clear();
487 MergeFrom(from);
488 }
489
IsInitialized() const490 bool ChromeMetadataPacket_FinchHash::IsInitialized() const {
491 return true;
492 }
493
InternalSwap(ChromeMetadataPacket_FinchHash * other)494 void ChromeMetadataPacket_FinchHash::InternalSwap(ChromeMetadataPacket_FinchHash* other) {
495 using std::swap;
496 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
497 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
498 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
499 PROTOBUF_FIELD_OFFSET(ChromeMetadataPacket_FinchHash, _impl_.group_)
500 + sizeof(ChromeMetadataPacket_FinchHash::_impl_.group_) // NOLINT
501 - PROTOBUF_FIELD_OFFSET(ChromeMetadataPacket_FinchHash, _impl_.name_)>(
502 reinterpret_cast<char*>(&_impl_.name_),
503 reinterpret_cast<char*>(&other->_impl_.name_));
504 }
505
GetTypeName() const506 std::string ChromeMetadataPacket_FinchHash::GetTypeName() const {
507 return "perfetto.protos.ChromeMetadataPacket.FinchHash";
508 }
509
510
511 // ===================================================================
512
513 class ChromeMetadataPacket::_Internal {
514 public:
515 using HasBits = decltype(std::declval<ChromeMetadataPacket>()._impl_._has_bits_);
516 static const ::perfetto::protos::BackgroundTracingMetadata& background_tracing_metadata(const ChromeMetadataPacket* msg);
set_has_background_tracing_metadata(HasBits * has_bits)517 static void set_has_background_tracing_metadata(HasBits* has_bits) {
518 (*has_bits)[0] |= 2u;
519 }
set_has_chrome_version_code(HasBits * has_bits)520 static void set_has_chrome_version_code(HasBits* has_bits) {
521 (*has_bits)[0] |= 4u;
522 }
set_has_enabled_categories(HasBits * has_bits)523 static void set_has_enabled_categories(HasBits* has_bits) {
524 (*has_bits)[0] |= 1u;
525 }
526 };
527
528 const ::perfetto::protos::BackgroundTracingMetadata&
background_tracing_metadata(const ChromeMetadataPacket * msg)529 ChromeMetadataPacket::_Internal::background_tracing_metadata(const ChromeMetadataPacket* msg) {
530 return *msg->_impl_.background_tracing_metadata_;
531 }
ChromeMetadataPacket(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)532 ChromeMetadataPacket::ChromeMetadataPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
533 bool is_message_owned)
534 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
535 SharedCtor(arena, is_message_owned);
536 // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeMetadataPacket)
537 }
ChromeMetadataPacket(const ChromeMetadataPacket & from)538 ChromeMetadataPacket::ChromeMetadataPacket(const ChromeMetadataPacket& from)
539 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
540 ChromeMetadataPacket* const _this = this; (void)_this;
541 new (&_impl_) Impl_{
542 decltype(_impl_._has_bits_){from._impl_._has_bits_}
543 , /*decltype(_impl_._cached_size_)*/{}
544 , decltype(_impl_.field_trial_hashes_){from._impl_.field_trial_hashes_}
545 , decltype(_impl_.enabled_categories_){}
546 , decltype(_impl_.background_tracing_metadata_){nullptr}
547 , decltype(_impl_.chrome_version_code_){}};
548
549 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
550 _impl_.enabled_categories_.InitDefault();
551 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
552 _impl_.enabled_categories_.Set("", GetArenaForAllocation());
553 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
554 if (from._internal_has_enabled_categories()) {
555 _this->_impl_.enabled_categories_.Set(from._internal_enabled_categories(),
556 _this->GetArenaForAllocation());
557 }
558 if (from._internal_has_background_tracing_metadata()) {
559 _this->_impl_.background_tracing_metadata_ = new ::perfetto::protos::BackgroundTracingMetadata(*from._impl_.background_tracing_metadata_);
560 }
561 _this->_impl_.chrome_version_code_ = from._impl_.chrome_version_code_;
562 // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeMetadataPacket)
563 }
564
SharedCtor(::_pb::Arena * arena,bool is_message_owned)565 inline void ChromeMetadataPacket::SharedCtor(
566 ::_pb::Arena* arena, bool is_message_owned) {
567 (void)arena;
568 (void)is_message_owned;
569 new (&_impl_) Impl_{
570 decltype(_impl_._has_bits_){}
571 , /*decltype(_impl_._cached_size_)*/{}
572 , decltype(_impl_.field_trial_hashes_){arena}
573 , decltype(_impl_.enabled_categories_){}
574 , decltype(_impl_.background_tracing_metadata_){nullptr}
575 , decltype(_impl_.chrome_version_code_){0}
576 };
577 _impl_.enabled_categories_.InitDefault();
578 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
579 _impl_.enabled_categories_.Set("", GetArenaForAllocation());
580 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
581 }
582
~ChromeMetadataPacket()583 ChromeMetadataPacket::~ChromeMetadataPacket() {
584 // @@protoc_insertion_point(destructor:perfetto.protos.ChromeMetadataPacket)
585 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
586 (void)arena;
587 return;
588 }
589 SharedDtor();
590 }
591
SharedDtor()592 inline void ChromeMetadataPacket::SharedDtor() {
593 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
594 _impl_.field_trial_hashes_.~RepeatedPtrField();
595 _impl_.enabled_categories_.Destroy();
596 if (this != internal_default_instance()) delete _impl_.background_tracing_metadata_;
597 }
598
SetCachedSize(int size) const599 void ChromeMetadataPacket::SetCachedSize(int size) const {
600 _impl_._cached_size_.Set(size);
601 }
602
Clear()603 void ChromeMetadataPacket::Clear() {
604 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeMetadataPacket)
605 ::uint32_t cached_has_bits = 0;
606 // Prevent compiler warnings about cached_has_bits being unused
607 (void) cached_has_bits;
608
609 _impl_.field_trial_hashes_.Clear();
610 cached_has_bits = _impl_._has_bits_[0];
611 if (cached_has_bits & 0x00000003u) {
612 if (cached_has_bits & 0x00000001u) {
613 _impl_.enabled_categories_.ClearNonDefaultToEmpty();
614 }
615 if (cached_has_bits & 0x00000002u) {
616 GOOGLE_DCHECK(_impl_.background_tracing_metadata_ != nullptr);
617 _impl_.background_tracing_metadata_->Clear();
618 }
619 }
620 _impl_.chrome_version_code_ = 0;
621 _impl_._has_bits_.Clear();
622 _internal_metadata_.Clear<std::string>();
623 }
624
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)625 const char* ChromeMetadataPacket::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
626 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
627 _Internal::HasBits has_bits{};
628 while (!ctx->Done(&ptr)) {
629 ::uint32_t tag;
630 ptr = ::_pbi::ReadTag(ptr, &tag);
631 switch (tag >> 3) {
632 // optional .perfetto.protos.BackgroundTracingMetadata background_tracing_metadata = 1;
633 case 1:
634 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
635 ptr = ctx->ParseMessage(_internal_mutable_background_tracing_metadata(), ptr);
636 CHK_(ptr);
637 } else {
638 goto handle_unusual;
639 }
640 continue;
641 // optional int32 chrome_version_code = 2;
642 case 2:
643 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
644 _Internal::set_has_chrome_version_code(&has_bits);
645 _impl_.chrome_version_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
646 CHK_(ptr);
647 } else {
648 goto handle_unusual;
649 }
650 continue;
651 // optional string enabled_categories = 3;
652 case 3:
653 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
654 auto str = _internal_mutable_enabled_categories();
655 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
656 CHK_(ptr);
657 } else {
658 goto handle_unusual;
659 }
660 continue;
661 // repeated .perfetto.protos.ChromeMetadataPacket.FinchHash field_trial_hashes = 4;
662 case 4:
663 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
664 ptr -= 1;
665 do {
666 ptr += 1;
667 ptr = ctx->ParseMessage(_internal_add_field_trial_hashes(), ptr);
668 CHK_(ptr);
669 if (!ctx->DataAvailable(ptr)) break;
670 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
671 } else {
672 goto handle_unusual;
673 }
674 continue;
675 default:
676 goto handle_unusual;
677 } // switch
678 handle_unusual:
679 if ((tag == 0) || ((tag & 7) == 4)) {
680 CHK_(ptr);
681 ctx->SetLastTag(tag);
682 goto message_done;
683 }
684 ptr = UnknownFieldParse(
685 tag,
686 _internal_metadata_.mutable_unknown_fields<std::string>(),
687 ptr, ctx);
688 CHK_(ptr != nullptr);
689 } // while
690 message_done:
691 _impl_._has_bits_.Or(has_bits);
692 return ptr;
693 failure:
694 ptr = nullptr;
695 goto message_done;
696 #undef CHK_
697 }
698
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const699 ::uint8_t* ChromeMetadataPacket::_InternalSerialize(
700 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
701 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeMetadataPacket)
702 ::uint32_t cached_has_bits = 0;
703 (void) cached_has_bits;
704
705 cached_has_bits = _impl_._has_bits_[0];
706 // optional .perfetto.protos.BackgroundTracingMetadata background_tracing_metadata = 1;
707 if (cached_has_bits & 0x00000002u) {
708 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
709 InternalWriteMessage(1, _Internal::background_tracing_metadata(this),
710 _Internal::background_tracing_metadata(this).GetCachedSize(), target, stream);
711 }
712
713 // optional int32 chrome_version_code = 2;
714 if (cached_has_bits & 0x00000004u) {
715 target = stream->EnsureSpace(target);
716 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_chrome_version_code(), target);
717 }
718
719 // optional string enabled_categories = 3;
720 if (cached_has_bits & 0x00000001u) {
721 target = stream->WriteStringMaybeAliased(
722 3, this->_internal_enabled_categories(), target);
723 }
724
725 // repeated .perfetto.protos.ChromeMetadataPacket.FinchHash field_trial_hashes = 4;
726 for (unsigned i = 0,
727 n = static_cast<unsigned>(this->_internal_field_trial_hashes_size()); i < n; i++) {
728 const auto& repfield = this->_internal_field_trial_hashes(i);
729 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
730 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
731 }
732
733 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
734 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
735 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
736 }
737 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeMetadataPacket)
738 return target;
739 }
740
ByteSizeLong() const741 size_t ChromeMetadataPacket::ByteSizeLong() const {
742 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeMetadataPacket)
743 size_t total_size = 0;
744
745 ::uint32_t cached_has_bits = 0;
746 // Prevent compiler warnings about cached_has_bits being unused
747 (void) cached_has_bits;
748
749 // repeated .perfetto.protos.ChromeMetadataPacket.FinchHash field_trial_hashes = 4;
750 total_size += 1UL * this->_internal_field_trial_hashes_size();
751 for (const auto& msg : this->_impl_.field_trial_hashes_) {
752 total_size +=
753 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
754 }
755
756 cached_has_bits = _impl_._has_bits_[0];
757 if (cached_has_bits & 0x00000007u) {
758 // optional string enabled_categories = 3;
759 if (cached_has_bits & 0x00000001u) {
760 total_size += 1 +
761 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
762 this->_internal_enabled_categories());
763 }
764
765 // optional .perfetto.protos.BackgroundTracingMetadata background_tracing_metadata = 1;
766 if (cached_has_bits & 0x00000002u) {
767 total_size += 1 +
768 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
769 *_impl_.background_tracing_metadata_);
770 }
771
772 // optional int32 chrome_version_code = 2;
773 if (cached_has_bits & 0x00000004u) {
774 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_chrome_version_code());
775 }
776
777 }
778 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
779 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
780 }
781 int cached_size = ::_pbi::ToCachedSize(total_size);
782 SetCachedSize(cached_size);
783 return total_size;
784 }
785
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)786 void ChromeMetadataPacket::CheckTypeAndMergeFrom(
787 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
788 MergeFrom(*::_pbi::DownCast<const ChromeMetadataPacket*>(
789 &from));
790 }
791
MergeFrom(const ChromeMetadataPacket & from)792 void ChromeMetadataPacket::MergeFrom(const ChromeMetadataPacket& from) {
793 ChromeMetadataPacket* const _this = this;
794 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeMetadataPacket)
795 GOOGLE_DCHECK_NE(&from, _this);
796 ::uint32_t cached_has_bits = 0;
797 (void) cached_has_bits;
798
799 _this->_impl_.field_trial_hashes_.MergeFrom(from._impl_.field_trial_hashes_);
800 cached_has_bits = from._impl_._has_bits_[0];
801 if (cached_has_bits & 0x00000007u) {
802 if (cached_has_bits & 0x00000001u) {
803 _this->_internal_set_enabled_categories(from._internal_enabled_categories());
804 }
805 if (cached_has_bits & 0x00000002u) {
806 _this->_internal_mutable_background_tracing_metadata()->::perfetto::protos::BackgroundTracingMetadata::MergeFrom(
807 from._internal_background_tracing_metadata());
808 }
809 if (cached_has_bits & 0x00000004u) {
810 _this->_impl_.chrome_version_code_ = from._impl_.chrome_version_code_;
811 }
812 _this->_impl_._has_bits_[0] |= cached_has_bits;
813 }
814 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
815 }
816
CopyFrom(const ChromeMetadataPacket & from)817 void ChromeMetadataPacket::CopyFrom(const ChromeMetadataPacket& from) {
818 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeMetadataPacket)
819 if (&from == this) return;
820 Clear();
821 MergeFrom(from);
822 }
823
IsInitialized() const824 bool ChromeMetadataPacket::IsInitialized() const {
825 return true;
826 }
827
InternalSwap(ChromeMetadataPacket * other)828 void ChromeMetadataPacket::InternalSwap(ChromeMetadataPacket* other) {
829 using std::swap;
830 auto* lhs_arena = GetArenaForAllocation();
831 auto* rhs_arena = other->GetArenaForAllocation();
832 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
833 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
834 _impl_.field_trial_hashes_.InternalSwap(&other->_impl_.field_trial_hashes_);
835 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
836 &_impl_.enabled_categories_, lhs_arena,
837 &other->_impl_.enabled_categories_, rhs_arena
838 );
839 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
840 PROTOBUF_FIELD_OFFSET(ChromeMetadataPacket, _impl_.chrome_version_code_)
841 + sizeof(ChromeMetadataPacket::_impl_.chrome_version_code_) // NOLINT
842 - PROTOBUF_FIELD_OFFSET(ChromeMetadataPacket, _impl_.background_tracing_metadata_)>(
843 reinterpret_cast<char*>(&_impl_.background_tracing_metadata_),
844 reinterpret_cast<char*>(&other->_impl_.background_tracing_metadata_));
845 }
846
GetTypeName() const847 std::string ChromeMetadataPacket::GetTypeName() const {
848 return "perfetto.protos.ChromeMetadataPacket";
849 }
850
851
852 // ===================================================================
853
854 class BackgroundTracingMetadata_TriggerRule_HistogramRule::_Internal {
855 public:
856 using HasBits = decltype(std::declval<BackgroundTracingMetadata_TriggerRule_HistogramRule>()._impl_._has_bits_);
set_has_histogram_name_hash(HasBits * has_bits)857 static void set_has_histogram_name_hash(HasBits* has_bits) {
858 (*has_bits)[0] |= 1u;
859 }
set_has_histogram_min_trigger(HasBits * has_bits)860 static void set_has_histogram_min_trigger(HasBits* has_bits) {
861 (*has_bits)[0] |= 2u;
862 }
set_has_histogram_max_trigger(HasBits * has_bits)863 static void set_has_histogram_max_trigger(HasBits* has_bits) {
864 (*has_bits)[0] |= 4u;
865 }
866 };
867
BackgroundTracingMetadata_TriggerRule_HistogramRule(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)868 BackgroundTracingMetadata_TriggerRule_HistogramRule::BackgroundTracingMetadata_TriggerRule_HistogramRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
869 bool is_message_owned)
870 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
871 SharedCtor(arena, is_message_owned);
872 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
873 }
BackgroundTracingMetadata_TriggerRule_HistogramRule(const BackgroundTracingMetadata_TriggerRule_HistogramRule & from)874 BackgroundTracingMetadata_TriggerRule_HistogramRule::BackgroundTracingMetadata_TriggerRule_HistogramRule(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from)
875 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
876 BackgroundTracingMetadata_TriggerRule_HistogramRule* const _this = this; (void)_this;
877 new (&_impl_) Impl_{
878 decltype(_impl_._has_bits_){from._impl_._has_bits_}
879 , /*decltype(_impl_._cached_size_)*/{}
880 , decltype(_impl_.histogram_name_hash_){}
881 , decltype(_impl_.histogram_min_trigger_){}
882 , decltype(_impl_.histogram_max_trigger_){}};
883
884 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
885 ::memcpy(&_impl_.histogram_name_hash_, &from._impl_.histogram_name_hash_,
886 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.histogram_max_trigger_) -
887 reinterpret_cast<char*>(&_impl_.histogram_name_hash_)) + sizeof(_impl_.histogram_max_trigger_));
888 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
889 }
890
SharedCtor(::_pb::Arena * arena,bool is_message_owned)891 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::SharedCtor(
892 ::_pb::Arena* arena, bool is_message_owned) {
893 (void)arena;
894 (void)is_message_owned;
895 new (&_impl_) Impl_{
896 decltype(_impl_._has_bits_){}
897 , /*decltype(_impl_._cached_size_)*/{}
898 , decltype(_impl_.histogram_name_hash_){::uint64_t{0u}}
899 , decltype(_impl_.histogram_min_trigger_){::int64_t{0}}
900 , decltype(_impl_.histogram_max_trigger_){::int64_t{0}}
901 };
902 }
903
~BackgroundTracingMetadata_TriggerRule_HistogramRule()904 BackgroundTracingMetadata_TriggerRule_HistogramRule::~BackgroundTracingMetadata_TriggerRule_HistogramRule() {
905 // @@protoc_insertion_point(destructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
906 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
907 (void)arena;
908 return;
909 }
910 SharedDtor();
911 }
912
SharedDtor()913 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::SharedDtor() {
914 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
915 }
916
SetCachedSize(int size) const917 void BackgroundTracingMetadata_TriggerRule_HistogramRule::SetCachedSize(int size) const {
918 _impl_._cached_size_.Set(size);
919 }
920
Clear()921 void BackgroundTracingMetadata_TriggerRule_HistogramRule::Clear() {
922 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
923 ::uint32_t cached_has_bits = 0;
924 // Prevent compiler warnings about cached_has_bits being unused
925 (void) cached_has_bits;
926
927 cached_has_bits = _impl_._has_bits_[0];
928 if (cached_has_bits & 0x00000007u) {
929 ::memset(&_impl_.histogram_name_hash_, 0, static_cast<size_t>(
930 reinterpret_cast<char*>(&_impl_.histogram_max_trigger_) -
931 reinterpret_cast<char*>(&_impl_.histogram_name_hash_)) + sizeof(_impl_.histogram_max_trigger_));
932 }
933 _impl_._has_bits_.Clear();
934 _internal_metadata_.Clear<std::string>();
935 }
936
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)937 const char* BackgroundTracingMetadata_TriggerRule_HistogramRule::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
938 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
939 _Internal::HasBits has_bits{};
940 while (!ctx->Done(&ptr)) {
941 ::uint32_t tag;
942 ptr = ::_pbi::ReadTag(ptr, &tag);
943 switch (tag >> 3) {
944 // optional fixed64 histogram_name_hash = 1;
945 case 1:
946 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
947 _Internal::set_has_histogram_name_hash(&has_bits);
948 _impl_.histogram_name_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
949 ptr += sizeof(::uint64_t);
950 } else {
951 goto handle_unusual;
952 }
953 continue;
954 // optional int64 histogram_min_trigger = 2;
955 case 2:
956 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
957 _Internal::set_has_histogram_min_trigger(&has_bits);
958 _impl_.histogram_min_trigger_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
959 CHK_(ptr);
960 } else {
961 goto handle_unusual;
962 }
963 continue;
964 // optional int64 histogram_max_trigger = 3;
965 case 3:
966 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
967 _Internal::set_has_histogram_max_trigger(&has_bits);
968 _impl_.histogram_max_trigger_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
969 CHK_(ptr);
970 } else {
971 goto handle_unusual;
972 }
973 continue;
974 default:
975 goto handle_unusual;
976 } // switch
977 handle_unusual:
978 if ((tag == 0) || ((tag & 7) == 4)) {
979 CHK_(ptr);
980 ctx->SetLastTag(tag);
981 goto message_done;
982 }
983 ptr = UnknownFieldParse(
984 tag,
985 _internal_metadata_.mutable_unknown_fields<std::string>(),
986 ptr, ctx);
987 CHK_(ptr != nullptr);
988 } // while
989 message_done:
990 _impl_._has_bits_.Or(has_bits);
991 return ptr;
992 failure:
993 ptr = nullptr;
994 goto message_done;
995 #undef CHK_
996 }
997
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const998 ::uint8_t* BackgroundTracingMetadata_TriggerRule_HistogramRule::_InternalSerialize(
999 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1000 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
1001 ::uint32_t cached_has_bits = 0;
1002 (void) cached_has_bits;
1003
1004 cached_has_bits = _impl_._has_bits_[0];
1005 // optional fixed64 histogram_name_hash = 1;
1006 if (cached_has_bits & 0x00000001u) {
1007 target = stream->EnsureSpace(target);
1008 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(1, this->_internal_histogram_name_hash(), target);
1009 }
1010
1011 // optional int64 histogram_min_trigger = 2;
1012 if (cached_has_bits & 0x00000002u) {
1013 target = stream->EnsureSpace(target);
1014 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_histogram_min_trigger(), target);
1015 }
1016
1017 // optional int64 histogram_max_trigger = 3;
1018 if (cached_has_bits & 0x00000004u) {
1019 target = stream->EnsureSpace(target);
1020 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_histogram_max_trigger(), target);
1021 }
1022
1023 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1024 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1025 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1026 }
1027 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
1028 return target;
1029 }
1030
ByteSizeLong() const1031 size_t BackgroundTracingMetadata_TriggerRule_HistogramRule::ByteSizeLong() const {
1032 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
1033 size_t total_size = 0;
1034
1035 ::uint32_t cached_has_bits = 0;
1036 // Prevent compiler warnings about cached_has_bits being unused
1037 (void) cached_has_bits;
1038
1039 cached_has_bits = _impl_._has_bits_[0];
1040 if (cached_has_bits & 0x00000007u) {
1041 // optional fixed64 histogram_name_hash = 1;
1042 if (cached_has_bits & 0x00000001u) {
1043 total_size += 1 + 8;
1044 }
1045
1046 // optional int64 histogram_min_trigger = 2;
1047 if (cached_has_bits & 0x00000002u) {
1048 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_histogram_min_trigger());
1049 }
1050
1051 // optional int64 histogram_max_trigger = 3;
1052 if (cached_has_bits & 0x00000004u) {
1053 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_histogram_max_trigger());
1054 }
1055
1056 }
1057 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1058 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1059 }
1060 int cached_size = ::_pbi::ToCachedSize(total_size);
1061 SetCachedSize(cached_size);
1062 return total_size;
1063 }
1064
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1065 void BackgroundTracingMetadata_TriggerRule_HistogramRule::CheckTypeAndMergeFrom(
1066 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1067 MergeFrom(*::_pbi::DownCast<const BackgroundTracingMetadata_TriggerRule_HistogramRule*>(
1068 &from));
1069 }
1070
MergeFrom(const BackgroundTracingMetadata_TriggerRule_HistogramRule & from)1071 void BackgroundTracingMetadata_TriggerRule_HistogramRule::MergeFrom(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from) {
1072 BackgroundTracingMetadata_TriggerRule_HistogramRule* const _this = this;
1073 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
1074 GOOGLE_DCHECK_NE(&from, _this);
1075 ::uint32_t cached_has_bits = 0;
1076 (void) cached_has_bits;
1077
1078 cached_has_bits = from._impl_._has_bits_[0];
1079 if (cached_has_bits & 0x00000007u) {
1080 if (cached_has_bits & 0x00000001u) {
1081 _this->_impl_.histogram_name_hash_ = from._impl_.histogram_name_hash_;
1082 }
1083 if (cached_has_bits & 0x00000002u) {
1084 _this->_impl_.histogram_min_trigger_ = from._impl_.histogram_min_trigger_;
1085 }
1086 if (cached_has_bits & 0x00000004u) {
1087 _this->_impl_.histogram_max_trigger_ = from._impl_.histogram_max_trigger_;
1088 }
1089 _this->_impl_._has_bits_[0] |= cached_has_bits;
1090 }
1091 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1092 }
1093
CopyFrom(const BackgroundTracingMetadata_TriggerRule_HistogramRule & from)1094 void BackgroundTracingMetadata_TriggerRule_HistogramRule::CopyFrom(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from) {
1095 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
1096 if (&from == this) return;
1097 Clear();
1098 MergeFrom(from);
1099 }
1100
IsInitialized() const1101 bool BackgroundTracingMetadata_TriggerRule_HistogramRule::IsInitialized() const {
1102 return true;
1103 }
1104
InternalSwap(BackgroundTracingMetadata_TriggerRule_HistogramRule * other)1105 void BackgroundTracingMetadata_TriggerRule_HistogramRule::InternalSwap(BackgroundTracingMetadata_TriggerRule_HistogramRule* other) {
1106 using std::swap;
1107 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1108 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1109 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1110 PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata_TriggerRule_HistogramRule, _impl_.histogram_max_trigger_)
1111 + sizeof(BackgroundTracingMetadata_TriggerRule_HistogramRule::_impl_.histogram_max_trigger_) // NOLINT
1112 - PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata_TriggerRule_HistogramRule, _impl_.histogram_name_hash_)>(
1113 reinterpret_cast<char*>(&_impl_.histogram_name_hash_),
1114 reinterpret_cast<char*>(&other->_impl_.histogram_name_hash_));
1115 }
1116
GetTypeName() const1117 std::string BackgroundTracingMetadata_TriggerRule_HistogramRule::GetTypeName() const {
1118 return "perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule";
1119 }
1120
1121
1122 // ===================================================================
1123
1124 class BackgroundTracingMetadata_TriggerRule_NamedRule::_Internal {
1125 public:
1126 using HasBits = decltype(std::declval<BackgroundTracingMetadata_TriggerRule_NamedRule>()._impl_._has_bits_);
set_has_event_type(HasBits * has_bits)1127 static void set_has_event_type(HasBits* has_bits) {
1128 (*has_bits)[0] |= 2u;
1129 }
set_has_content_trigger_name_hash(HasBits * has_bits)1130 static void set_has_content_trigger_name_hash(HasBits* has_bits) {
1131 (*has_bits)[0] |= 1u;
1132 }
1133 };
1134
BackgroundTracingMetadata_TriggerRule_NamedRule(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1135 BackgroundTracingMetadata_TriggerRule_NamedRule::BackgroundTracingMetadata_TriggerRule_NamedRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1136 bool is_message_owned)
1137 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1138 SharedCtor(arena, is_message_owned);
1139 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1140 }
BackgroundTracingMetadata_TriggerRule_NamedRule(const BackgroundTracingMetadata_TriggerRule_NamedRule & from)1141 BackgroundTracingMetadata_TriggerRule_NamedRule::BackgroundTracingMetadata_TriggerRule_NamedRule(const BackgroundTracingMetadata_TriggerRule_NamedRule& from)
1142 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1143 BackgroundTracingMetadata_TriggerRule_NamedRule* const _this = this; (void)_this;
1144 new (&_impl_) Impl_{
1145 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1146 , /*decltype(_impl_._cached_size_)*/{}
1147 , decltype(_impl_.content_trigger_name_hash_){}
1148 , decltype(_impl_.event_type_){}};
1149
1150 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1151 ::memcpy(&_impl_.content_trigger_name_hash_, &from._impl_.content_trigger_name_hash_,
1152 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.event_type_) -
1153 reinterpret_cast<char*>(&_impl_.content_trigger_name_hash_)) + sizeof(_impl_.event_type_));
1154 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1155 }
1156
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1157 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::SharedCtor(
1158 ::_pb::Arena* arena, bool is_message_owned) {
1159 (void)arena;
1160 (void)is_message_owned;
1161 new (&_impl_) Impl_{
1162 decltype(_impl_._has_bits_){}
1163 , /*decltype(_impl_._cached_size_)*/{}
1164 , decltype(_impl_.content_trigger_name_hash_){::uint64_t{0u}}
1165 , decltype(_impl_.event_type_){0}
1166 };
1167 }
1168
~BackgroundTracingMetadata_TriggerRule_NamedRule()1169 BackgroundTracingMetadata_TriggerRule_NamedRule::~BackgroundTracingMetadata_TriggerRule_NamedRule() {
1170 // @@protoc_insertion_point(destructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1171 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1172 (void)arena;
1173 return;
1174 }
1175 SharedDtor();
1176 }
1177
SharedDtor()1178 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::SharedDtor() {
1179 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1180 }
1181
SetCachedSize(int size) const1182 void BackgroundTracingMetadata_TriggerRule_NamedRule::SetCachedSize(int size) const {
1183 _impl_._cached_size_.Set(size);
1184 }
1185
Clear()1186 void BackgroundTracingMetadata_TriggerRule_NamedRule::Clear() {
1187 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1188 ::uint32_t cached_has_bits = 0;
1189 // Prevent compiler warnings about cached_has_bits being unused
1190 (void) cached_has_bits;
1191
1192 cached_has_bits = _impl_._has_bits_[0];
1193 if (cached_has_bits & 0x00000003u) {
1194 ::memset(&_impl_.content_trigger_name_hash_, 0, static_cast<size_t>(
1195 reinterpret_cast<char*>(&_impl_.event_type_) -
1196 reinterpret_cast<char*>(&_impl_.content_trigger_name_hash_)) + sizeof(_impl_.event_type_));
1197 }
1198 _impl_._has_bits_.Clear();
1199 _internal_metadata_.Clear<std::string>();
1200 }
1201
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1202 const char* BackgroundTracingMetadata_TriggerRule_NamedRule::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1203 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1204 _Internal::HasBits has_bits{};
1205 while (!ctx->Done(&ptr)) {
1206 ::uint32_t tag;
1207 ptr = ::_pbi::ReadTag(ptr, &tag);
1208 switch (tag >> 3) {
1209 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.EventType event_type = 1;
1210 case 1:
1211 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1212 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1213 CHK_(ptr);
1214 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_IsValid(val))) {
1215 _internal_set_event_type(static_cast<::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType>(val));
1216 } else {
1217 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
1218 }
1219 } else {
1220 goto handle_unusual;
1221 }
1222 continue;
1223 // optional fixed64 content_trigger_name_hash = 2;
1224 case 2:
1225 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 17)) {
1226 _Internal::set_has_content_trigger_name_hash(&has_bits);
1227 _impl_.content_trigger_name_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
1228 ptr += sizeof(::uint64_t);
1229 } else {
1230 goto handle_unusual;
1231 }
1232 continue;
1233 default:
1234 goto handle_unusual;
1235 } // switch
1236 handle_unusual:
1237 if ((tag == 0) || ((tag & 7) == 4)) {
1238 CHK_(ptr);
1239 ctx->SetLastTag(tag);
1240 goto message_done;
1241 }
1242 ptr = UnknownFieldParse(
1243 tag,
1244 _internal_metadata_.mutable_unknown_fields<std::string>(),
1245 ptr, ctx);
1246 CHK_(ptr != nullptr);
1247 } // while
1248 message_done:
1249 _impl_._has_bits_.Or(has_bits);
1250 return ptr;
1251 failure:
1252 ptr = nullptr;
1253 goto message_done;
1254 #undef CHK_
1255 }
1256
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1257 ::uint8_t* BackgroundTracingMetadata_TriggerRule_NamedRule::_InternalSerialize(
1258 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1259 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1260 ::uint32_t cached_has_bits = 0;
1261 (void) cached_has_bits;
1262
1263 cached_has_bits = _impl_._has_bits_[0];
1264 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.EventType event_type = 1;
1265 if (cached_has_bits & 0x00000002u) {
1266 target = stream->EnsureSpace(target);
1267 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1268 1, this->_internal_event_type(), target);
1269 }
1270
1271 // optional fixed64 content_trigger_name_hash = 2;
1272 if (cached_has_bits & 0x00000001u) {
1273 target = stream->EnsureSpace(target);
1274 target = ::_pbi::WireFormatLite::WriteFixed64ToArray(2, this->_internal_content_trigger_name_hash(), target);
1275 }
1276
1277 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1278 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1279 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1280 }
1281 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1282 return target;
1283 }
1284
ByteSizeLong() const1285 size_t BackgroundTracingMetadata_TriggerRule_NamedRule::ByteSizeLong() const {
1286 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1287 size_t total_size = 0;
1288
1289 ::uint32_t cached_has_bits = 0;
1290 // Prevent compiler warnings about cached_has_bits being unused
1291 (void) cached_has_bits;
1292
1293 cached_has_bits = _impl_._has_bits_[0];
1294 if (cached_has_bits & 0x00000003u) {
1295 // optional fixed64 content_trigger_name_hash = 2;
1296 if (cached_has_bits & 0x00000001u) {
1297 total_size += 1 + 8;
1298 }
1299
1300 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.EventType event_type = 1;
1301 if (cached_has_bits & 0x00000002u) {
1302 total_size += 1 +
1303 ::_pbi::WireFormatLite::EnumSize(this->_internal_event_type());
1304 }
1305
1306 }
1307 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1308 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1309 }
1310 int cached_size = ::_pbi::ToCachedSize(total_size);
1311 SetCachedSize(cached_size);
1312 return total_size;
1313 }
1314
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1315 void BackgroundTracingMetadata_TriggerRule_NamedRule::CheckTypeAndMergeFrom(
1316 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1317 MergeFrom(*::_pbi::DownCast<const BackgroundTracingMetadata_TriggerRule_NamedRule*>(
1318 &from));
1319 }
1320
MergeFrom(const BackgroundTracingMetadata_TriggerRule_NamedRule & from)1321 void BackgroundTracingMetadata_TriggerRule_NamedRule::MergeFrom(const BackgroundTracingMetadata_TriggerRule_NamedRule& from) {
1322 BackgroundTracingMetadata_TriggerRule_NamedRule* const _this = this;
1323 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1324 GOOGLE_DCHECK_NE(&from, _this);
1325 ::uint32_t cached_has_bits = 0;
1326 (void) cached_has_bits;
1327
1328 cached_has_bits = from._impl_._has_bits_[0];
1329 if (cached_has_bits & 0x00000003u) {
1330 if (cached_has_bits & 0x00000001u) {
1331 _this->_impl_.content_trigger_name_hash_ = from._impl_.content_trigger_name_hash_;
1332 }
1333 if (cached_has_bits & 0x00000002u) {
1334 _this->_impl_.event_type_ = from._impl_.event_type_;
1335 }
1336 _this->_impl_._has_bits_[0] |= cached_has_bits;
1337 }
1338 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1339 }
1340
CopyFrom(const BackgroundTracingMetadata_TriggerRule_NamedRule & from)1341 void BackgroundTracingMetadata_TriggerRule_NamedRule::CopyFrom(const BackgroundTracingMetadata_TriggerRule_NamedRule& from) {
1342 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
1343 if (&from == this) return;
1344 Clear();
1345 MergeFrom(from);
1346 }
1347
IsInitialized() const1348 bool BackgroundTracingMetadata_TriggerRule_NamedRule::IsInitialized() const {
1349 return true;
1350 }
1351
InternalSwap(BackgroundTracingMetadata_TriggerRule_NamedRule * other)1352 void BackgroundTracingMetadata_TriggerRule_NamedRule::InternalSwap(BackgroundTracingMetadata_TriggerRule_NamedRule* other) {
1353 using std::swap;
1354 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1355 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1356 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1357 PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata_TriggerRule_NamedRule, _impl_.event_type_)
1358 + sizeof(BackgroundTracingMetadata_TriggerRule_NamedRule::_impl_.event_type_) // NOLINT
1359 - PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata_TriggerRule_NamedRule, _impl_.content_trigger_name_hash_)>(
1360 reinterpret_cast<char*>(&_impl_.content_trigger_name_hash_),
1361 reinterpret_cast<char*>(&other->_impl_.content_trigger_name_hash_));
1362 }
1363
GetTypeName() const1364 std::string BackgroundTracingMetadata_TriggerRule_NamedRule::GetTypeName() const {
1365 return "perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule";
1366 }
1367
1368
1369 // ===================================================================
1370
1371 class BackgroundTracingMetadata_TriggerRule::_Internal {
1372 public:
1373 using HasBits = decltype(std::declval<BackgroundTracingMetadata_TriggerRule>()._impl_._has_bits_);
set_has_trigger_type(HasBits * has_bits)1374 static void set_has_trigger_type(HasBits* has_bits) {
1375 (*has_bits)[0] |= 4u;
1376 }
1377 static const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule& histogram_rule(const BackgroundTracingMetadata_TriggerRule* msg);
set_has_histogram_rule(HasBits * has_bits)1378 static void set_has_histogram_rule(HasBits* has_bits) {
1379 (*has_bits)[0] |= 1u;
1380 }
1381 static const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule& named_rule(const BackgroundTracingMetadata_TriggerRule* msg);
set_has_named_rule(HasBits * has_bits)1382 static void set_has_named_rule(HasBits* has_bits) {
1383 (*has_bits)[0] |= 2u;
1384 }
set_has_name_hash(HasBits * has_bits)1385 static void set_has_name_hash(HasBits* has_bits) {
1386 (*has_bits)[0] |= 8u;
1387 }
1388 };
1389
1390 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule&
histogram_rule(const BackgroundTracingMetadata_TriggerRule * msg)1391 BackgroundTracingMetadata_TriggerRule::_Internal::histogram_rule(const BackgroundTracingMetadata_TriggerRule* msg) {
1392 return *msg->_impl_.histogram_rule_;
1393 }
1394 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule&
named_rule(const BackgroundTracingMetadata_TriggerRule * msg)1395 BackgroundTracingMetadata_TriggerRule::_Internal::named_rule(const BackgroundTracingMetadata_TriggerRule* msg) {
1396 return *msg->_impl_.named_rule_;
1397 }
BackgroundTracingMetadata_TriggerRule(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1398 BackgroundTracingMetadata_TriggerRule::BackgroundTracingMetadata_TriggerRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1399 bool is_message_owned)
1400 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1401 SharedCtor(arena, is_message_owned);
1402 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1403 }
BackgroundTracingMetadata_TriggerRule(const BackgroundTracingMetadata_TriggerRule & from)1404 BackgroundTracingMetadata_TriggerRule::BackgroundTracingMetadata_TriggerRule(const BackgroundTracingMetadata_TriggerRule& from)
1405 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1406 BackgroundTracingMetadata_TriggerRule* const _this = this; (void)_this;
1407 new (&_impl_) Impl_{
1408 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1409 , /*decltype(_impl_._cached_size_)*/{}
1410 , decltype(_impl_.histogram_rule_){nullptr}
1411 , decltype(_impl_.named_rule_){nullptr}
1412 , decltype(_impl_.trigger_type_){}
1413 , decltype(_impl_.name_hash_){}};
1414
1415 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1416 if (from._internal_has_histogram_rule()) {
1417 _this->_impl_.histogram_rule_ = new ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule(*from._impl_.histogram_rule_);
1418 }
1419 if (from._internal_has_named_rule()) {
1420 _this->_impl_.named_rule_ = new ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule(*from._impl_.named_rule_);
1421 }
1422 ::memcpy(&_impl_.trigger_type_, &from._impl_.trigger_type_,
1423 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.name_hash_) -
1424 reinterpret_cast<char*>(&_impl_.trigger_type_)) + sizeof(_impl_.name_hash_));
1425 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1426 }
1427
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1428 inline void BackgroundTracingMetadata_TriggerRule::SharedCtor(
1429 ::_pb::Arena* arena, bool is_message_owned) {
1430 (void)arena;
1431 (void)is_message_owned;
1432 new (&_impl_) Impl_{
1433 decltype(_impl_._has_bits_){}
1434 , /*decltype(_impl_._cached_size_)*/{}
1435 , decltype(_impl_.histogram_rule_){nullptr}
1436 , decltype(_impl_.named_rule_){nullptr}
1437 , decltype(_impl_.trigger_type_){0}
1438 , decltype(_impl_.name_hash_){0u}
1439 };
1440 }
1441
~BackgroundTracingMetadata_TriggerRule()1442 BackgroundTracingMetadata_TriggerRule::~BackgroundTracingMetadata_TriggerRule() {
1443 // @@protoc_insertion_point(destructor:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1444 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1445 (void)arena;
1446 return;
1447 }
1448 SharedDtor();
1449 }
1450
SharedDtor()1451 inline void BackgroundTracingMetadata_TriggerRule::SharedDtor() {
1452 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1453 if (this != internal_default_instance()) delete _impl_.histogram_rule_;
1454 if (this != internal_default_instance()) delete _impl_.named_rule_;
1455 }
1456
SetCachedSize(int size) const1457 void BackgroundTracingMetadata_TriggerRule::SetCachedSize(int size) const {
1458 _impl_._cached_size_.Set(size);
1459 }
1460
Clear()1461 void BackgroundTracingMetadata_TriggerRule::Clear() {
1462 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1463 ::uint32_t cached_has_bits = 0;
1464 // Prevent compiler warnings about cached_has_bits being unused
1465 (void) cached_has_bits;
1466
1467 cached_has_bits = _impl_._has_bits_[0];
1468 if (cached_has_bits & 0x00000003u) {
1469 if (cached_has_bits & 0x00000001u) {
1470 GOOGLE_DCHECK(_impl_.histogram_rule_ != nullptr);
1471 _impl_.histogram_rule_->Clear();
1472 }
1473 if (cached_has_bits & 0x00000002u) {
1474 GOOGLE_DCHECK(_impl_.named_rule_ != nullptr);
1475 _impl_.named_rule_->Clear();
1476 }
1477 }
1478 if (cached_has_bits & 0x0000000cu) {
1479 ::memset(&_impl_.trigger_type_, 0, static_cast<size_t>(
1480 reinterpret_cast<char*>(&_impl_.name_hash_) -
1481 reinterpret_cast<char*>(&_impl_.trigger_type_)) + sizeof(_impl_.name_hash_));
1482 }
1483 _impl_._has_bits_.Clear();
1484 _internal_metadata_.Clear<std::string>();
1485 }
1486
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1487 const char* BackgroundTracingMetadata_TriggerRule::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1488 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1489 _Internal::HasBits has_bits{};
1490 while (!ctx->Done(&ptr)) {
1491 ::uint32_t tag;
1492 ptr = ::_pbi::ReadTag(ptr, &tag);
1493 switch (tag >> 3) {
1494 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.TriggerType trigger_type = 1;
1495 case 1:
1496 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1497 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1498 CHK_(ptr);
1499 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType_IsValid(val))) {
1500 _internal_set_trigger_type(static_cast<::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType>(val));
1501 } else {
1502 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
1503 }
1504 } else {
1505 goto handle_unusual;
1506 }
1507 continue;
1508 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule histogram_rule = 2;
1509 case 2:
1510 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1511 ptr = ctx->ParseMessage(_internal_mutable_histogram_rule(), ptr);
1512 CHK_(ptr);
1513 } else {
1514 goto handle_unusual;
1515 }
1516 continue;
1517 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule named_rule = 3;
1518 case 3:
1519 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1520 ptr = ctx->ParseMessage(_internal_mutable_named_rule(), ptr);
1521 CHK_(ptr);
1522 } else {
1523 goto handle_unusual;
1524 }
1525 continue;
1526 // optional fixed32 name_hash = 4;
1527 case 4:
1528 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 37)) {
1529 _Internal::set_has_name_hash(&has_bits);
1530 _impl_.name_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint32_t>(ptr);
1531 ptr += sizeof(::uint32_t);
1532 } else {
1533 goto handle_unusual;
1534 }
1535 continue;
1536 default:
1537 goto handle_unusual;
1538 } // switch
1539 handle_unusual:
1540 if ((tag == 0) || ((tag & 7) == 4)) {
1541 CHK_(ptr);
1542 ctx->SetLastTag(tag);
1543 goto message_done;
1544 }
1545 ptr = UnknownFieldParse(
1546 tag,
1547 _internal_metadata_.mutable_unknown_fields<std::string>(),
1548 ptr, ctx);
1549 CHK_(ptr != nullptr);
1550 } // while
1551 message_done:
1552 _impl_._has_bits_.Or(has_bits);
1553 return ptr;
1554 failure:
1555 ptr = nullptr;
1556 goto message_done;
1557 #undef CHK_
1558 }
1559
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1560 ::uint8_t* BackgroundTracingMetadata_TriggerRule::_InternalSerialize(
1561 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1562 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1563 ::uint32_t cached_has_bits = 0;
1564 (void) cached_has_bits;
1565
1566 cached_has_bits = _impl_._has_bits_[0];
1567 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.TriggerType trigger_type = 1;
1568 if (cached_has_bits & 0x00000004u) {
1569 target = stream->EnsureSpace(target);
1570 target = ::_pbi::WireFormatLite::WriteEnumToArray(
1571 1, this->_internal_trigger_type(), target);
1572 }
1573
1574 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule histogram_rule = 2;
1575 if (cached_has_bits & 0x00000001u) {
1576 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1577 InternalWriteMessage(2, _Internal::histogram_rule(this),
1578 _Internal::histogram_rule(this).GetCachedSize(), target, stream);
1579 }
1580
1581 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule named_rule = 3;
1582 if (cached_has_bits & 0x00000002u) {
1583 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1584 InternalWriteMessage(3, _Internal::named_rule(this),
1585 _Internal::named_rule(this).GetCachedSize(), target, stream);
1586 }
1587
1588 // optional fixed32 name_hash = 4;
1589 if (cached_has_bits & 0x00000008u) {
1590 target = stream->EnsureSpace(target);
1591 target = ::_pbi::WireFormatLite::WriteFixed32ToArray(4, this->_internal_name_hash(), target);
1592 }
1593
1594 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1595 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1596 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1597 }
1598 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1599 return target;
1600 }
1601
ByteSizeLong() const1602 size_t BackgroundTracingMetadata_TriggerRule::ByteSizeLong() const {
1603 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1604 size_t total_size = 0;
1605
1606 ::uint32_t cached_has_bits = 0;
1607 // Prevent compiler warnings about cached_has_bits being unused
1608 (void) cached_has_bits;
1609
1610 cached_has_bits = _impl_._has_bits_[0];
1611 if (cached_has_bits & 0x0000000fu) {
1612 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule histogram_rule = 2;
1613 if (cached_has_bits & 0x00000001u) {
1614 total_size += 1 +
1615 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1616 *_impl_.histogram_rule_);
1617 }
1618
1619 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule named_rule = 3;
1620 if (cached_has_bits & 0x00000002u) {
1621 total_size += 1 +
1622 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1623 *_impl_.named_rule_);
1624 }
1625
1626 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.TriggerType trigger_type = 1;
1627 if (cached_has_bits & 0x00000004u) {
1628 total_size += 1 +
1629 ::_pbi::WireFormatLite::EnumSize(this->_internal_trigger_type());
1630 }
1631
1632 // optional fixed32 name_hash = 4;
1633 if (cached_has_bits & 0x00000008u) {
1634 total_size += 1 + 4;
1635 }
1636
1637 }
1638 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1639 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1640 }
1641 int cached_size = ::_pbi::ToCachedSize(total_size);
1642 SetCachedSize(cached_size);
1643 return total_size;
1644 }
1645
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1646 void BackgroundTracingMetadata_TriggerRule::CheckTypeAndMergeFrom(
1647 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1648 MergeFrom(*::_pbi::DownCast<const BackgroundTracingMetadata_TriggerRule*>(
1649 &from));
1650 }
1651
MergeFrom(const BackgroundTracingMetadata_TriggerRule & from)1652 void BackgroundTracingMetadata_TriggerRule::MergeFrom(const BackgroundTracingMetadata_TriggerRule& from) {
1653 BackgroundTracingMetadata_TriggerRule* const _this = this;
1654 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1655 GOOGLE_DCHECK_NE(&from, _this);
1656 ::uint32_t cached_has_bits = 0;
1657 (void) cached_has_bits;
1658
1659 cached_has_bits = from._impl_._has_bits_[0];
1660 if (cached_has_bits & 0x0000000fu) {
1661 if (cached_has_bits & 0x00000001u) {
1662 _this->_internal_mutable_histogram_rule()->::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule::MergeFrom(
1663 from._internal_histogram_rule());
1664 }
1665 if (cached_has_bits & 0x00000002u) {
1666 _this->_internal_mutable_named_rule()->::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule::MergeFrom(
1667 from._internal_named_rule());
1668 }
1669 if (cached_has_bits & 0x00000004u) {
1670 _this->_impl_.trigger_type_ = from._impl_.trigger_type_;
1671 }
1672 if (cached_has_bits & 0x00000008u) {
1673 _this->_impl_.name_hash_ = from._impl_.name_hash_;
1674 }
1675 _this->_impl_._has_bits_[0] |= cached_has_bits;
1676 }
1677 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1678 }
1679
CopyFrom(const BackgroundTracingMetadata_TriggerRule & from)1680 void BackgroundTracingMetadata_TriggerRule::CopyFrom(const BackgroundTracingMetadata_TriggerRule& from) {
1681 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1682 if (&from == this) return;
1683 Clear();
1684 MergeFrom(from);
1685 }
1686
IsInitialized() const1687 bool BackgroundTracingMetadata_TriggerRule::IsInitialized() const {
1688 return true;
1689 }
1690
InternalSwap(BackgroundTracingMetadata_TriggerRule * other)1691 void BackgroundTracingMetadata_TriggerRule::InternalSwap(BackgroundTracingMetadata_TriggerRule* other) {
1692 using std::swap;
1693 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1694 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1695 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1696 PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata_TriggerRule, _impl_.name_hash_)
1697 + sizeof(BackgroundTracingMetadata_TriggerRule::_impl_.name_hash_) // NOLINT
1698 - PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata_TriggerRule, _impl_.histogram_rule_)>(
1699 reinterpret_cast<char*>(&_impl_.histogram_rule_),
1700 reinterpret_cast<char*>(&other->_impl_.histogram_rule_));
1701 }
1702
GetTypeName() const1703 std::string BackgroundTracingMetadata_TriggerRule::GetTypeName() const {
1704 return "perfetto.protos.BackgroundTracingMetadata.TriggerRule";
1705 }
1706
1707
1708 // ===================================================================
1709
1710 class BackgroundTracingMetadata::_Internal {
1711 public:
1712 using HasBits = decltype(std::declval<BackgroundTracingMetadata>()._impl_._has_bits_);
1713 static const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& triggered_rule(const BackgroundTracingMetadata* msg);
set_has_triggered_rule(HasBits * has_bits)1714 static void set_has_triggered_rule(HasBits* has_bits) {
1715 (*has_bits)[0] |= 1u;
1716 }
set_has_scenario_name_hash(HasBits * has_bits)1717 static void set_has_scenario_name_hash(HasBits* has_bits) {
1718 (*has_bits)[0] |= 2u;
1719 }
1720 };
1721
1722 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule&
triggered_rule(const BackgroundTracingMetadata * msg)1723 BackgroundTracingMetadata::_Internal::triggered_rule(const BackgroundTracingMetadata* msg) {
1724 return *msg->_impl_.triggered_rule_;
1725 }
BackgroundTracingMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1726 BackgroundTracingMetadata::BackgroundTracingMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1727 bool is_message_owned)
1728 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1729 SharedCtor(arena, is_message_owned);
1730 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BackgroundTracingMetadata)
1731 }
BackgroundTracingMetadata(const BackgroundTracingMetadata & from)1732 BackgroundTracingMetadata::BackgroundTracingMetadata(const BackgroundTracingMetadata& from)
1733 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1734 BackgroundTracingMetadata* const _this = this; (void)_this;
1735 new (&_impl_) Impl_{
1736 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1737 , /*decltype(_impl_._cached_size_)*/{}
1738 , decltype(_impl_.active_rules_){from._impl_.active_rules_}
1739 , decltype(_impl_.triggered_rule_){nullptr}
1740 , decltype(_impl_.scenario_name_hash_){}};
1741
1742 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1743 if (from._internal_has_triggered_rule()) {
1744 _this->_impl_.triggered_rule_ = new ::perfetto::protos::BackgroundTracingMetadata_TriggerRule(*from._impl_.triggered_rule_);
1745 }
1746 _this->_impl_.scenario_name_hash_ = from._impl_.scenario_name_hash_;
1747 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BackgroundTracingMetadata)
1748 }
1749
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1750 inline void BackgroundTracingMetadata::SharedCtor(
1751 ::_pb::Arena* arena, bool is_message_owned) {
1752 (void)arena;
1753 (void)is_message_owned;
1754 new (&_impl_) Impl_{
1755 decltype(_impl_._has_bits_){}
1756 , /*decltype(_impl_._cached_size_)*/{}
1757 , decltype(_impl_.active_rules_){arena}
1758 , decltype(_impl_.triggered_rule_){nullptr}
1759 , decltype(_impl_.scenario_name_hash_){0u}
1760 };
1761 }
1762
~BackgroundTracingMetadata()1763 BackgroundTracingMetadata::~BackgroundTracingMetadata() {
1764 // @@protoc_insertion_point(destructor:perfetto.protos.BackgroundTracingMetadata)
1765 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1766 (void)arena;
1767 return;
1768 }
1769 SharedDtor();
1770 }
1771
SharedDtor()1772 inline void BackgroundTracingMetadata::SharedDtor() {
1773 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1774 _impl_.active_rules_.~RepeatedPtrField();
1775 if (this != internal_default_instance()) delete _impl_.triggered_rule_;
1776 }
1777
SetCachedSize(int size) const1778 void BackgroundTracingMetadata::SetCachedSize(int size) const {
1779 _impl_._cached_size_.Set(size);
1780 }
1781
Clear()1782 void BackgroundTracingMetadata::Clear() {
1783 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BackgroundTracingMetadata)
1784 ::uint32_t cached_has_bits = 0;
1785 // Prevent compiler warnings about cached_has_bits being unused
1786 (void) cached_has_bits;
1787
1788 _impl_.active_rules_.Clear();
1789 cached_has_bits = _impl_._has_bits_[0];
1790 if (cached_has_bits & 0x00000001u) {
1791 GOOGLE_DCHECK(_impl_.triggered_rule_ != nullptr);
1792 _impl_.triggered_rule_->Clear();
1793 }
1794 _impl_.scenario_name_hash_ = 0u;
1795 _impl_._has_bits_.Clear();
1796 _internal_metadata_.Clear<std::string>();
1797 }
1798
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1799 const char* BackgroundTracingMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1800 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1801 _Internal::HasBits has_bits{};
1802 while (!ctx->Done(&ptr)) {
1803 ::uint32_t tag;
1804 ptr = ::_pbi::ReadTag(ptr, &tag);
1805 switch (tag >> 3) {
1806 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule triggered_rule = 1;
1807 case 1:
1808 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1809 ptr = ctx->ParseMessage(_internal_mutable_triggered_rule(), ptr);
1810 CHK_(ptr);
1811 } else {
1812 goto handle_unusual;
1813 }
1814 continue;
1815 // repeated .perfetto.protos.BackgroundTracingMetadata.TriggerRule active_rules = 2;
1816 case 2:
1817 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1818 ptr -= 1;
1819 do {
1820 ptr += 1;
1821 ptr = ctx->ParseMessage(_internal_add_active_rules(), ptr);
1822 CHK_(ptr);
1823 if (!ctx->DataAvailable(ptr)) break;
1824 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1825 } else {
1826 goto handle_unusual;
1827 }
1828 continue;
1829 // optional fixed32 scenario_name_hash = 3;
1830 case 3:
1831 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 29)) {
1832 _Internal::set_has_scenario_name_hash(&has_bits);
1833 _impl_.scenario_name_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint32_t>(ptr);
1834 ptr += sizeof(::uint32_t);
1835 } else {
1836 goto handle_unusual;
1837 }
1838 continue;
1839 default:
1840 goto handle_unusual;
1841 } // switch
1842 handle_unusual:
1843 if ((tag == 0) || ((tag & 7) == 4)) {
1844 CHK_(ptr);
1845 ctx->SetLastTag(tag);
1846 goto message_done;
1847 }
1848 ptr = UnknownFieldParse(
1849 tag,
1850 _internal_metadata_.mutable_unknown_fields<std::string>(),
1851 ptr, ctx);
1852 CHK_(ptr != nullptr);
1853 } // while
1854 message_done:
1855 _impl_._has_bits_.Or(has_bits);
1856 return ptr;
1857 failure:
1858 ptr = nullptr;
1859 goto message_done;
1860 #undef CHK_
1861 }
1862
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1863 ::uint8_t* BackgroundTracingMetadata::_InternalSerialize(
1864 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1865 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BackgroundTracingMetadata)
1866 ::uint32_t cached_has_bits = 0;
1867 (void) cached_has_bits;
1868
1869 cached_has_bits = _impl_._has_bits_[0];
1870 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule triggered_rule = 1;
1871 if (cached_has_bits & 0x00000001u) {
1872 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1873 InternalWriteMessage(1, _Internal::triggered_rule(this),
1874 _Internal::triggered_rule(this).GetCachedSize(), target, stream);
1875 }
1876
1877 // repeated .perfetto.protos.BackgroundTracingMetadata.TriggerRule active_rules = 2;
1878 for (unsigned i = 0,
1879 n = static_cast<unsigned>(this->_internal_active_rules_size()); i < n; i++) {
1880 const auto& repfield = this->_internal_active_rules(i);
1881 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1882 InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1883 }
1884
1885 // optional fixed32 scenario_name_hash = 3;
1886 if (cached_has_bits & 0x00000002u) {
1887 target = stream->EnsureSpace(target);
1888 target = ::_pbi::WireFormatLite::WriteFixed32ToArray(3, this->_internal_scenario_name_hash(), target);
1889 }
1890
1891 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1892 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1893 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1894 }
1895 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BackgroundTracingMetadata)
1896 return target;
1897 }
1898
ByteSizeLong() const1899 size_t BackgroundTracingMetadata::ByteSizeLong() const {
1900 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BackgroundTracingMetadata)
1901 size_t total_size = 0;
1902
1903 ::uint32_t cached_has_bits = 0;
1904 // Prevent compiler warnings about cached_has_bits being unused
1905 (void) cached_has_bits;
1906
1907 // repeated .perfetto.protos.BackgroundTracingMetadata.TriggerRule active_rules = 2;
1908 total_size += 1UL * this->_internal_active_rules_size();
1909 for (const auto& msg : this->_impl_.active_rules_) {
1910 total_size +=
1911 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1912 }
1913
1914 cached_has_bits = _impl_._has_bits_[0];
1915 if (cached_has_bits & 0x00000003u) {
1916 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule triggered_rule = 1;
1917 if (cached_has_bits & 0x00000001u) {
1918 total_size += 1 +
1919 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1920 *_impl_.triggered_rule_);
1921 }
1922
1923 // optional fixed32 scenario_name_hash = 3;
1924 if (cached_has_bits & 0x00000002u) {
1925 total_size += 1 + 4;
1926 }
1927
1928 }
1929 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1930 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1931 }
1932 int cached_size = ::_pbi::ToCachedSize(total_size);
1933 SetCachedSize(cached_size);
1934 return total_size;
1935 }
1936
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1937 void BackgroundTracingMetadata::CheckTypeAndMergeFrom(
1938 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1939 MergeFrom(*::_pbi::DownCast<const BackgroundTracingMetadata*>(
1940 &from));
1941 }
1942
MergeFrom(const BackgroundTracingMetadata & from)1943 void BackgroundTracingMetadata::MergeFrom(const BackgroundTracingMetadata& from) {
1944 BackgroundTracingMetadata* const _this = this;
1945 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BackgroundTracingMetadata)
1946 GOOGLE_DCHECK_NE(&from, _this);
1947 ::uint32_t cached_has_bits = 0;
1948 (void) cached_has_bits;
1949
1950 _this->_impl_.active_rules_.MergeFrom(from._impl_.active_rules_);
1951 cached_has_bits = from._impl_._has_bits_[0];
1952 if (cached_has_bits & 0x00000003u) {
1953 if (cached_has_bits & 0x00000001u) {
1954 _this->_internal_mutable_triggered_rule()->::perfetto::protos::BackgroundTracingMetadata_TriggerRule::MergeFrom(
1955 from._internal_triggered_rule());
1956 }
1957 if (cached_has_bits & 0x00000002u) {
1958 _this->_impl_.scenario_name_hash_ = from._impl_.scenario_name_hash_;
1959 }
1960 _this->_impl_._has_bits_[0] |= cached_has_bits;
1961 }
1962 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1963 }
1964
CopyFrom(const BackgroundTracingMetadata & from)1965 void BackgroundTracingMetadata::CopyFrom(const BackgroundTracingMetadata& from) {
1966 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BackgroundTracingMetadata)
1967 if (&from == this) return;
1968 Clear();
1969 MergeFrom(from);
1970 }
1971
IsInitialized() const1972 bool BackgroundTracingMetadata::IsInitialized() const {
1973 return true;
1974 }
1975
InternalSwap(BackgroundTracingMetadata * other)1976 void BackgroundTracingMetadata::InternalSwap(BackgroundTracingMetadata* other) {
1977 using std::swap;
1978 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1979 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1980 _impl_.active_rules_.InternalSwap(&other->_impl_.active_rules_);
1981 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1982 PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata, _impl_.scenario_name_hash_)
1983 + sizeof(BackgroundTracingMetadata::_impl_.scenario_name_hash_) // NOLINT
1984 - PROTOBUF_FIELD_OFFSET(BackgroundTracingMetadata, _impl_.triggered_rule_)>(
1985 reinterpret_cast<char*>(&_impl_.triggered_rule_),
1986 reinterpret_cast<char*>(&other->_impl_.triggered_rule_));
1987 }
1988
GetTypeName() const1989 std::string BackgroundTracingMetadata::GetTypeName() const {
1990 return "perfetto.protos.BackgroundTracingMetadata";
1991 }
1992
1993
1994 // @@protoc_insertion_point(namespace_scope)
1995 } // namespace protos
1996 } // namespace perfetto
1997 PROTOBUF_NAMESPACE_OPEN
1998 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeMetadataPacket_FinchHash*
CreateMaybeMessage(Arena * arena)1999 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeMetadataPacket_FinchHash >(Arena* arena) {
2000 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeMetadataPacket_FinchHash >(arena);
2001 }
2002 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeMetadataPacket*
CreateMaybeMessage(Arena * arena)2003 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeMetadataPacket >(Arena* arena) {
2004 return Arena::CreateMessageInternal< ::perfetto::protos::ChromeMetadataPacket >(arena);
2005 }
2006 template<> PROTOBUF_NOINLINE ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule*
CreateMaybeMessage(Arena * arena)2007 Arena::CreateMaybeMessage< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule >(Arena* arena) {
2008 return Arena::CreateMessageInternal< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule >(arena);
2009 }
2010 template<> PROTOBUF_NOINLINE ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule*
CreateMaybeMessage(Arena * arena)2011 Arena::CreateMaybeMessage< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule >(Arena* arena) {
2012 return Arena::CreateMessageInternal< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule >(arena);
2013 }
2014 template<> PROTOBUF_NOINLINE ::perfetto::protos::BackgroundTracingMetadata_TriggerRule*
CreateMaybeMessage(Arena * arena)2015 Arena::CreateMaybeMessage< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule >(Arena* arena) {
2016 return Arena::CreateMessageInternal< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule >(arena);
2017 }
2018 template<> PROTOBUF_NOINLINE ::perfetto::protos::BackgroundTracingMetadata*
CreateMaybeMessage(Arena * arena)2019 Arena::CreateMaybeMessage< ::perfetto::protos::BackgroundTracingMetadata >(Arena* arena) {
2020 return Arena::CreateMessageInternal< ::perfetto::protos::BackgroundTracingMetadata >(arena);
2021 }
2022 PROTOBUF_NAMESPACE_CLOSE
2023
2024 // @@protoc_insertion_point(global_scope)
2025 #include <google/protobuf/port_undef.inc>
2026