1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/chrome/chrome_metadata.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/generated_enum_util.h>
33 // @@protoc_insertion_point(includes)
34 #include <google/protobuf/port_def.inc>
35 #define PROTOBUF_INTERNAL_EXPORT_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto
36 PROTOBUF_NAMESPACE_OPEN
37 namespace internal {
38 class AnyMetadata;
39 } // namespace internal
40 PROTOBUF_NAMESPACE_CLOSE
41
42 // Internal implementation detail -- do not use these members.
43 struct TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto {
44 static const ::uint32_t offsets[];
45 };
46 namespace perfetto {
47 namespace protos {
48 class BackgroundTracingMetadata;
49 struct BackgroundTracingMetadataDefaultTypeInternal;
50 extern BackgroundTracingMetadataDefaultTypeInternal _BackgroundTracingMetadata_default_instance_;
51 class BackgroundTracingMetadata_TriggerRule;
52 struct BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal;
53 extern BackgroundTracingMetadata_TriggerRuleDefaultTypeInternal _BackgroundTracingMetadata_TriggerRule_default_instance_;
54 class BackgroundTracingMetadata_TriggerRule_HistogramRule;
55 struct BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal;
56 extern BackgroundTracingMetadata_TriggerRule_HistogramRuleDefaultTypeInternal _BackgroundTracingMetadata_TriggerRule_HistogramRule_default_instance_;
57 class BackgroundTracingMetadata_TriggerRule_NamedRule;
58 struct BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal;
59 extern BackgroundTracingMetadata_TriggerRule_NamedRuleDefaultTypeInternal _BackgroundTracingMetadata_TriggerRule_NamedRule_default_instance_;
60 class ChromeMetadataPacket;
61 struct ChromeMetadataPacketDefaultTypeInternal;
62 extern ChromeMetadataPacketDefaultTypeInternal _ChromeMetadataPacket_default_instance_;
63 class ChromeMetadataPacket_FinchHash;
64 struct ChromeMetadataPacket_FinchHashDefaultTypeInternal;
65 extern ChromeMetadataPacket_FinchHashDefaultTypeInternal _ChromeMetadataPacket_FinchHash_default_instance_;
66 } // namespace protos
67 } // namespace perfetto
68 PROTOBUF_NAMESPACE_OPEN
69 template<> ::perfetto::protos::BackgroundTracingMetadata* Arena::CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata>(Arena*);
70 template<> ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* Arena::CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata_TriggerRule>(Arena*);
71 template<> ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* Arena::CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule>(Arena*);
72 template<> ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* Arena::CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule>(Arena*);
73 template<> ::perfetto::protos::ChromeMetadataPacket* Arena::CreateMaybeMessage<::perfetto::protos::ChromeMetadataPacket>(Arena*);
74 template<> ::perfetto::protos::ChromeMetadataPacket_FinchHash* Arena::CreateMaybeMessage<::perfetto::protos::ChromeMetadataPacket_FinchHash>(Arena*);
75 PROTOBUF_NAMESPACE_CLOSE
76 namespace perfetto {
77 namespace protos {
78
79 enum BackgroundTracingMetadata_TriggerRule_NamedRule_EventType : int {
80 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_UNSPECIFIED = 0,
81 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_SESSION_RESTORE = 1,
82 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_NAVIGATION = 2,
83 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_STARTUP = 3,
84 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_REACHED_CODE = 4,
85 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_CONTENT_TRIGGER = 5,
86 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_TEST_RULE = 1000
87 };
88 bool BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_IsValid(int value);
89 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_MIN = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_UNSPECIFIED;
90 constexpr BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_MAX = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_TEST_RULE;
91 constexpr int BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_ARRAYSIZE = BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_MAX + 1;
92
93 const std::string& BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value);
94 template<typename T>
BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(T enum_t_value)95 inline const std::string& BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(T enum_t_value) {
96 static_assert(::std::is_same<T, BackgroundTracingMetadata_TriggerRule_NamedRule_EventType>::value ||
97 ::std::is_integral<T>::value,
98 "Incorrect type passed to function BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name.");
99 return BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(static_cast<BackgroundTracingMetadata_TriggerRule_NamedRule_EventType>(enum_t_value));
100 }
101 bool BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Parse(
102 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BackgroundTracingMetadata_TriggerRule_NamedRule_EventType* value);
103 enum BackgroundTracingMetadata_TriggerRule_TriggerType : int {
104 BackgroundTracingMetadata_TriggerRule_TriggerType_TRIGGER_UNSPECIFIED = 0,
105 BackgroundTracingMetadata_TriggerRule_TriggerType_MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE = 1,
106 BackgroundTracingMetadata_TriggerRule_TriggerType_MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED = 2
107 };
108 bool BackgroundTracingMetadata_TriggerRule_TriggerType_IsValid(int value);
109 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_MIN = BackgroundTracingMetadata_TriggerRule_TriggerType_TRIGGER_UNSPECIFIED;
110 constexpr BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_MAX = BackgroundTracingMetadata_TriggerRule_TriggerType_MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
111 constexpr int BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_ARRAYSIZE = BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_MAX + 1;
112
113 const std::string& BackgroundTracingMetadata_TriggerRule_TriggerType_Name(BackgroundTracingMetadata_TriggerRule_TriggerType value);
114 template<typename T>
BackgroundTracingMetadata_TriggerRule_TriggerType_Name(T enum_t_value)115 inline const std::string& BackgroundTracingMetadata_TriggerRule_TriggerType_Name(T enum_t_value) {
116 static_assert(::std::is_same<T, BackgroundTracingMetadata_TriggerRule_TriggerType>::value ||
117 ::std::is_integral<T>::value,
118 "Incorrect type passed to function BackgroundTracingMetadata_TriggerRule_TriggerType_Name.");
119 return BackgroundTracingMetadata_TriggerRule_TriggerType_Name(static_cast<BackgroundTracingMetadata_TriggerRule_TriggerType>(enum_t_value));
120 }
121 bool BackgroundTracingMetadata_TriggerRule_TriggerType_Parse(
122 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, BackgroundTracingMetadata_TriggerRule_TriggerType* value);
123 // ===================================================================
124
125 class ChromeMetadataPacket_FinchHash final :
126 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeMetadataPacket.FinchHash) */ {
127 public:
ChromeMetadataPacket_FinchHash()128 inline ChromeMetadataPacket_FinchHash() : ChromeMetadataPacket_FinchHash(nullptr) {}
129 ~ChromeMetadataPacket_FinchHash() override;
130 explicit PROTOBUF_CONSTEXPR ChromeMetadataPacket_FinchHash(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
131
132 ChromeMetadataPacket_FinchHash(const ChromeMetadataPacket_FinchHash& from);
ChromeMetadataPacket_FinchHash(ChromeMetadataPacket_FinchHash && from)133 ChromeMetadataPacket_FinchHash(ChromeMetadataPacket_FinchHash&& from) noexcept
134 : ChromeMetadataPacket_FinchHash() {
135 *this = ::std::move(from);
136 }
137
138 inline ChromeMetadataPacket_FinchHash& operator=(const ChromeMetadataPacket_FinchHash& from) {
139 if (this == &from) return *this;
140 CopyFrom(from);
141 return *this;
142 }
143 inline ChromeMetadataPacket_FinchHash& operator=(ChromeMetadataPacket_FinchHash&& from) noexcept {
144 if (this == &from) return *this;
145 if (GetOwningArena() == from.GetOwningArena()
146 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
147 && GetOwningArena() != nullptr
148 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
149 ) {
150 InternalSwap(&from);
151 } else {
152 CopyFrom(from);
153 }
154 return *this;
155 }
156
unknown_fields()157 inline const std::string& unknown_fields() const {
158 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
159 }
mutable_unknown_fields()160 inline std::string* mutable_unknown_fields() {
161 return _internal_metadata_.mutable_unknown_fields<std::string>();
162 }
163
default_instance()164 static const ChromeMetadataPacket_FinchHash& default_instance() {
165 return *internal_default_instance();
166 }
internal_default_instance()167 static inline const ChromeMetadataPacket_FinchHash* internal_default_instance() {
168 return reinterpret_cast<const ChromeMetadataPacket_FinchHash*>(
169 &_ChromeMetadataPacket_FinchHash_default_instance_);
170 }
171 static constexpr int kIndexInFileMessages =
172 0;
173
swap(ChromeMetadataPacket_FinchHash & a,ChromeMetadataPacket_FinchHash & b)174 friend void swap(ChromeMetadataPacket_FinchHash& a, ChromeMetadataPacket_FinchHash& b) {
175 a.Swap(&b);
176 }
Swap(ChromeMetadataPacket_FinchHash * other)177 inline void Swap(ChromeMetadataPacket_FinchHash* other) {
178 if (other == this) return;
179 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
180 if (GetOwningArena() != nullptr &&
181 GetOwningArena() == other->GetOwningArena()) {
182 #else // PROTOBUF_FORCE_COPY_IN_SWAP
183 if (GetOwningArena() == other->GetOwningArena()) {
184 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
185 InternalSwap(other);
186 } else {
187 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
188 }
189 }
190 void UnsafeArenaSwap(ChromeMetadataPacket_FinchHash* other) {
191 if (other == this) return;
192 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
193 InternalSwap(other);
194 }
195
196 // implements Message ----------------------------------------------
197
198 ChromeMetadataPacket_FinchHash* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
199 return CreateMaybeMessage<ChromeMetadataPacket_FinchHash>(arena);
200 }
201 ChromeMetadataPacket_FinchHash* New() const {
202 return New(nullptr);
203 }
204 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
205 void CopyFrom(const ChromeMetadataPacket_FinchHash& from);
206 void MergeFrom(const ChromeMetadataPacket_FinchHash& from);
207 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
208 bool IsInitialized() const final;
209
210 size_t ByteSizeLong() const final;
211 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
212 ::uint8_t* _InternalSerialize(
213 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
214 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
215
216 private:
217 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
218 void SharedDtor();
219 void SetCachedSize(int size) const;
220 void InternalSwap(ChromeMetadataPacket_FinchHash* other);
221
222 private:
223 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
224 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
225 return "perfetto.protos.ChromeMetadataPacket.FinchHash";
226 }
227 protected:
228 explicit ChromeMetadataPacket_FinchHash(::PROTOBUF_NAMESPACE_ID::Arena* arena,
229 bool is_message_owned = false);
230 public:
231
232 std::string GetTypeName() const final;
233
234 // nested types ----------------------------------------------------
235
236 // accessors -------------------------------------------------------
237
238 enum : int {
239 kNameFieldNumber = 1,
240 kGroupFieldNumber = 2,
241 };
242 // optional uint32 name = 1;
243 bool has_name() const;
244 private:
245 bool _internal_has_name() const;
246 public:
247 void clear_name();
248 ::uint32_t name() const;
249 void set_name(::uint32_t value);
250 private:
251 ::uint32_t _internal_name() const;
252 void _internal_set_name(::uint32_t value);
253 public:
254
255 // optional uint32 group = 2;
256 bool has_group() const;
257 private:
258 bool _internal_has_group() const;
259 public:
260 void clear_group();
261 ::uint32_t group() const;
262 void set_group(::uint32_t value);
263 private:
264 ::uint32_t _internal_group() const;
265 void _internal_set_group(::uint32_t value);
266 public:
267
268 // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeMetadataPacket.FinchHash)
269 private:
270 class _Internal;
271
272 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
273 typedef void InternalArenaConstructable_;
274 typedef void DestructorSkippable_;
275 struct Impl_ {
276 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
277 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
278 ::uint32_t name_;
279 ::uint32_t group_;
280 };
281 union { Impl_ _impl_; };
282 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto;
283 };
284 // -------------------------------------------------------------------
285
286 class ChromeMetadataPacket final :
287 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.ChromeMetadataPacket) */ {
288 public:
ChromeMetadataPacket()289 inline ChromeMetadataPacket() : ChromeMetadataPacket(nullptr) {}
290 ~ChromeMetadataPacket() override;
291 explicit PROTOBUF_CONSTEXPR ChromeMetadataPacket(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
292
293 ChromeMetadataPacket(const ChromeMetadataPacket& from);
ChromeMetadataPacket(ChromeMetadataPacket && from)294 ChromeMetadataPacket(ChromeMetadataPacket&& from) noexcept
295 : ChromeMetadataPacket() {
296 *this = ::std::move(from);
297 }
298
299 inline ChromeMetadataPacket& operator=(const ChromeMetadataPacket& from) {
300 if (this == &from) return *this;
301 CopyFrom(from);
302 return *this;
303 }
304 inline ChromeMetadataPacket& operator=(ChromeMetadataPacket&& from) noexcept {
305 if (this == &from) return *this;
306 if (GetOwningArena() == from.GetOwningArena()
307 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
308 && GetOwningArena() != nullptr
309 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
310 ) {
311 InternalSwap(&from);
312 } else {
313 CopyFrom(from);
314 }
315 return *this;
316 }
317
unknown_fields()318 inline const std::string& unknown_fields() const {
319 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
320 }
mutable_unknown_fields()321 inline std::string* mutable_unknown_fields() {
322 return _internal_metadata_.mutable_unknown_fields<std::string>();
323 }
324
default_instance()325 static const ChromeMetadataPacket& default_instance() {
326 return *internal_default_instance();
327 }
internal_default_instance()328 static inline const ChromeMetadataPacket* internal_default_instance() {
329 return reinterpret_cast<const ChromeMetadataPacket*>(
330 &_ChromeMetadataPacket_default_instance_);
331 }
332 static constexpr int kIndexInFileMessages =
333 1;
334
swap(ChromeMetadataPacket & a,ChromeMetadataPacket & b)335 friend void swap(ChromeMetadataPacket& a, ChromeMetadataPacket& b) {
336 a.Swap(&b);
337 }
Swap(ChromeMetadataPacket * other)338 inline void Swap(ChromeMetadataPacket* other) {
339 if (other == this) return;
340 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
341 if (GetOwningArena() != nullptr &&
342 GetOwningArena() == other->GetOwningArena()) {
343 #else // PROTOBUF_FORCE_COPY_IN_SWAP
344 if (GetOwningArena() == other->GetOwningArena()) {
345 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
346 InternalSwap(other);
347 } else {
348 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
349 }
350 }
351 void UnsafeArenaSwap(ChromeMetadataPacket* other) {
352 if (other == this) return;
353 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
354 InternalSwap(other);
355 }
356
357 // implements Message ----------------------------------------------
358
359 ChromeMetadataPacket* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
360 return CreateMaybeMessage<ChromeMetadataPacket>(arena);
361 }
362 ChromeMetadataPacket* New() const {
363 return New(nullptr);
364 }
365 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
366 void CopyFrom(const ChromeMetadataPacket& from);
367 void MergeFrom(const ChromeMetadataPacket& from);
368 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
369 bool IsInitialized() const final;
370
371 size_t ByteSizeLong() const final;
372 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
373 ::uint8_t* _InternalSerialize(
374 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
375 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
376
377 private:
378 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
379 void SharedDtor();
380 void SetCachedSize(int size) const;
381 void InternalSwap(ChromeMetadataPacket* other);
382
383 private:
384 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
385 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
386 return "perfetto.protos.ChromeMetadataPacket";
387 }
388 protected:
389 explicit ChromeMetadataPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
390 bool is_message_owned = false);
391 public:
392
393 std::string GetTypeName() const final;
394
395 // nested types ----------------------------------------------------
396
397 typedef ChromeMetadataPacket_FinchHash FinchHash;
398
399 // accessors -------------------------------------------------------
400
401 enum : int {
402 kFieldTrialHashesFieldNumber = 4,
403 kEnabledCategoriesFieldNumber = 3,
404 kBackgroundTracingMetadataFieldNumber = 1,
405 kChromeVersionCodeFieldNumber = 2,
406 };
407 // repeated .perfetto.protos.ChromeMetadataPacket.FinchHash field_trial_hashes = 4;
408 int field_trial_hashes_size() const;
409 private:
410 int _internal_field_trial_hashes_size() const;
411 public:
412 void clear_field_trial_hashes();
413 ::perfetto::protos::ChromeMetadataPacket_FinchHash* mutable_field_trial_hashes(int index);
414 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadataPacket_FinchHash >*
415 mutable_field_trial_hashes();
416 private:
417 const ::perfetto::protos::ChromeMetadataPacket_FinchHash& _internal_field_trial_hashes(int index) const;
418 ::perfetto::protos::ChromeMetadataPacket_FinchHash* _internal_add_field_trial_hashes();
419 public:
420 const ::perfetto::protos::ChromeMetadataPacket_FinchHash& field_trial_hashes(int index) const;
421 ::perfetto::protos::ChromeMetadataPacket_FinchHash* add_field_trial_hashes();
422 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadataPacket_FinchHash >&
423 field_trial_hashes() const;
424
425 // optional string enabled_categories = 3;
426 bool has_enabled_categories() const;
427 private:
428 bool _internal_has_enabled_categories() const;
429 public:
430 void clear_enabled_categories();
431 const std::string& enabled_categories() const;
432 template <typename ArgT0 = const std::string&, typename... ArgT>
433 void set_enabled_categories(ArgT0&& arg0, ArgT... args);
434 std::string* mutable_enabled_categories();
435 PROTOBUF_NODISCARD std::string* release_enabled_categories();
436 void set_allocated_enabled_categories(std::string* enabled_categories);
437 private:
438 const std::string& _internal_enabled_categories() const;
439 inline PROTOBUF_ALWAYS_INLINE void _internal_set_enabled_categories(const std::string& value);
440 std::string* _internal_mutable_enabled_categories();
441 public:
442
443 // optional .perfetto.protos.BackgroundTracingMetadata background_tracing_metadata = 1;
444 bool has_background_tracing_metadata() const;
445 private:
446 bool _internal_has_background_tracing_metadata() const;
447 public:
448 void clear_background_tracing_metadata();
449 const ::perfetto::protos::BackgroundTracingMetadata& background_tracing_metadata() const;
450 PROTOBUF_NODISCARD ::perfetto::protos::BackgroundTracingMetadata* release_background_tracing_metadata();
451 ::perfetto::protos::BackgroundTracingMetadata* mutable_background_tracing_metadata();
452 void set_allocated_background_tracing_metadata(::perfetto::protos::BackgroundTracingMetadata* background_tracing_metadata);
453 private:
454 const ::perfetto::protos::BackgroundTracingMetadata& _internal_background_tracing_metadata() const;
455 ::perfetto::protos::BackgroundTracingMetadata* _internal_mutable_background_tracing_metadata();
456 public:
457 void unsafe_arena_set_allocated_background_tracing_metadata(
458 ::perfetto::protos::BackgroundTracingMetadata* background_tracing_metadata);
459 ::perfetto::protos::BackgroundTracingMetadata* unsafe_arena_release_background_tracing_metadata();
460
461 // optional int32 chrome_version_code = 2;
462 bool has_chrome_version_code() const;
463 private:
464 bool _internal_has_chrome_version_code() const;
465 public:
466 void clear_chrome_version_code();
467 ::int32_t chrome_version_code() const;
468 void set_chrome_version_code(::int32_t value);
469 private:
470 ::int32_t _internal_chrome_version_code() const;
471 void _internal_set_chrome_version_code(::int32_t value);
472 public:
473
474 // @@protoc_insertion_point(class_scope:perfetto.protos.ChromeMetadataPacket)
475 private:
476 class _Internal;
477
478 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
479 typedef void InternalArenaConstructable_;
480 typedef void DestructorSkippable_;
481 struct Impl_ {
482 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
483 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
484 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadataPacket_FinchHash > field_trial_hashes_;
485 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr enabled_categories_;
486 ::perfetto::protos::BackgroundTracingMetadata* background_tracing_metadata_;
487 ::int32_t chrome_version_code_;
488 };
489 union { Impl_ _impl_; };
490 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto;
491 };
492 // -------------------------------------------------------------------
493
494 class BackgroundTracingMetadata_TriggerRule_HistogramRule final :
495 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule) */ {
496 public:
BackgroundTracingMetadata_TriggerRule_HistogramRule()497 inline BackgroundTracingMetadata_TriggerRule_HistogramRule() : BackgroundTracingMetadata_TriggerRule_HistogramRule(nullptr) {}
498 ~BackgroundTracingMetadata_TriggerRule_HistogramRule() override;
499 explicit PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule_HistogramRule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
500
501 BackgroundTracingMetadata_TriggerRule_HistogramRule(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from);
BackgroundTracingMetadata_TriggerRule_HistogramRule(BackgroundTracingMetadata_TriggerRule_HistogramRule && from)502 BackgroundTracingMetadata_TriggerRule_HistogramRule(BackgroundTracingMetadata_TriggerRule_HistogramRule&& from) noexcept
503 : BackgroundTracingMetadata_TriggerRule_HistogramRule() {
504 *this = ::std::move(from);
505 }
506
507 inline BackgroundTracingMetadata_TriggerRule_HistogramRule& operator=(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from) {
508 if (this == &from) return *this;
509 CopyFrom(from);
510 return *this;
511 }
512 inline BackgroundTracingMetadata_TriggerRule_HistogramRule& operator=(BackgroundTracingMetadata_TriggerRule_HistogramRule&& from) noexcept {
513 if (this == &from) return *this;
514 if (GetOwningArena() == from.GetOwningArena()
515 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
516 && GetOwningArena() != nullptr
517 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
518 ) {
519 InternalSwap(&from);
520 } else {
521 CopyFrom(from);
522 }
523 return *this;
524 }
525
unknown_fields()526 inline const std::string& unknown_fields() const {
527 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
528 }
mutable_unknown_fields()529 inline std::string* mutable_unknown_fields() {
530 return _internal_metadata_.mutable_unknown_fields<std::string>();
531 }
532
default_instance()533 static const BackgroundTracingMetadata_TriggerRule_HistogramRule& default_instance() {
534 return *internal_default_instance();
535 }
internal_default_instance()536 static inline const BackgroundTracingMetadata_TriggerRule_HistogramRule* internal_default_instance() {
537 return reinterpret_cast<const BackgroundTracingMetadata_TriggerRule_HistogramRule*>(
538 &_BackgroundTracingMetadata_TriggerRule_HistogramRule_default_instance_);
539 }
540 static constexpr int kIndexInFileMessages =
541 2;
542
swap(BackgroundTracingMetadata_TriggerRule_HistogramRule & a,BackgroundTracingMetadata_TriggerRule_HistogramRule & b)543 friend void swap(BackgroundTracingMetadata_TriggerRule_HistogramRule& a, BackgroundTracingMetadata_TriggerRule_HistogramRule& b) {
544 a.Swap(&b);
545 }
Swap(BackgroundTracingMetadata_TriggerRule_HistogramRule * other)546 inline void Swap(BackgroundTracingMetadata_TriggerRule_HistogramRule* other) {
547 if (other == this) return;
548 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
549 if (GetOwningArena() != nullptr &&
550 GetOwningArena() == other->GetOwningArena()) {
551 #else // PROTOBUF_FORCE_COPY_IN_SWAP
552 if (GetOwningArena() == other->GetOwningArena()) {
553 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
554 InternalSwap(other);
555 } else {
556 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
557 }
558 }
559 void UnsafeArenaSwap(BackgroundTracingMetadata_TriggerRule_HistogramRule* other) {
560 if (other == this) return;
561 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
562 InternalSwap(other);
563 }
564
565 // implements Message ----------------------------------------------
566
567 BackgroundTracingMetadata_TriggerRule_HistogramRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
568 return CreateMaybeMessage<BackgroundTracingMetadata_TriggerRule_HistogramRule>(arena);
569 }
570 BackgroundTracingMetadata_TriggerRule_HistogramRule* New() const {
571 return New(nullptr);
572 }
573 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
574 void CopyFrom(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from);
575 void MergeFrom(const BackgroundTracingMetadata_TriggerRule_HistogramRule& from);
576 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
577 bool IsInitialized() const final;
578
579 size_t ByteSizeLong() const final;
580 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
581 ::uint8_t* _InternalSerialize(
582 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
583 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
584
585 private:
586 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
587 void SharedDtor();
588 void SetCachedSize(int size) const;
589 void InternalSwap(BackgroundTracingMetadata_TriggerRule_HistogramRule* other);
590
591 private:
592 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
593 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
594 return "perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule";
595 }
596 protected:
597 explicit BackgroundTracingMetadata_TriggerRule_HistogramRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
598 bool is_message_owned = false);
599 public:
600
601 std::string GetTypeName() const final;
602
603 // nested types ----------------------------------------------------
604
605 // accessors -------------------------------------------------------
606
607 enum : int {
608 kHistogramNameHashFieldNumber = 1,
609 kHistogramMinTriggerFieldNumber = 2,
610 kHistogramMaxTriggerFieldNumber = 3,
611 };
612 // optional fixed64 histogram_name_hash = 1;
613 bool has_histogram_name_hash() const;
614 private:
615 bool _internal_has_histogram_name_hash() const;
616 public:
617 void clear_histogram_name_hash();
618 ::uint64_t histogram_name_hash() const;
619 void set_histogram_name_hash(::uint64_t value);
620 private:
621 ::uint64_t _internal_histogram_name_hash() const;
622 void _internal_set_histogram_name_hash(::uint64_t value);
623 public:
624
625 // optional int64 histogram_min_trigger = 2;
626 bool has_histogram_min_trigger() const;
627 private:
628 bool _internal_has_histogram_min_trigger() const;
629 public:
630 void clear_histogram_min_trigger();
631 ::int64_t histogram_min_trigger() const;
632 void set_histogram_min_trigger(::int64_t value);
633 private:
634 ::int64_t _internal_histogram_min_trigger() const;
635 void _internal_set_histogram_min_trigger(::int64_t value);
636 public:
637
638 // optional int64 histogram_max_trigger = 3;
639 bool has_histogram_max_trigger() const;
640 private:
641 bool _internal_has_histogram_max_trigger() const;
642 public:
643 void clear_histogram_max_trigger();
644 ::int64_t histogram_max_trigger() const;
645 void set_histogram_max_trigger(::int64_t value);
646 private:
647 ::int64_t _internal_histogram_max_trigger() const;
648 void _internal_set_histogram_max_trigger(::int64_t value);
649 public:
650
651 // @@protoc_insertion_point(class_scope:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule)
652 private:
653 class _Internal;
654
655 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
656 typedef void InternalArenaConstructable_;
657 typedef void DestructorSkippable_;
658 struct Impl_ {
659 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
660 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
661 ::uint64_t histogram_name_hash_;
662 ::int64_t histogram_min_trigger_;
663 ::int64_t histogram_max_trigger_;
664 };
665 union { Impl_ _impl_; };
666 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto;
667 };
668 // -------------------------------------------------------------------
669
670 class BackgroundTracingMetadata_TriggerRule_NamedRule final :
671 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule) */ {
672 public:
BackgroundTracingMetadata_TriggerRule_NamedRule()673 inline BackgroundTracingMetadata_TriggerRule_NamedRule() : BackgroundTracingMetadata_TriggerRule_NamedRule(nullptr) {}
674 ~BackgroundTracingMetadata_TriggerRule_NamedRule() override;
675 explicit PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule_NamedRule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
676
677 BackgroundTracingMetadata_TriggerRule_NamedRule(const BackgroundTracingMetadata_TriggerRule_NamedRule& from);
BackgroundTracingMetadata_TriggerRule_NamedRule(BackgroundTracingMetadata_TriggerRule_NamedRule && from)678 BackgroundTracingMetadata_TriggerRule_NamedRule(BackgroundTracingMetadata_TriggerRule_NamedRule&& from) noexcept
679 : BackgroundTracingMetadata_TriggerRule_NamedRule() {
680 *this = ::std::move(from);
681 }
682
683 inline BackgroundTracingMetadata_TriggerRule_NamedRule& operator=(const BackgroundTracingMetadata_TriggerRule_NamedRule& from) {
684 if (this == &from) return *this;
685 CopyFrom(from);
686 return *this;
687 }
688 inline BackgroundTracingMetadata_TriggerRule_NamedRule& operator=(BackgroundTracingMetadata_TriggerRule_NamedRule&& from) noexcept {
689 if (this == &from) return *this;
690 if (GetOwningArena() == from.GetOwningArena()
691 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
692 && GetOwningArena() != nullptr
693 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
694 ) {
695 InternalSwap(&from);
696 } else {
697 CopyFrom(from);
698 }
699 return *this;
700 }
701
unknown_fields()702 inline const std::string& unknown_fields() const {
703 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
704 }
mutable_unknown_fields()705 inline std::string* mutable_unknown_fields() {
706 return _internal_metadata_.mutable_unknown_fields<std::string>();
707 }
708
default_instance()709 static const BackgroundTracingMetadata_TriggerRule_NamedRule& default_instance() {
710 return *internal_default_instance();
711 }
internal_default_instance()712 static inline const BackgroundTracingMetadata_TriggerRule_NamedRule* internal_default_instance() {
713 return reinterpret_cast<const BackgroundTracingMetadata_TriggerRule_NamedRule*>(
714 &_BackgroundTracingMetadata_TriggerRule_NamedRule_default_instance_);
715 }
716 static constexpr int kIndexInFileMessages =
717 3;
718
swap(BackgroundTracingMetadata_TriggerRule_NamedRule & a,BackgroundTracingMetadata_TriggerRule_NamedRule & b)719 friend void swap(BackgroundTracingMetadata_TriggerRule_NamedRule& a, BackgroundTracingMetadata_TriggerRule_NamedRule& b) {
720 a.Swap(&b);
721 }
Swap(BackgroundTracingMetadata_TriggerRule_NamedRule * other)722 inline void Swap(BackgroundTracingMetadata_TriggerRule_NamedRule* other) {
723 if (other == this) return;
724 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
725 if (GetOwningArena() != nullptr &&
726 GetOwningArena() == other->GetOwningArena()) {
727 #else // PROTOBUF_FORCE_COPY_IN_SWAP
728 if (GetOwningArena() == other->GetOwningArena()) {
729 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
730 InternalSwap(other);
731 } else {
732 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
733 }
734 }
735 void UnsafeArenaSwap(BackgroundTracingMetadata_TriggerRule_NamedRule* other) {
736 if (other == this) return;
737 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
738 InternalSwap(other);
739 }
740
741 // implements Message ----------------------------------------------
742
743 BackgroundTracingMetadata_TriggerRule_NamedRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
744 return CreateMaybeMessage<BackgroundTracingMetadata_TriggerRule_NamedRule>(arena);
745 }
746 BackgroundTracingMetadata_TriggerRule_NamedRule* New() const {
747 return New(nullptr);
748 }
749 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
750 void CopyFrom(const BackgroundTracingMetadata_TriggerRule_NamedRule& from);
751 void MergeFrom(const BackgroundTracingMetadata_TriggerRule_NamedRule& from);
752 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
753 bool IsInitialized() const final;
754
755 size_t ByteSizeLong() const final;
756 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
757 ::uint8_t* _InternalSerialize(
758 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
759 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
760
761 private:
762 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
763 void SharedDtor();
764 void SetCachedSize(int size) const;
765 void InternalSwap(BackgroundTracingMetadata_TriggerRule_NamedRule* other);
766
767 private:
768 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
769 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
770 return "perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule";
771 }
772 protected:
773 explicit BackgroundTracingMetadata_TriggerRule_NamedRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
774 bool is_message_owned = false);
775 public:
776
777 std::string GetTypeName() const final;
778
779 // nested types ----------------------------------------------------
780
781 typedef BackgroundTracingMetadata_TriggerRule_NamedRule_EventType EventType;
782 static constexpr EventType UNSPECIFIED =
783 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_UNSPECIFIED;
784 static constexpr EventType SESSION_RESTORE =
785 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_SESSION_RESTORE;
786 static constexpr EventType NAVIGATION =
787 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_NAVIGATION;
788 static constexpr EventType STARTUP =
789 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_STARTUP;
790 static constexpr EventType REACHED_CODE =
791 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_REACHED_CODE;
792 static constexpr EventType CONTENT_TRIGGER =
793 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_CONTENT_TRIGGER;
794 static constexpr EventType TEST_RULE =
795 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_TEST_RULE;
796 static inline bool EventType_IsValid(int value) {
797 return BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_IsValid(value);
798 }
799 static constexpr EventType EventType_MIN =
800 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_MIN;
801 static constexpr EventType EventType_MAX =
802 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_MAX;
803 static constexpr int EventType_ARRAYSIZE =
804 BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_EventType_ARRAYSIZE;
805 template<typename T>
806 static inline const std::string& EventType_Name(T enum_t_value) {
807 static_assert(::std::is_same<T, EventType>::value ||
808 ::std::is_integral<T>::value,
809 "Incorrect type passed to function EventType_Name.");
810 return BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Name(enum_t_value);
811 }
812 static inline bool EventType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
813 EventType* value) {
814 return BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_Parse(name, value);
815 }
816
817 // accessors -------------------------------------------------------
818
819 enum : int {
820 kContentTriggerNameHashFieldNumber = 2,
821 kEventTypeFieldNumber = 1,
822 };
823 // optional fixed64 content_trigger_name_hash = 2;
824 bool has_content_trigger_name_hash() const;
825 private:
826 bool _internal_has_content_trigger_name_hash() const;
827 public:
828 void clear_content_trigger_name_hash();
829 ::uint64_t content_trigger_name_hash() const;
830 void set_content_trigger_name_hash(::uint64_t value);
831 private:
832 ::uint64_t _internal_content_trigger_name_hash() const;
833 void _internal_set_content_trigger_name_hash(::uint64_t value);
834 public:
835
836 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.EventType event_type = 1;
837 bool has_event_type() const;
838 private:
839 bool _internal_has_event_type() const;
840 public:
841 void clear_event_type();
842 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType event_type() const;
843 void set_event_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value);
844 private:
845 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType _internal_event_type() const;
846 void _internal_set_event_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value);
847 public:
848
849 // @@protoc_insertion_point(class_scope:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule)
850 private:
851 class _Internal;
852
853 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
854 typedef void InternalArenaConstructable_;
855 typedef void DestructorSkippable_;
856 struct Impl_ {
857 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
858 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
859 ::uint64_t content_trigger_name_hash_;
860 int event_type_;
861 };
862 union { Impl_ _impl_; };
863 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto;
864 };
865 // -------------------------------------------------------------------
866
867 class BackgroundTracingMetadata_TriggerRule final :
868 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BackgroundTracingMetadata.TriggerRule) */ {
869 public:
BackgroundTracingMetadata_TriggerRule()870 inline BackgroundTracingMetadata_TriggerRule() : BackgroundTracingMetadata_TriggerRule(nullptr) {}
871 ~BackgroundTracingMetadata_TriggerRule() override;
872 explicit PROTOBUF_CONSTEXPR BackgroundTracingMetadata_TriggerRule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
873
874 BackgroundTracingMetadata_TriggerRule(const BackgroundTracingMetadata_TriggerRule& from);
BackgroundTracingMetadata_TriggerRule(BackgroundTracingMetadata_TriggerRule && from)875 BackgroundTracingMetadata_TriggerRule(BackgroundTracingMetadata_TriggerRule&& from) noexcept
876 : BackgroundTracingMetadata_TriggerRule() {
877 *this = ::std::move(from);
878 }
879
880 inline BackgroundTracingMetadata_TriggerRule& operator=(const BackgroundTracingMetadata_TriggerRule& from) {
881 if (this == &from) return *this;
882 CopyFrom(from);
883 return *this;
884 }
885 inline BackgroundTracingMetadata_TriggerRule& operator=(BackgroundTracingMetadata_TriggerRule&& from) noexcept {
886 if (this == &from) return *this;
887 if (GetOwningArena() == from.GetOwningArena()
888 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
889 && GetOwningArena() != nullptr
890 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
891 ) {
892 InternalSwap(&from);
893 } else {
894 CopyFrom(from);
895 }
896 return *this;
897 }
898
unknown_fields()899 inline const std::string& unknown_fields() const {
900 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
901 }
mutable_unknown_fields()902 inline std::string* mutable_unknown_fields() {
903 return _internal_metadata_.mutable_unknown_fields<std::string>();
904 }
905
default_instance()906 static const BackgroundTracingMetadata_TriggerRule& default_instance() {
907 return *internal_default_instance();
908 }
internal_default_instance()909 static inline const BackgroundTracingMetadata_TriggerRule* internal_default_instance() {
910 return reinterpret_cast<const BackgroundTracingMetadata_TriggerRule*>(
911 &_BackgroundTracingMetadata_TriggerRule_default_instance_);
912 }
913 static constexpr int kIndexInFileMessages =
914 4;
915
swap(BackgroundTracingMetadata_TriggerRule & a,BackgroundTracingMetadata_TriggerRule & b)916 friend void swap(BackgroundTracingMetadata_TriggerRule& a, BackgroundTracingMetadata_TriggerRule& b) {
917 a.Swap(&b);
918 }
Swap(BackgroundTracingMetadata_TriggerRule * other)919 inline void Swap(BackgroundTracingMetadata_TriggerRule* other) {
920 if (other == this) return;
921 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
922 if (GetOwningArena() != nullptr &&
923 GetOwningArena() == other->GetOwningArena()) {
924 #else // PROTOBUF_FORCE_COPY_IN_SWAP
925 if (GetOwningArena() == other->GetOwningArena()) {
926 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
927 InternalSwap(other);
928 } else {
929 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
930 }
931 }
932 void UnsafeArenaSwap(BackgroundTracingMetadata_TriggerRule* other) {
933 if (other == this) return;
934 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
935 InternalSwap(other);
936 }
937
938 // implements Message ----------------------------------------------
939
940 BackgroundTracingMetadata_TriggerRule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
941 return CreateMaybeMessage<BackgroundTracingMetadata_TriggerRule>(arena);
942 }
943 BackgroundTracingMetadata_TriggerRule* New() const {
944 return New(nullptr);
945 }
946 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
947 void CopyFrom(const BackgroundTracingMetadata_TriggerRule& from);
948 void MergeFrom(const BackgroundTracingMetadata_TriggerRule& from);
949 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
950 bool IsInitialized() const final;
951
952 size_t ByteSizeLong() const final;
953 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
954 ::uint8_t* _InternalSerialize(
955 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
956 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
957
958 private:
959 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
960 void SharedDtor();
961 void SetCachedSize(int size) const;
962 void InternalSwap(BackgroundTracingMetadata_TriggerRule* other);
963
964 private:
965 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
966 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
967 return "perfetto.protos.BackgroundTracingMetadata.TriggerRule";
968 }
969 protected:
970 explicit BackgroundTracingMetadata_TriggerRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
971 bool is_message_owned = false);
972 public:
973
974 std::string GetTypeName() const final;
975
976 // nested types ----------------------------------------------------
977
978 typedef BackgroundTracingMetadata_TriggerRule_HistogramRule HistogramRule;
979 typedef BackgroundTracingMetadata_TriggerRule_NamedRule NamedRule;
980
981 typedef BackgroundTracingMetadata_TriggerRule_TriggerType TriggerType;
982 static constexpr TriggerType TRIGGER_UNSPECIFIED =
983 BackgroundTracingMetadata_TriggerRule_TriggerType_TRIGGER_UNSPECIFIED;
984 static constexpr TriggerType MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE =
985 BackgroundTracingMetadata_TriggerRule_TriggerType_MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
986 static constexpr TriggerType MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED =
987 BackgroundTracingMetadata_TriggerRule_TriggerType_MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
988 static inline bool TriggerType_IsValid(int value) {
989 return BackgroundTracingMetadata_TriggerRule_TriggerType_IsValid(value);
990 }
991 static constexpr TriggerType TriggerType_MIN =
992 BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_MIN;
993 static constexpr TriggerType TriggerType_MAX =
994 BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_MAX;
995 static constexpr int TriggerType_ARRAYSIZE =
996 BackgroundTracingMetadata_TriggerRule_TriggerType_TriggerType_ARRAYSIZE;
997 template<typename T>
998 static inline const std::string& TriggerType_Name(T enum_t_value) {
999 static_assert(::std::is_same<T, TriggerType>::value ||
1000 ::std::is_integral<T>::value,
1001 "Incorrect type passed to function TriggerType_Name.");
1002 return BackgroundTracingMetadata_TriggerRule_TriggerType_Name(enum_t_value);
1003 }
1004 static inline bool TriggerType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1005 TriggerType* value) {
1006 return BackgroundTracingMetadata_TriggerRule_TriggerType_Parse(name, value);
1007 }
1008
1009 // accessors -------------------------------------------------------
1010
1011 enum : int {
1012 kHistogramRuleFieldNumber = 2,
1013 kNamedRuleFieldNumber = 3,
1014 kTriggerTypeFieldNumber = 1,
1015 kNameHashFieldNumber = 4,
1016 };
1017 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule histogram_rule = 2;
1018 bool has_histogram_rule() const;
1019 private:
1020 bool _internal_has_histogram_rule() const;
1021 public:
1022 void clear_histogram_rule();
1023 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule& histogram_rule() const;
1024 PROTOBUF_NODISCARD ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* release_histogram_rule();
1025 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* mutable_histogram_rule();
1026 void set_allocated_histogram_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* histogram_rule);
1027 private:
1028 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule& _internal_histogram_rule() const;
1029 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* _internal_mutable_histogram_rule();
1030 public:
1031 void unsafe_arena_set_allocated_histogram_rule(
1032 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* histogram_rule);
1033 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* unsafe_arena_release_histogram_rule();
1034
1035 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule named_rule = 3;
1036 bool has_named_rule() const;
1037 private:
1038 bool _internal_has_named_rule() const;
1039 public:
1040 void clear_named_rule();
1041 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule& named_rule() const;
1042 PROTOBUF_NODISCARD ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* release_named_rule();
1043 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* mutable_named_rule();
1044 void set_allocated_named_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* named_rule);
1045 private:
1046 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule& _internal_named_rule() const;
1047 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* _internal_mutable_named_rule();
1048 public:
1049 void unsafe_arena_set_allocated_named_rule(
1050 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* named_rule);
1051 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* unsafe_arena_release_named_rule();
1052
1053 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.TriggerType trigger_type = 1;
1054 bool has_trigger_type() const;
1055 private:
1056 bool _internal_has_trigger_type() const;
1057 public:
1058 void clear_trigger_type();
1059 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType trigger_type() const;
1060 void set_trigger_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType value);
1061 private:
1062 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType _internal_trigger_type() const;
1063 void _internal_set_trigger_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType value);
1064 public:
1065
1066 // optional fixed32 name_hash = 4;
1067 bool has_name_hash() const;
1068 private:
1069 bool _internal_has_name_hash() const;
1070 public:
1071 void clear_name_hash();
1072 ::uint32_t name_hash() const;
1073 void set_name_hash(::uint32_t value);
1074 private:
1075 ::uint32_t _internal_name_hash() const;
1076 void _internal_set_name_hash(::uint32_t value);
1077 public:
1078
1079 // @@protoc_insertion_point(class_scope:perfetto.protos.BackgroundTracingMetadata.TriggerRule)
1080 private:
1081 class _Internal;
1082
1083 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1084 typedef void InternalArenaConstructable_;
1085 typedef void DestructorSkippable_;
1086 struct Impl_ {
1087 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1088 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1089 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* histogram_rule_;
1090 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* named_rule_;
1091 int trigger_type_;
1092 ::uint32_t name_hash_;
1093 };
1094 union { Impl_ _impl_; };
1095 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto;
1096 };
1097 // -------------------------------------------------------------------
1098
1099 class BackgroundTracingMetadata final :
1100 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.BackgroundTracingMetadata) */ {
1101 public:
BackgroundTracingMetadata()1102 inline BackgroundTracingMetadata() : BackgroundTracingMetadata(nullptr) {}
1103 ~BackgroundTracingMetadata() override;
1104 explicit PROTOBUF_CONSTEXPR BackgroundTracingMetadata(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1105
1106 BackgroundTracingMetadata(const BackgroundTracingMetadata& from);
BackgroundTracingMetadata(BackgroundTracingMetadata && from)1107 BackgroundTracingMetadata(BackgroundTracingMetadata&& from) noexcept
1108 : BackgroundTracingMetadata() {
1109 *this = ::std::move(from);
1110 }
1111
1112 inline BackgroundTracingMetadata& operator=(const BackgroundTracingMetadata& from) {
1113 if (this == &from) return *this;
1114 CopyFrom(from);
1115 return *this;
1116 }
1117 inline BackgroundTracingMetadata& operator=(BackgroundTracingMetadata&& from) noexcept {
1118 if (this == &from) return *this;
1119 if (GetOwningArena() == from.GetOwningArena()
1120 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1121 && GetOwningArena() != nullptr
1122 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1123 ) {
1124 InternalSwap(&from);
1125 } else {
1126 CopyFrom(from);
1127 }
1128 return *this;
1129 }
1130
unknown_fields()1131 inline const std::string& unknown_fields() const {
1132 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1133 }
mutable_unknown_fields()1134 inline std::string* mutable_unknown_fields() {
1135 return _internal_metadata_.mutable_unknown_fields<std::string>();
1136 }
1137
default_instance()1138 static const BackgroundTracingMetadata& default_instance() {
1139 return *internal_default_instance();
1140 }
internal_default_instance()1141 static inline const BackgroundTracingMetadata* internal_default_instance() {
1142 return reinterpret_cast<const BackgroundTracingMetadata*>(
1143 &_BackgroundTracingMetadata_default_instance_);
1144 }
1145 static constexpr int kIndexInFileMessages =
1146 5;
1147
swap(BackgroundTracingMetadata & a,BackgroundTracingMetadata & b)1148 friend void swap(BackgroundTracingMetadata& a, BackgroundTracingMetadata& b) {
1149 a.Swap(&b);
1150 }
Swap(BackgroundTracingMetadata * other)1151 inline void Swap(BackgroundTracingMetadata* other) {
1152 if (other == this) return;
1153 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1154 if (GetOwningArena() != nullptr &&
1155 GetOwningArena() == other->GetOwningArena()) {
1156 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1157 if (GetOwningArena() == other->GetOwningArena()) {
1158 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1159 InternalSwap(other);
1160 } else {
1161 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1162 }
1163 }
1164 void UnsafeArenaSwap(BackgroundTracingMetadata* other) {
1165 if (other == this) return;
1166 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1167 InternalSwap(other);
1168 }
1169
1170 // implements Message ----------------------------------------------
1171
1172 BackgroundTracingMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1173 return CreateMaybeMessage<BackgroundTracingMetadata>(arena);
1174 }
1175 BackgroundTracingMetadata* New() const {
1176 return New(nullptr);
1177 }
1178 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1179 void CopyFrom(const BackgroundTracingMetadata& from);
1180 void MergeFrom(const BackgroundTracingMetadata& from);
1181 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1182 bool IsInitialized() const final;
1183
1184 size_t ByteSizeLong() const final;
1185 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1186 ::uint8_t* _InternalSerialize(
1187 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1188 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1189
1190 private:
1191 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1192 void SharedDtor();
1193 void SetCachedSize(int size) const;
1194 void InternalSwap(BackgroundTracingMetadata* other);
1195
1196 private:
1197 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1198 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1199 return "perfetto.protos.BackgroundTracingMetadata";
1200 }
1201 protected:
1202 explicit BackgroundTracingMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1203 bool is_message_owned = false);
1204 public:
1205
1206 std::string GetTypeName() const final;
1207
1208 // nested types ----------------------------------------------------
1209
1210 typedef BackgroundTracingMetadata_TriggerRule TriggerRule;
1211
1212 // accessors -------------------------------------------------------
1213
1214 enum : int {
1215 kActiveRulesFieldNumber = 2,
1216 kTriggeredRuleFieldNumber = 1,
1217 kScenarioNameHashFieldNumber = 3,
1218 };
1219 // repeated .perfetto.protos.BackgroundTracingMetadata.TriggerRule active_rules = 2;
1220 int active_rules_size() const;
1221 private:
1222 int _internal_active_rules_size() const;
1223 public:
1224 void clear_active_rules();
1225 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* mutable_active_rules(int index);
1226 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule >*
1227 mutable_active_rules();
1228 private:
1229 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& _internal_active_rules(int index) const;
1230 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* _internal_add_active_rules();
1231 public:
1232 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& active_rules(int index) const;
1233 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* add_active_rules();
1234 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule >&
1235 active_rules() const;
1236
1237 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule triggered_rule = 1;
1238 bool has_triggered_rule() const;
1239 private:
1240 bool _internal_has_triggered_rule() const;
1241 public:
1242 void clear_triggered_rule();
1243 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& triggered_rule() const;
1244 PROTOBUF_NODISCARD ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* release_triggered_rule();
1245 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* mutable_triggered_rule();
1246 void set_allocated_triggered_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule* triggered_rule);
1247 private:
1248 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& _internal_triggered_rule() const;
1249 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* _internal_mutable_triggered_rule();
1250 public:
1251 void unsafe_arena_set_allocated_triggered_rule(
1252 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* triggered_rule);
1253 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* unsafe_arena_release_triggered_rule();
1254
1255 // optional fixed32 scenario_name_hash = 3;
1256 bool has_scenario_name_hash() const;
1257 private:
1258 bool _internal_has_scenario_name_hash() const;
1259 public:
1260 void clear_scenario_name_hash();
1261 ::uint32_t scenario_name_hash() const;
1262 void set_scenario_name_hash(::uint32_t value);
1263 private:
1264 ::uint32_t _internal_scenario_name_hash() const;
1265 void _internal_set_scenario_name_hash(::uint32_t value);
1266 public:
1267
1268 // @@protoc_insertion_point(class_scope:perfetto.protos.BackgroundTracingMetadata)
1269 private:
1270 class _Internal;
1271
1272 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1273 typedef void InternalArenaConstructable_;
1274 typedef void DestructorSkippable_;
1275 struct Impl_ {
1276 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1277 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1278 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule > active_rules_;
1279 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* triggered_rule_;
1280 ::uint32_t scenario_name_hash_;
1281 };
1282 union { Impl_ _impl_; };
1283 friend struct ::TableStruct_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto;
1284 };
1285 // ===================================================================
1286
1287
1288 // ===================================================================
1289
1290 #ifdef __GNUC__
1291 #pragma GCC diagnostic push
1292 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1293 #endif // __GNUC__
1294 // ChromeMetadataPacket_FinchHash
1295
1296 // optional uint32 name = 1;
_internal_has_name()1297 inline bool ChromeMetadataPacket_FinchHash::_internal_has_name() const {
1298 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1299 return value;
1300 }
has_name()1301 inline bool ChromeMetadataPacket_FinchHash::has_name() const {
1302 return _internal_has_name();
1303 }
clear_name()1304 inline void ChromeMetadataPacket_FinchHash::clear_name() {
1305 _impl_.name_ = 0u;
1306 _impl_._has_bits_[0] &= ~0x00000001u;
1307 }
_internal_name()1308 inline ::uint32_t ChromeMetadataPacket_FinchHash::_internal_name() const {
1309 return _impl_.name_;
1310 }
name()1311 inline ::uint32_t ChromeMetadataPacket_FinchHash::name() const {
1312 // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadataPacket.FinchHash.name)
1313 return _internal_name();
1314 }
_internal_set_name(::uint32_t value)1315 inline void ChromeMetadataPacket_FinchHash::_internal_set_name(::uint32_t value) {
1316 _impl_._has_bits_[0] |= 0x00000001u;
1317 _impl_.name_ = value;
1318 }
set_name(::uint32_t value)1319 inline void ChromeMetadataPacket_FinchHash::set_name(::uint32_t value) {
1320 _internal_set_name(value);
1321 // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadataPacket.FinchHash.name)
1322 }
1323
1324 // optional uint32 group = 2;
_internal_has_group()1325 inline bool ChromeMetadataPacket_FinchHash::_internal_has_group() const {
1326 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1327 return value;
1328 }
has_group()1329 inline bool ChromeMetadataPacket_FinchHash::has_group() const {
1330 return _internal_has_group();
1331 }
clear_group()1332 inline void ChromeMetadataPacket_FinchHash::clear_group() {
1333 _impl_.group_ = 0u;
1334 _impl_._has_bits_[0] &= ~0x00000002u;
1335 }
_internal_group()1336 inline ::uint32_t ChromeMetadataPacket_FinchHash::_internal_group() const {
1337 return _impl_.group_;
1338 }
group()1339 inline ::uint32_t ChromeMetadataPacket_FinchHash::group() const {
1340 // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadataPacket.FinchHash.group)
1341 return _internal_group();
1342 }
_internal_set_group(::uint32_t value)1343 inline void ChromeMetadataPacket_FinchHash::_internal_set_group(::uint32_t value) {
1344 _impl_._has_bits_[0] |= 0x00000002u;
1345 _impl_.group_ = value;
1346 }
set_group(::uint32_t value)1347 inline void ChromeMetadataPacket_FinchHash::set_group(::uint32_t value) {
1348 _internal_set_group(value);
1349 // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadataPacket.FinchHash.group)
1350 }
1351
1352 // -------------------------------------------------------------------
1353
1354 // ChromeMetadataPacket
1355
1356 // optional .perfetto.protos.BackgroundTracingMetadata background_tracing_metadata = 1;
_internal_has_background_tracing_metadata()1357 inline bool ChromeMetadataPacket::_internal_has_background_tracing_metadata() const {
1358 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1359 PROTOBUF_ASSUME(!value || _impl_.background_tracing_metadata_ != nullptr);
1360 return value;
1361 }
has_background_tracing_metadata()1362 inline bool ChromeMetadataPacket::has_background_tracing_metadata() const {
1363 return _internal_has_background_tracing_metadata();
1364 }
clear_background_tracing_metadata()1365 inline void ChromeMetadataPacket::clear_background_tracing_metadata() {
1366 if (_impl_.background_tracing_metadata_ != nullptr) _impl_.background_tracing_metadata_->Clear();
1367 _impl_._has_bits_[0] &= ~0x00000002u;
1368 }
_internal_background_tracing_metadata()1369 inline const ::perfetto::protos::BackgroundTracingMetadata& ChromeMetadataPacket::_internal_background_tracing_metadata() const {
1370 const ::perfetto::protos::BackgroundTracingMetadata* p = _impl_.background_tracing_metadata_;
1371 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::BackgroundTracingMetadata&>(
1372 ::perfetto::protos::_BackgroundTracingMetadata_default_instance_);
1373 }
background_tracing_metadata()1374 inline const ::perfetto::protos::BackgroundTracingMetadata& ChromeMetadataPacket::background_tracing_metadata() const {
1375 // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadataPacket.background_tracing_metadata)
1376 return _internal_background_tracing_metadata();
1377 }
unsafe_arena_set_allocated_background_tracing_metadata(::perfetto::protos::BackgroundTracingMetadata * background_tracing_metadata)1378 inline void ChromeMetadataPacket::unsafe_arena_set_allocated_background_tracing_metadata(
1379 ::perfetto::protos::BackgroundTracingMetadata* background_tracing_metadata) {
1380 if (GetArenaForAllocation() == nullptr) {
1381 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.background_tracing_metadata_);
1382 }
1383 _impl_.background_tracing_metadata_ = background_tracing_metadata;
1384 if (background_tracing_metadata) {
1385 _impl_._has_bits_[0] |= 0x00000002u;
1386 } else {
1387 _impl_._has_bits_[0] &= ~0x00000002u;
1388 }
1389 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.ChromeMetadataPacket.background_tracing_metadata)
1390 }
release_background_tracing_metadata()1391 inline ::perfetto::protos::BackgroundTracingMetadata* ChromeMetadataPacket::release_background_tracing_metadata() {
1392 _impl_._has_bits_[0] &= ~0x00000002u;
1393 ::perfetto::protos::BackgroundTracingMetadata* temp = _impl_.background_tracing_metadata_;
1394 _impl_.background_tracing_metadata_ = nullptr;
1395 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1396 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1397 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1398 if (GetArenaForAllocation() == nullptr) { delete old; }
1399 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1400 if (GetArenaForAllocation() != nullptr) {
1401 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1402 }
1403 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1404 return temp;
1405 }
unsafe_arena_release_background_tracing_metadata()1406 inline ::perfetto::protos::BackgroundTracingMetadata* ChromeMetadataPacket::unsafe_arena_release_background_tracing_metadata() {
1407 // @@protoc_insertion_point(field_release:perfetto.protos.ChromeMetadataPacket.background_tracing_metadata)
1408 _impl_._has_bits_[0] &= ~0x00000002u;
1409 ::perfetto::protos::BackgroundTracingMetadata* temp = _impl_.background_tracing_metadata_;
1410 _impl_.background_tracing_metadata_ = nullptr;
1411 return temp;
1412 }
_internal_mutable_background_tracing_metadata()1413 inline ::perfetto::protos::BackgroundTracingMetadata* ChromeMetadataPacket::_internal_mutable_background_tracing_metadata() {
1414 _impl_._has_bits_[0] |= 0x00000002u;
1415 if (_impl_.background_tracing_metadata_ == nullptr) {
1416 auto* p = CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata>(GetArenaForAllocation());
1417 _impl_.background_tracing_metadata_ = p;
1418 }
1419 return _impl_.background_tracing_metadata_;
1420 }
mutable_background_tracing_metadata()1421 inline ::perfetto::protos::BackgroundTracingMetadata* ChromeMetadataPacket::mutable_background_tracing_metadata() {
1422 ::perfetto::protos::BackgroundTracingMetadata* _msg = _internal_mutable_background_tracing_metadata();
1423 // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeMetadataPacket.background_tracing_metadata)
1424 return _msg;
1425 }
set_allocated_background_tracing_metadata(::perfetto::protos::BackgroundTracingMetadata * background_tracing_metadata)1426 inline void ChromeMetadataPacket::set_allocated_background_tracing_metadata(::perfetto::protos::BackgroundTracingMetadata* background_tracing_metadata) {
1427 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1428 if (message_arena == nullptr) {
1429 delete _impl_.background_tracing_metadata_;
1430 }
1431 if (background_tracing_metadata) {
1432 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1433 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(background_tracing_metadata);
1434 if (message_arena != submessage_arena) {
1435 background_tracing_metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1436 message_arena, background_tracing_metadata, submessage_arena);
1437 }
1438 _impl_._has_bits_[0] |= 0x00000002u;
1439 } else {
1440 _impl_._has_bits_[0] &= ~0x00000002u;
1441 }
1442 _impl_.background_tracing_metadata_ = background_tracing_metadata;
1443 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeMetadataPacket.background_tracing_metadata)
1444 }
1445
1446 // optional int32 chrome_version_code = 2;
_internal_has_chrome_version_code()1447 inline bool ChromeMetadataPacket::_internal_has_chrome_version_code() const {
1448 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1449 return value;
1450 }
has_chrome_version_code()1451 inline bool ChromeMetadataPacket::has_chrome_version_code() const {
1452 return _internal_has_chrome_version_code();
1453 }
clear_chrome_version_code()1454 inline void ChromeMetadataPacket::clear_chrome_version_code() {
1455 _impl_.chrome_version_code_ = 0;
1456 _impl_._has_bits_[0] &= ~0x00000004u;
1457 }
_internal_chrome_version_code()1458 inline ::int32_t ChromeMetadataPacket::_internal_chrome_version_code() const {
1459 return _impl_.chrome_version_code_;
1460 }
chrome_version_code()1461 inline ::int32_t ChromeMetadataPacket::chrome_version_code() const {
1462 // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadataPacket.chrome_version_code)
1463 return _internal_chrome_version_code();
1464 }
_internal_set_chrome_version_code(::int32_t value)1465 inline void ChromeMetadataPacket::_internal_set_chrome_version_code(::int32_t value) {
1466 _impl_._has_bits_[0] |= 0x00000004u;
1467 _impl_.chrome_version_code_ = value;
1468 }
set_chrome_version_code(::int32_t value)1469 inline void ChromeMetadataPacket::set_chrome_version_code(::int32_t value) {
1470 _internal_set_chrome_version_code(value);
1471 // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadataPacket.chrome_version_code)
1472 }
1473
1474 // optional string enabled_categories = 3;
_internal_has_enabled_categories()1475 inline bool ChromeMetadataPacket::_internal_has_enabled_categories() const {
1476 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1477 return value;
1478 }
has_enabled_categories()1479 inline bool ChromeMetadataPacket::has_enabled_categories() const {
1480 return _internal_has_enabled_categories();
1481 }
clear_enabled_categories()1482 inline void ChromeMetadataPacket::clear_enabled_categories() {
1483 _impl_.enabled_categories_.ClearToEmpty();
1484 _impl_._has_bits_[0] &= ~0x00000001u;
1485 }
enabled_categories()1486 inline const std::string& ChromeMetadataPacket::enabled_categories() const {
1487 // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadataPacket.enabled_categories)
1488 return _internal_enabled_categories();
1489 }
1490 template <typename ArgT0, typename... ArgT>
1491 inline PROTOBUF_ALWAYS_INLINE
set_enabled_categories(ArgT0 && arg0,ArgT...args)1492 void ChromeMetadataPacket::set_enabled_categories(ArgT0&& arg0, ArgT... args) {
1493 _impl_._has_bits_[0] |= 0x00000001u;
1494 _impl_.enabled_categories_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1495 // @@protoc_insertion_point(field_set:perfetto.protos.ChromeMetadataPacket.enabled_categories)
1496 }
mutable_enabled_categories()1497 inline std::string* ChromeMetadataPacket::mutable_enabled_categories() {
1498 std::string* _s = _internal_mutable_enabled_categories();
1499 // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeMetadataPacket.enabled_categories)
1500 return _s;
1501 }
_internal_enabled_categories()1502 inline const std::string& ChromeMetadataPacket::_internal_enabled_categories() const {
1503 return _impl_.enabled_categories_.Get();
1504 }
_internal_set_enabled_categories(const std::string & value)1505 inline void ChromeMetadataPacket::_internal_set_enabled_categories(const std::string& value) {
1506 _impl_._has_bits_[0] |= 0x00000001u;
1507 _impl_.enabled_categories_.Set(value, GetArenaForAllocation());
1508 }
_internal_mutable_enabled_categories()1509 inline std::string* ChromeMetadataPacket::_internal_mutable_enabled_categories() {
1510 _impl_._has_bits_[0] |= 0x00000001u;
1511 return _impl_.enabled_categories_.Mutable(GetArenaForAllocation());
1512 }
release_enabled_categories()1513 inline std::string* ChromeMetadataPacket::release_enabled_categories() {
1514 // @@protoc_insertion_point(field_release:perfetto.protos.ChromeMetadataPacket.enabled_categories)
1515 if (!_internal_has_enabled_categories()) {
1516 return nullptr;
1517 }
1518 _impl_._has_bits_[0] &= ~0x00000001u;
1519 auto* p = _impl_.enabled_categories_.Release();
1520 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1521 if (_impl_.enabled_categories_.IsDefault()) {
1522 _impl_.enabled_categories_.Set("", GetArenaForAllocation());
1523 }
1524 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1525 return p;
1526 }
set_allocated_enabled_categories(std::string * enabled_categories)1527 inline void ChromeMetadataPacket::set_allocated_enabled_categories(std::string* enabled_categories) {
1528 if (enabled_categories != nullptr) {
1529 _impl_._has_bits_[0] |= 0x00000001u;
1530 } else {
1531 _impl_._has_bits_[0] &= ~0x00000001u;
1532 }
1533 _impl_.enabled_categories_.SetAllocated(enabled_categories, GetArenaForAllocation());
1534 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1535 if (_impl_.enabled_categories_.IsDefault()) {
1536 _impl_.enabled_categories_.Set("", GetArenaForAllocation());
1537 }
1538 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1539 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.ChromeMetadataPacket.enabled_categories)
1540 }
1541
1542 // repeated .perfetto.protos.ChromeMetadataPacket.FinchHash field_trial_hashes = 4;
_internal_field_trial_hashes_size()1543 inline int ChromeMetadataPacket::_internal_field_trial_hashes_size() const {
1544 return _impl_.field_trial_hashes_.size();
1545 }
field_trial_hashes_size()1546 inline int ChromeMetadataPacket::field_trial_hashes_size() const {
1547 return _internal_field_trial_hashes_size();
1548 }
clear_field_trial_hashes()1549 inline void ChromeMetadataPacket::clear_field_trial_hashes() {
1550 _impl_.field_trial_hashes_.Clear();
1551 }
mutable_field_trial_hashes(int index)1552 inline ::perfetto::protos::ChromeMetadataPacket_FinchHash* ChromeMetadataPacket::mutable_field_trial_hashes(int index) {
1553 // @@protoc_insertion_point(field_mutable:perfetto.protos.ChromeMetadataPacket.field_trial_hashes)
1554 return _impl_.field_trial_hashes_.Mutable(index);
1555 }
1556 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadataPacket_FinchHash >*
mutable_field_trial_hashes()1557 ChromeMetadataPacket::mutable_field_trial_hashes() {
1558 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.ChromeMetadataPacket.field_trial_hashes)
1559 return &_impl_.field_trial_hashes_;
1560 }
_internal_field_trial_hashes(int index)1561 inline const ::perfetto::protos::ChromeMetadataPacket_FinchHash& ChromeMetadataPacket::_internal_field_trial_hashes(int index) const {
1562 return _impl_.field_trial_hashes_.Get(index);
1563 }
field_trial_hashes(int index)1564 inline const ::perfetto::protos::ChromeMetadataPacket_FinchHash& ChromeMetadataPacket::field_trial_hashes(int index) const {
1565 // @@protoc_insertion_point(field_get:perfetto.protos.ChromeMetadataPacket.field_trial_hashes)
1566 return _internal_field_trial_hashes(index);
1567 }
_internal_add_field_trial_hashes()1568 inline ::perfetto::protos::ChromeMetadataPacket_FinchHash* ChromeMetadataPacket::_internal_add_field_trial_hashes() {
1569 return _impl_.field_trial_hashes_.Add();
1570 }
add_field_trial_hashes()1571 inline ::perfetto::protos::ChromeMetadataPacket_FinchHash* ChromeMetadataPacket::add_field_trial_hashes() {
1572 ::perfetto::protos::ChromeMetadataPacket_FinchHash* _add = _internal_add_field_trial_hashes();
1573 // @@protoc_insertion_point(field_add:perfetto.protos.ChromeMetadataPacket.field_trial_hashes)
1574 return _add;
1575 }
1576 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::ChromeMetadataPacket_FinchHash >&
field_trial_hashes()1577 ChromeMetadataPacket::field_trial_hashes() const {
1578 // @@protoc_insertion_point(field_list:perfetto.protos.ChromeMetadataPacket.field_trial_hashes)
1579 return _impl_.field_trial_hashes_;
1580 }
1581
1582 // -------------------------------------------------------------------
1583
1584 // BackgroundTracingMetadata_TriggerRule_HistogramRule
1585
1586 // optional fixed64 histogram_name_hash = 1;
_internal_has_histogram_name_hash()1587 inline bool BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_has_histogram_name_hash() const {
1588 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1589 return value;
1590 }
has_histogram_name_hash()1591 inline bool BackgroundTracingMetadata_TriggerRule_HistogramRule::has_histogram_name_hash() const {
1592 return _internal_has_histogram_name_hash();
1593 }
clear_histogram_name_hash()1594 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::clear_histogram_name_hash() {
1595 _impl_.histogram_name_hash_ = ::uint64_t{0u};
1596 _impl_._has_bits_[0] &= ~0x00000001u;
1597 }
_internal_histogram_name_hash()1598 inline ::uint64_t BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_histogram_name_hash() const {
1599 return _impl_.histogram_name_hash_;
1600 }
histogram_name_hash()1601 inline ::uint64_t BackgroundTracingMetadata_TriggerRule_HistogramRule::histogram_name_hash() const {
1602 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule.histogram_name_hash)
1603 return _internal_histogram_name_hash();
1604 }
_internal_set_histogram_name_hash(::uint64_t value)1605 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_set_histogram_name_hash(::uint64_t value) {
1606 _impl_._has_bits_[0] |= 0x00000001u;
1607 _impl_.histogram_name_hash_ = value;
1608 }
set_histogram_name_hash(::uint64_t value)1609 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::set_histogram_name_hash(::uint64_t value) {
1610 _internal_set_histogram_name_hash(value);
1611 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule.histogram_name_hash)
1612 }
1613
1614 // optional int64 histogram_min_trigger = 2;
_internal_has_histogram_min_trigger()1615 inline bool BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_has_histogram_min_trigger() const {
1616 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1617 return value;
1618 }
has_histogram_min_trigger()1619 inline bool BackgroundTracingMetadata_TriggerRule_HistogramRule::has_histogram_min_trigger() const {
1620 return _internal_has_histogram_min_trigger();
1621 }
clear_histogram_min_trigger()1622 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::clear_histogram_min_trigger() {
1623 _impl_.histogram_min_trigger_ = ::int64_t{0};
1624 _impl_._has_bits_[0] &= ~0x00000002u;
1625 }
_internal_histogram_min_trigger()1626 inline ::int64_t BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_histogram_min_trigger() const {
1627 return _impl_.histogram_min_trigger_;
1628 }
histogram_min_trigger()1629 inline ::int64_t BackgroundTracingMetadata_TriggerRule_HistogramRule::histogram_min_trigger() const {
1630 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule.histogram_min_trigger)
1631 return _internal_histogram_min_trigger();
1632 }
_internal_set_histogram_min_trigger(::int64_t value)1633 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_set_histogram_min_trigger(::int64_t value) {
1634 _impl_._has_bits_[0] |= 0x00000002u;
1635 _impl_.histogram_min_trigger_ = value;
1636 }
set_histogram_min_trigger(::int64_t value)1637 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::set_histogram_min_trigger(::int64_t value) {
1638 _internal_set_histogram_min_trigger(value);
1639 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule.histogram_min_trigger)
1640 }
1641
1642 // optional int64 histogram_max_trigger = 3;
_internal_has_histogram_max_trigger()1643 inline bool BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_has_histogram_max_trigger() const {
1644 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1645 return value;
1646 }
has_histogram_max_trigger()1647 inline bool BackgroundTracingMetadata_TriggerRule_HistogramRule::has_histogram_max_trigger() const {
1648 return _internal_has_histogram_max_trigger();
1649 }
clear_histogram_max_trigger()1650 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::clear_histogram_max_trigger() {
1651 _impl_.histogram_max_trigger_ = ::int64_t{0};
1652 _impl_._has_bits_[0] &= ~0x00000004u;
1653 }
_internal_histogram_max_trigger()1654 inline ::int64_t BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_histogram_max_trigger() const {
1655 return _impl_.histogram_max_trigger_;
1656 }
histogram_max_trigger()1657 inline ::int64_t BackgroundTracingMetadata_TriggerRule_HistogramRule::histogram_max_trigger() const {
1658 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule.histogram_max_trigger)
1659 return _internal_histogram_max_trigger();
1660 }
_internal_set_histogram_max_trigger(::int64_t value)1661 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::_internal_set_histogram_max_trigger(::int64_t value) {
1662 _impl_._has_bits_[0] |= 0x00000004u;
1663 _impl_.histogram_max_trigger_ = value;
1664 }
set_histogram_max_trigger(::int64_t value)1665 inline void BackgroundTracingMetadata_TriggerRule_HistogramRule::set_histogram_max_trigger(::int64_t value) {
1666 _internal_set_histogram_max_trigger(value);
1667 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule.histogram_max_trigger)
1668 }
1669
1670 // -------------------------------------------------------------------
1671
1672 // BackgroundTracingMetadata_TriggerRule_NamedRule
1673
1674 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.EventType event_type = 1;
_internal_has_event_type()1675 inline bool BackgroundTracingMetadata_TriggerRule_NamedRule::_internal_has_event_type() const {
1676 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1677 return value;
1678 }
has_event_type()1679 inline bool BackgroundTracingMetadata_TriggerRule_NamedRule::has_event_type() const {
1680 return _internal_has_event_type();
1681 }
clear_event_type()1682 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::clear_event_type() {
1683 _impl_.event_type_ = 0;
1684 _impl_._has_bits_[0] &= ~0x00000002u;
1685 }
_internal_event_type()1686 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::_internal_event_type() const {
1687 return static_cast< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType >(_impl_.event_type_);
1688 }
event_type()1689 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType BackgroundTracingMetadata_TriggerRule_NamedRule::event_type() const {
1690 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.event_type)
1691 return _internal_event_type();
1692 }
_internal_set_event_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value)1693 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::_internal_set_event_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
1694 assert(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType_IsValid(value));
1695 _impl_._has_bits_[0] |= 0x00000002u;
1696 _impl_.event_type_ = value;
1697 }
set_event_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value)1698 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::set_event_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType value) {
1699 _internal_set_event_type(value);
1700 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.event_type)
1701 }
1702
1703 // optional fixed64 content_trigger_name_hash = 2;
_internal_has_content_trigger_name_hash()1704 inline bool BackgroundTracingMetadata_TriggerRule_NamedRule::_internal_has_content_trigger_name_hash() const {
1705 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1706 return value;
1707 }
has_content_trigger_name_hash()1708 inline bool BackgroundTracingMetadata_TriggerRule_NamedRule::has_content_trigger_name_hash() const {
1709 return _internal_has_content_trigger_name_hash();
1710 }
clear_content_trigger_name_hash()1711 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::clear_content_trigger_name_hash() {
1712 _impl_.content_trigger_name_hash_ = ::uint64_t{0u};
1713 _impl_._has_bits_[0] &= ~0x00000001u;
1714 }
_internal_content_trigger_name_hash()1715 inline ::uint64_t BackgroundTracingMetadata_TriggerRule_NamedRule::_internal_content_trigger_name_hash() const {
1716 return _impl_.content_trigger_name_hash_;
1717 }
content_trigger_name_hash()1718 inline ::uint64_t BackgroundTracingMetadata_TriggerRule_NamedRule::content_trigger_name_hash() const {
1719 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.content_trigger_name_hash)
1720 return _internal_content_trigger_name_hash();
1721 }
_internal_set_content_trigger_name_hash(::uint64_t value)1722 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::_internal_set_content_trigger_name_hash(::uint64_t value) {
1723 _impl_._has_bits_[0] |= 0x00000001u;
1724 _impl_.content_trigger_name_hash_ = value;
1725 }
set_content_trigger_name_hash(::uint64_t value)1726 inline void BackgroundTracingMetadata_TriggerRule_NamedRule::set_content_trigger_name_hash(::uint64_t value) {
1727 _internal_set_content_trigger_name_hash(value);
1728 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule.content_trigger_name_hash)
1729 }
1730
1731 // -------------------------------------------------------------------
1732
1733 // BackgroundTracingMetadata_TriggerRule
1734
1735 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.TriggerType trigger_type = 1;
_internal_has_trigger_type()1736 inline bool BackgroundTracingMetadata_TriggerRule::_internal_has_trigger_type() const {
1737 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
1738 return value;
1739 }
has_trigger_type()1740 inline bool BackgroundTracingMetadata_TriggerRule::has_trigger_type() const {
1741 return _internal_has_trigger_type();
1742 }
clear_trigger_type()1743 inline void BackgroundTracingMetadata_TriggerRule::clear_trigger_type() {
1744 _impl_.trigger_type_ = 0;
1745 _impl_._has_bits_[0] &= ~0x00000004u;
1746 }
_internal_trigger_type()1747 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::_internal_trigger_type() const {
1748 return static_cast< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType >(_impl_.trigger_type_);
1749 }
trigger_type()1750 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType BackgroundTracingMetadata_TriggerRule::trigger_type() const {
1751 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.trigger_type)
1752 return _internal_trigger_type();
1753 }
_internal_set_trigger_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType value)1754 inline void BackgroundTracingMetadata_TriggerRule::_internal_set_trigger_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType value) {
1755 assert(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType_IsValid(value));
1756 _impl_._has_bits_[0] |= 0x00000004u;
1757 _impl_.trigger_type_ = value;
1758 }
set_trigger_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType value)1759 inline void BackgroundTracingMetadata_TriggerRule::set_trigger_type(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType value) {
1760 _internal_set_trigger_type(value);
1761 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.trigger_type)
1762 }
1763
1764 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.HistogramRule histogram_rule = 2;
_internal_has_histogram_rule()1765 inline bool BackgroundTracingMetadata_TriggerRule::_internal_has_histogram_rule() const {
1766 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1767 PROTOBUF_ASSUME(!value || _impl_.histogram_rule_ != nullptr);
1768 return value;
1769 }
has_histogram_rule()1770 inline bool BackgroundTracingMetadata_TriggerRule::has_histogram_rule() const {
1771 return _internal_has_histogram_rule();
1772 }
clear_histogram_rule()1773 inline void BackgroundTracingMetadata_TriggerRule::clear_histogram_rule() {
1774 if (_impl_.histogram_rule_ != nullptr) _impl_.histogram_rule_->Clear();
1775 _impl_._has_bits_[0] &= ~0x00000001u;
1776 }
_internal_histogram_rule()1777 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule& BackgroundTracingMetadata_TriggerRule::_internal_histogram_rule() const {
1778 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* p = _impl_.histogram_rule_;
1779 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule&>(
1780 ::perfetto::protos::_BackgroundTracingMetadata_TriggerRule_HistogramRule_default_instance_);
1781 }
histogram_rule()1782 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule& BackgroundTracingMetadata_TriggerRule::histogram_rule() const {
1783 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.histogram_rule)
1784 return _internal_histogram_rule();
1785 }
unsafe_arena_set_allocated_histogram_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule * histogram_rule)1786 inline void BackgroundTracingMetadata_TriggerRule::unsafe_arena_set_allocated_histogram_rule(
1787 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* histogram_rule) {
1788 if (GetArenaForAllocation() == nullptr) {
1789 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.histogram_rule_);
1790 }
1791 _impl_.histogram_rule_ = histogram_rule;
1792 if (histogram_rule) {
1793 _impl_._has_bits_[0] |= 0x00000001u;
1794 } else {
1795 _impl_._has_bits_[0] &= ~0x00000001u;
1796 }
1797 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.BackgroundTracingMetadata.TriggerRule.histogram_rule)
1798 }
release_histogram_rule()1799 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* BackgroundTracingMetadata_TriggerRule::release_histogram_rule() {
1800 _impl_._has_bits_[0] &= ~0x00000001u;
1801 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* temp = _impl_.histogram_rule_;
1802 _impl_.histogram_rule_ = nullptr;
1803 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1804 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1805 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1806 if (GetArenaForAllocation() == nullptr) { delete old; }
1807 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1808 if (GetArenaForAllocation() != nullptr) {
1809 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1810 }
1811 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1812 return temp;
1813 }
unsafe_arena_release_histogram_rule()1814 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* BackgroundTracingMetadata_TriggerRule::unsafe_arena_release_histogram_rule() {
1815 // @@protoc_insertion_point(field_release:perfetto.protos.BackgroundTracingMetadata.TriggerRule.histogram_rule)
1816 _impl_._has_bits_[0] &= ~0x00000001u;
1817 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* temp = _impl_.histogram_rule_;
1818 _impl_.histogram_rule_ = nullptr;
1819 return temp;
1820 }
_internal_mutable_histogram_rule()1821 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* BackgroundTracingMetadata_TriggerRule::_internal_mutable_histogram_rule() {
1822 _impl_._has_bits_[0] |= 0x00000001u;
1823 if (_impl_.histogram_rule_ == nullptr) {
1824 auto* p = CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule>(GetArenaForAllocation());
1825 _impl_.histogram_rule_ = p;
1826 }
1827 return _impl_.histogram_rule_;
1828 }
mutable_histogram_rule()1829 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* BackgroundTracingMetadata_TriggerRule::mutable_histogram_rule() {
1830 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* _msg = _internal_mutable_histogram_rule();
1831 // @@protoc_insertion_point(field_mutable:perfetto.protos.BackgroundTracingMetadata.TriggerRule.histogram_rule)
1832 return _msg;
1833 }
set_allocated_histogram_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule * histogram_rule)1834 inline void BackgroundTracingMetadata_TriggerRule::set_allocated_histogram_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_HistogramRule* histogram_rule) {
1835 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1836 if (message_arena == nullptr) {
1837 delete _impl_.histogram_rule_;
1838 }
1839 if (histogram_rule) {
1840 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1841 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(histogram_rule);
1842 if (message_arena != submessage_arena) {
1843 histogram_rule = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1844 message_arena, histogram_rule, submessage_arena);
1845 }
1846 _impl_._has_bits_[0] |= 0x00000001u;
1847 } else {
1848 _impl_._has_bits_[0] &= ~0x00000001u;
1849 }
1850 _impl_.histogram_rule_ = histogram_rule;
1851 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.BackgroundTracingMetadata.TriggerRule.histogram_rule)
1852 }
1853
1854 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule.NamedRule named_rule = 3;
_internal_has_named_rule()1855 inline bool BackgroundTracingMetadata_TriggerRule::_internal_has_named_rule() const {
1856 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1857 PROTOBUF_ASSUME(!value || _impl_.named_rule_ != nullptr);
1858 return value;
1859 }
has_named_rule()1860 inline bool BackgroundTracingMetadata_TriggerRule::has_named_rule() const {
1861 return _internal_has_named_rule();
1862 }
clear_named_rule()1863 inline void BackgroundTracingMetadata_TriggerRule::clear_named_rule() {
1864 if (_impl_.named_rule_ != nullptr) _impl_.named_rule_->Clear();
1865 _impl_._has_bits_[0] &= ~0x00000002u;
1866 }
_internal_named_rule()1867 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule& BackgroundTracingMetadata_TriggerRule::_internal_named_rule() const {
1868 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* p = _impl_.named_rule_;
1869 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule&>(
1870 ::perfetto::protos::_BackgroundTracingMetadata_TriggerRule_NamedRule_default_instance_);
1871 }
named_rule()1872 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule& BackgroundTracingMetadata_TriggerRule::named_rule() const {
1873 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.named_rule)
1874 return _internal_named_rule();
1875 }
unsafe_arena_set_allocated_named_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule * named_rule)1876 inline void BackgroundTracingMetadata_TriggerRule::unsafe_arena_set_allocated_named_rule(
1877 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* named_rule) {
1878 if (GetArenaForAllocation() == nullptr) {
1879 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.named_rule_);
1880 }
1881 _impl_.named_rule_ = named_rule;
1882 if (named_rule) {
1883 _impl_._has_bits_[0] |= 0x00000002u;
1884 } else {
1885 _impl_._has_bits_[0] &= ~0x00000002u;
1886 }
1887 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.BackgroundTracingMetadata.TriggerRule.named_rule)
1888 }
release_named_rule()1889 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* BackgroundTracingMetadata_TriggerRule::release_named_rule() {
1890 _impl_._has_bits_[0] &= ~0x00000002u;
1891 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* temp = _impl_.named_rule_;
1892 _impl_.named_rule_ = nullptr;
1893 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
1894 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
1895 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1896 if (GetArenaForAllocation() == nullptr) { delete old; }
1897 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
1898 if (GetArenaForAllocation() != nullptr) {
1899 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1900 }
1901 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
1902 return temp;
1903 }
unsafe_arena_release_named_rule()1904 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* BackgroundTracingMetadata_TriggerRule::unsafe_arena_release_named_rule() {
1905 // @@protoc_insertion_point(field_release:perfetto.protos.BackgroundTracingMetadata.TriggerRule.named_rule)
1906 _impl_._has_bits_[0] &= ~0x00000002u;
1907 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* temp = _impl_.named_rule_;
1908 _impl_.named_rule_ = nullptr;
1909 return temp;
1910 }
_internal_mutable_named_rule()1911 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* BackgroundTracingMetadata_TriggerRule::_internal_mutable_named_rule() {
1912 _impl_._has_bits_[0] |= 0x00000002u;
1913 if (_impl_.named_rule_ == nullptr) {
1914 auto* p = CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule>(GetArenaForAllocation());
1915 _impl_.named_rule_ = p;
1916 }
1917 return _impl_.named_rule_;
1918 }
mutable_named_rule()1919 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* BackgroundTracingMetadata_TriggerRule::mutable_named_rule() {
1920 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* _msg = _internal_mutable_named_rule();
1921 // @@protoc_insertion_point(field_mutable:perfetto.protos.BackgroundTracingMetadata.TriggerRule.named_rule)
1922 return _msg;
1923 }
set_allocated_named_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule * named_rule)1924 inline void BackgroundTracingMetadata_TriggerRule::set_allocated_named_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule* named_rule) {
1925 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1926 if (message_arena == nullptr) {
1927 delete _impl_.named_rule_;
1928 }
1929 if (named_rule) {
1930 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1931 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(named_rule);
1932 if (message_arena != submessage_arena) {
1933 named_rule = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1934 message_arena, named_rule, submessage_arena);
1935 }
1936 _impl_._has_bits_[0] |= 0x00000002u;
1937 } else {
1938 _impl_._has_bits_[0] &= ~0x00000002u;
1939 }
1940 _impl_.named_rule_ = named_rule;
1941 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.BackgroundTracingMetadata.TriggerRule.named_rule)
1942 }
1943
1944 // optional fixed32 name_hash = 4;
_internal_has_name_hash()1945 inline bool BackgroundTracingMetadata_TriggerRule::_internal_has_name_hash() const {
1946 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
1947 return value;
1948 }
has_name_hash()1949 inline bool BackgroundTracingMetadata_TriggerRule::has_name_hash() const {
1950 return _internal_has_name_hash();
1951 }
clear_name_hash()1952 inline void BackgroundTracingMetadata_TriggerRule::clear_name_hash() {
1953 _impl_.name_hash_ = 0u;
1954 _impl_._has_bits_[0] &= ~0x00000008u;
1955 }
_internal_name_hash()1956 inline ::uint32_t BackgroundTracingMetadata_TriggerRule::_internal_name_hash() const {
1957 return _impl_.name_hash_;
1958 }
name_hash()1959 inline ::uint32_t BackgroundTracingMetadata_TriggerRule::name_hash() const {
1960 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.TriggerRule.name_hash)
1961 return _internal_name_hash();
1962 }
_internal_set_name_hash(::uint32_t value)1963 inline void BackgroundTracingMetadata_TriggerRule::_internal_set_name_hash(::uint32_t value) {
1964 _impl_._has_bits_[0] |= 0x00000008u;
1965 _impl_.name_hash_ = value;
1966 }
set_name_hash(::uint32_t value)1967 inline void BackgroundTracingMetadata_TriggerRule::set_name_hash(::uint32_t value) {
1968 _internal_set_name_hash(value);
1969 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.TriggerRule.name_hash)
1970 }
1971
1972 // -------------------------------------------------------------------
1973
1974 // BackgroundTracingMetadata
1975
1976 // optional .perfetto.protos.BackgroundTracingMetadata.TriggerRule triggered_rule = 1;
_internal_has_triggered_rule()1977 inline bool BackgroundTracingMetadata::_internal_has_triggered_rule() const {
1978 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1979 PROTOBUF_ASSUME(!value || _impl_.triggered_rule_ != nullptr);
1980 return value;
1981 }
has_triggered_rule()1982 inline bool BackgroundTracingMetadata::has_triggered_rule() const {
1983 return _internal_has_triggered_rule();
1984 }
clear_triggered_rule()1985 inline void BackgroundTracingMetadata::clear_triggered_rule() {
1986 if (_impl_.triggered_rule_ != nullptr) _impl_.triggered_rule_->Clear();
1987 _impl_._has_bits_[0] &= ~0x00000001u;
1988 }
_internal_triggered_rule()1989 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& BackgroundTracingMetadata::_internal_triggered_rule() const {
1990 const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* p = _impl_.triggered_rule_;
1991 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule&>(
1992 ::perfetto::protos::_BackgroundTracingMetadata_TriggerRule_default_instance_);
1993 }
triggered_rule()1994 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& BackgroundTracingMetadata::triggered_rule() const {
1995 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.triggered_rule)
1996 return _internal_triggered_rule();
1997 }
unsafe_arena_set_allocated_triggered_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule * triggered_rule)1998 inline void BackgroundTracingMetadata::unsafe_arena_set_allocated_triggered_rule(
1999 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* triggered_rule) {
2000 if (GetArenaForAllocation() == nullptr) {
2001 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.triggered_rule_);
2002 }
2003 _impl_.triggered_rule_ = triggered_rule;
2004 if (triggered_rule) {
2005 _impl_._has_bits_[0] |= 0x00000001u;
2006 } else {
2007 _impl_._has_bits_[0] &= ~0x00000001u;
2008 }
2009 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.BackgroundTracingMetadata.triggered_rule)
2010 }
release_triggered_rule()2011 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::release_triggered_rule() {
2012 _impl_._has_bits_[0] &= ~0x00000001u;
2013 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* temp = _impl_.triggered_rule_;
2014 _impl_.triggered_rule_ = nullptr;
2015 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2016 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2017 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2018 if (GetArenaForAllocation() == nullptr) { delete old; }
2019 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2020 if (GetArenaForAllocation() != nullptr) {
2021 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2022 }
2023 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2024 return temp;
2025 }
unsafe_arena_release_triggered_rule()2026 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::unsafe_arena_release_triggered_rule() {
2027 // @@protoc_insertion_point(field_release:perfetto.protos.BackgroundTracingMetadata.triggered_rule)
2028 _impl_._has_bits_[0] &= ~0x00000001u;
2029 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* temp = _impl_.triggered_rule_;
2030 _impl_.triggered_rule_ = nullptr;
2031 return temp;
2032 }
_internal_mutable_triggered_rule()2033 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::_internal_mutable_triggered_rule() {
2034 _impl_._has_bits_[0] |= 0x00000001u;
2035 if (_impl_.triggered_rule_ == nullptr) {
2036 auto* p = CreateMaybeMessage<::perfetto::protos::BackgroundTracingMetadata_TriggerRule>(GetArenaForAllocation());
2037 _impl_.triggered_rule_ = p;
2038 }
2039 return _impl_.triggered_rule_;
2040 }
mutable_triggered_rule()2041 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::mutable_triggered_rule() {
2042 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* _msg = _internal_mutable_triggered_rule();
2043 // @@protoc_insertion_point(field_mutable:perfetto.protos.BackgroundTracingMetadata.triggered_rule)
2044 return _msg;
2045 }
set_allocated_triggered_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule * triggered_rule)2046 inline void BackgroundTracingMetadata::set_allocated_triggered_rule(::perfetto::protos::BackgroundTracingMetadata_TriggerRule* triggered_rule) {
2047 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2048 if (message_arena == nullptr) {
2049 delete _impl_.triggered_rule_;
2050 }
2051 if (triggered_rule) {
2052 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2053 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(triggered_rule);
2054 if (message_arena != submessage_arena) {
2055 triggered_rule = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2056 message_arena, triggered_rule, submessage_arena);
2057 }
2058 _impl_._has_bits_[0] |= 0x00000001u;
2059 } else {
2060 _impl_._has_bits_[0] &= ~0x00000001u;
2061 }
2062 _impl_.triggered_rule_ = triggered_rule;
2063 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.BackgroundTracingMetadata.triggered_rule)
2064 }
2065
2066 // repeated .perfetto.protos.BackgroundTracingMetadata.TriggerRule active_rules = 2;
_internal_active_rules_size()2067 inline int BackgroundTracingMetadata::_internal_active_rules_size() const {
2068 return _impl_.active_rules_.size();
2069 }
active_rules_size()2070 inline int BackgroundTracingMetadata::active_rules_size() const {
2071 return _internal_active_rules_size();
2072 }
clear_active_rules()2073 inline void BackgroundTracingMetadata::clear_active_rules() {
2074 _impl_.active_rules_.Clear();
2075 }
mutable_active_rules(int index)2076 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::mutable_active_rules(int index) {
2077 // @@protoc_insertion_point(field_mutable:perfetto.protos.BackgroundTracingMetadata.active_rules)
2078 return _impl_.active_rules_.Mutable(index);
2079 }
2080 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule >*
mutable_active_rules()2081 BackgroundTracingMetadata::mutable_active_rules() {
2082 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.BackgroundTracingMetadata.active_rules)
2083 return &_impl_.active_rules_;
2084 }
_internal_active_rules(int index)2085 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& BackgroundTracingMetadata::_internal_active_rules(int index) const {
2086 return _impl_.active_rules_.Get(index);
2087 }
active_rules(int index)2088 inline const ::perfetto::protos::BackgroundTracingMetadata_TriggerRule& BackgroundTracingMetadata::active_rules(int index) const {
2089 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.active_rules)
2090 return _internal_active_rules(index);
2091 }
_internal_add_active_rules()2092 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::_internal_add_active_rules() {
2093 return _impl_.active_rules_.Add();
2094 }
add_active_rules()2095 inline ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* BackgroundTracingMetadata::add_active_rules() {
2096 ::perfetto::protos::BackgroundTracingMetadata_TriggerRule* _add = _internal_add_active_rules();
2097 // @@protoc_insertion_point(field_add:perfetto.protos.BackgroundTracingMetadata.active_rules)
2098 return _add;
2099 }
2100 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule >&
active_rules()2101 BackgroundTracingMetadata::active_rules() const {
2102 // @@protoc_insertion_point(field_list:perfetto.protos.BackgroundTracingMetadata.active_rules)
2103 return _impl_.active_rules_;
2104 }
2105
2106 // optional fixed32 scenario_name_hash = 3;
_internal_has_scenario_name_hash()2107 inline bool BackgroundTracingMetadata::_internal_has_scenario_name_hash() const {
2108 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2109 return value;
2110 }
has_scenario_name_hash()2111 inline bool BackgroundTracingMetadata::has_scenario_name_hash() const {
2112 return _internal_has_scenario_name_hash();
2113 }
clear_scenario_name_hash()2114 inline void BackgroundTracingMetadata::clear_scenario_name_hash() {
2115 _impl_.scenario_name_hash_ = 0u;
2116 _impl_._has_bits_[0] &= ~0x00000002u;
2117 }
_internal_scenario_name_hash()2118 inline ::uint32_t BackgroundTracingMetadata::_internal_scenario_name_hash() const {
2119 return _impl_.scenario_name_hash_;
2120 }
scenario_name_hash()2121 inline ::uint32_t BackgroundTracingMetadata::scenario_name_hash() const {
2122 // @@protoc_insertion_point(field_get:perfetto.protos.BackgroundTracingMetadata.scenario_name_hash)
2123 return _internal_scenario_name_hash();
2124 }
_internal_set_scenario_name_hash(::uint32_t value)2125 inline void BackgroundTracingMetadata::_internal_set_scenario_name_hash(::uint32_t value) {
2126 _impl_._has_bits_[0] |= 0x00000002u;
2127 _impl_.scenario_name_hash_ = value;
2128 }
set_scenario_name_hash(::uint32_t value)2129 inline void BackgroundTracingMetadata::set_scenario_name_hash(::uint32_t value) {
2130 _internal_set_scenario_name_hash(value);
2131 // @@protoc_insertion_point(field_set:perfetto.protos.BackgroundTracingMetadata.scenario_name_hash)
2132 }
2133
2134 #ifdef __GNUC__
2135 #pragma GCC diagnostic pop
2136 #endif // __GNUC__
2137 // -------------------------------------------------------------------
2138
2139 // -------------------------------------------------------------------
2140
2141 // -------------------------------------------------------------------
2142
2143 // -------------------------------------------------------------------
2144
2145 // -------------------------------------------------------------------
2146
2147
2148 // @@protoc_insertion_point(namespace_scope)
2149
2150 } // namespace protos
2151 } // namespace perfetto
2152
2153 PROTOBUF_NAMESPACE_OPEN
2154
2155 template <> struct is_proto_enum< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_NamedRule_EventType> : ::std::true_type {};
2156 template <> struct is_proto_enum< ::perfetto::protos::BackgroundTracingMetadata_TriggerRule_TriggerType> : ::std::true_type {};
2157
2158 PROTOBUF_NAMESPACE_CLOSE
2159
2160 // @@protoc_insertion_point(global_scope)
2161
2162 #include <google/protobuf/port_undef.inc>
2163 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2ftrace_2fchrome_2fchrome_5fmetadata_2eproto
2164