1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/config/chrome/chrome_config.proto
3 
4 #include "protos/perfetto/config/chrome/chrome_config.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace perfetto {
22 namespace protos {
ChromeConfig(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR ChromeConfig::ChromeConfig(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.trace_config_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.json_agent_label_filter_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.privacy_filtering_enabled_)*/false
30   , /*decltype(_impl_.convert_to_legacy_json_)*/false
31   , /*decltype(_impl_.client_priority_)*/0} {}
32 struct ChromeConfigDefaultTypeInternal {
ChromeConfigDefaultTypeInternalperfetto::protos::ChromeConfigDefaultTypeInternal33   PROTOBUF_CONSTEXPR ChromeConfigDefaultTypeInternal()
34       : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeConfigDefaultTypeInternalperfetto::protos::ChromeConfigDefaultTypeInternal35   ~ChromeConfigDefaultTypeInternal() {}
36   union {  // NOLINT(misc-non-private-member-variables-in-classes)
37     ChromeConfig _instance;
38   };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeConfigDefaultTypeInternal _ChromeConfig_default_instance_;
41 }  // namespace protos
42 }  // namespace perfetto
43 namespace perfetto {
44 namespace protos {
ChromeConfig_ClientPriority_IsValid(int value)45 bool ChromeConfig_ClientPriority_IsValid(int value) {
46   switch (value) {
47     case 0:
48     case 1:
49     case 2:
50       return true;
51     default:
52       return false;
53   }
54 }
55 
56 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeConfig_ClientPriority_strings[3] = {};
57 
58 static const char ChromeConfig_ClientPriority_names[] =
59   "BACKGROUND"
60   "UNKNOWN"
61   "USER_INITIATED";
62 
63 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeConfig_ClientPriority_entries[] = {
64   { {ChromeConfig_ClientPriority_names + 0, 10}, 1 },
65   { {ChromeConfig_ClientPriority_names + 10, 7}, 0 },
66   { {ChromeConfig_ClientPriority_names + 17, 14}, 2 },
67 };
68 
69 static const int ChromeConfig_ClientPriority_entries_by_number[] = {
70   1, // 0 -> UNKNOWN
71   0, // 1 -> BACKGROUND
72   2, // 2 -> USER_INITIATED
73 };
74 
ChromeConfig_ClientPriority_Name(ChromeConfig_ClientPriority value)75 const std::string& ChromeConfig_ClientPriority_Name(
76     ChromeConfig_ClientPriority value) {
77   static const bool dummy =
78       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
79           ChromeConfig_ClientPriority_entries,
80           ChromeConfig_ClientPriority_entries_by_number,
81           3, ChromeConfig_ClientPriority_strings);
82   (void) dummy;
83   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
84       ChromeConfig_ClientPriority_entries,
85       ChromeConfig_ClientPriority_entries_by_number,
86       3, value);
87   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
88                      ChromeConfig_ClientPriority_strings[idx].get();
89 }
ChromeConfig_ClientPriority_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeConfig_ClientPriority * value)90 bool ChromeConfig_ClientPriority_Parse(
91     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeConfig_ClientPriority* value) {
92   int int_value;
93   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
94       ChromeConfig_ClientPriority_entries, 3, name, &int_value);
95   if (success) {
96     *value = static_cast<ChromeConfig_ClientPriority>(int_value);
97   }
98   return success;
99 }
100 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
101 constexpr ChromeConfig_ClientPriority ChromeConfig::UNKNOWN;
102 constexpr ChromeConfig_ClientPriority ChromeConfig::BACKGROUND;
103 constexpr ChromeConfig_ClientPriority ChromeConfig::USER_INITIATED;
104 constexpr ChromeConfig_ClientPriority ChromeConfig::ClientPriority_MIN;
105 constexpr ChromeConfig_ClientPriority ChromeConfig::ClientPriority_MAX;
106 constexpr int ChromeConfig::ClientPriority_ARRAYSIZE;
107 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
108 
109 // ===================================================================
110 
111 class ChromeConfig::_Internal {
112  public:
113   using HasBits = decltype(std::declval<ChromeConfig>()._impl_._has_bits_);
set_has_trace_config(HasBits * has_bits)114   static void set_has_trace_config(HasBits* has_bits) {
115     (*has_bits)[0] |= 1u;
116   }
set_has_privacy_filtering_enabled(HasBits * has_bits)117   static void set_has_privacy_filtering_enabled(HasBits* has_bits) {
118     (*has_bits)[0] |= 4u;
119   }
set_has_convert_to_legacy_json(HasBits * has_bits)120   static void set_has_convert_to_legacy_json(HasBits* has_bits) {
121     (*has_bits)[0] |= 8u;
122   }
set_has_client_priority(HasBits * has_bits)123   static void set_has_client_priority(HasBits* has_bits) {
124     (*has_bits)[0] |= 16u;
125   }
set_has_json_agent_label_filter(HasBits * has_bits)126   static void set_has_json_agent_label_filter(HasBits* has_bits) {
127     (*has_bits)[0] |= 2u;
128   }
129 };
130 
ChromeConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)131 ChromeConfig::ChromeConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
132                          bool is_message_owned)
133   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
134   SharedCtor(arena, is_message_owned);
135   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeConfig)
136 }
ChromeConfig(const ChromeConfig & from)137 ChromeConfig::ChromeConfig(const ChromeConfig& from)
138   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
139   ChromeConfig* const _this = this; (void)_this;
140   new (&_impl_) Impl_{
141       decltype(_impl_._has_bits_){from._impl_._has_bits_}
142     , /*decltype(_impl_._cached_size_)*/{}
143     , decltype(_impl_.trace_config_){}
144     , decltype(_impl_.json_agent_label_filter_){}
145     , decltype(_impl_.privacy_filtering_enabled_){}
146     , decltype(_impl_.convert_to_legacy_json_){}
147     , decltype(_impl_.client_priority_){}};
148 
149   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
150   _impl_.trace_config_.InitDefault();
151   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
152     _impl_.trace_config_.Set("", GetArenaForAllocation());
153   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
154   if (from._internal_has_trace_config()) {
155     _this->_impl_.trace_config_.Set(from._internal_trace_config(),
156       _this->GetArenaForAllocation());
157   }
158   _impl_.json_agent_label_filter_.InitDefault();
159   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
160     _impl_.json_agent_label_filter_.Set("", GetArenaForAllocation());
161   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
162   if (from._internal_has_json_agent_label_filter()) {
163     _this->_impl_.json_agent_label_filter_.Set(from._internal_json_agent_label_filter(),
164       _this->GetArenaForAllocation());
165   }
166   ::memcpy(&_impl_.privacy_filtering_enabled_, &from._impl_.privacy_filtering_enabled_,
167     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.client_priority_) -
168     reinterpret_cast<char*>(&_impl_.privacy_filtering_enabled_)) + sizeof(_impl_.client_priority_));
169   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeConfig)
170 }
171 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)172 inline void ChromeConfig::SharedCtor(
173     ::_pb::Arena* arena, bool is_message_owned) {
174   (void)arena;
175   (void)is_message_owned;
176   new (&_impl_) Impl_{
177       decltype(_impl_._has_bits_){}
178     , /*decltype(_impl_._cached_size_)*/{}
179     , decltype(_impl_.trace_config_){}
180     , decltype(_impl_.json_agent_label_filter_){}
181     , decltype(_impl_.privacy_filtering_enabled_){false}
182     , decltype(_impl_.convert_to_legacy_json_){false}
183     , decltype(_impl_.client_priority_){0}
184   };
185   _impl_.trace_config_.InitDefault();
186   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
187     _impl_.trace_config_.Set("", GetArenaForAllocation());
188   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
189   _impl_.json_agent_label_filter_.InitDefault();
190   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
191     _impl_.json_agent_label_filter_.Set("", GetArenaForAllocation());
192   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
193 }
194 
~ChromeConfig()195 ChromeConfig::~ChromeConfig() {
196   // @@protoc_insertion_point(destructor:perfetto.protos.ChromeConfig)
197   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
198   (void)arena;
199     return;
200   }
201   SharedDtor();
202 }
203 
SharedDtor()204 inline void ChromeConfig::SharedDtor() {
205   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
206   _impl_.trace_config_.Destroy();
207   _impl_.json_agent_label_filter_.Destroy();
208 }
209 
SetCachedSize(int size) const210 void ChromeConfig::SetCachedSize(int size) const {
211   _impl_._cached_size_.Set(size);
212 }
213 
Clear()214 void ChromeConfig::Clear() {
215 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeConfig)
216   ::uint32_t cached_has_bits = 0;
217   // Prevent compiler warnings about cached_has_bits being unused
218   (void) cached_has_bits;
219 
220   cached_has_bits = _impl_._has_bits_[0];
221   if (cached_has_bits & 0x00000003u) {
222     if (cached_has_bits & 0x00000001u) {
223       _impl_.trace_config_.ClearNonDefaultToEmpty();
224     }
225     if (cached_has_bits & 0x00000002u) {
226       _impl_.json_agent_label_filter_.ClearNonDefaultToEmpty();
227     }
228   }
229   if (cached_has_bits & 0x0000001cu) {
230     ::memset(&_impl_.privacy_filtering_enabled_, 0, static_cast<size_t>(
231         reinterpret_cast<char*>(&_impl_.client_priority_) -
232         reinterpret_cast<char*>(&_impl_.privacy_filtering_enabled_)) + sizeof(_impl_.client_priority_));
233   }
234   _impl_._has_bits_.Clear();
235   _internal_metadata_.Clear<std::string>();
236 }
237 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)238 const char* ChromeConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
239 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
240   _Internal::HasBits has_bits{};
241   while (!ctx->Done(&ptr)) {
242     ::uint32_t tag;
243     ptr = ::_pbi::ReadTag(ptr, &tag);
244     switch (tag >> 3) {
245       // optional string trace_config = 1;
246       case 1:
247         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
248           auto str = _internal_mutable_trace_config();
249           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
250           CHK_(ptr);
251         } else {
252           goto handle_unusual;
253         }
254         continue;
255       // optional bool privacy_filtering_enabled = 2;
256       case 2:
257         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
258           _Internal::set_has_privacy_filtering_enabled(&has_bits);
259           _impl_.privacy_filtering_enabled_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
260           CHK_(ptr);
261         } else {
262           goto handle_unusual;
263         }
264         continue;
265       // optional bool convert_to_legacy_json = 3;
266       case 3:
267         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
268           _Internal::set_has_convert_to_legacy_json(&has_bits);
269           _impl_.convert_to_legacy_json_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
270           CHK_(ptr);
271         } else {
272           goto handle_unusual;
273         }
274         continue;
275       // optional .perfetto.protos.ChromeConfig.ClientPriority client_priority = 4;
276       case 4:
277         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
278           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
279           CHK_(ptr);
280           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeConfig_ClientPriority_IsValid(val))) {
281             _internal_set_client_priority(static_cast<::perfetto::protos::ChromeConfig_ClientPriority>(val));
282           } else {
283             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
284           }
285         } else {
286           goto handle_unusual;
287         }
288         continue;
289       // optional string json_agent_label_filter = 5;
290       case 5:
291         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
292           auto str = _internal_mutable_json_agent_label_filter();
293           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
294           CHK_(ptr);
295         } else {
296           goto handle_unusual;
297         }
298         continue;
299       default:
300         goto handle_unusual;
301     }  // switch
302   handle_unusual:
303     if ((tag == 0) || ((tag & 7) == 4)) {
304       CHK_(ptr);
305       ctx->SetLastTag(tag);
306       goto message_done;
307     }
308     ptr = UnknownFieldParse(
309         tag,
310         _internal_metadata_.mutable_unknown_fields<std::string>(),
311         ptr, ctx);
312     CHK_(ptr != nullptr);
313   }  // while
314 message_done:
315   _impl_._has_bits_.Or(has_bits);
316   return ptr;
317 failure:
318   ptr = nullptr;
319   goto message_done;
320 #undef CHK_
321 }
322 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const323 ::uint8_t* ChromeConfig::_InternalSerialize(
324     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
325   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeConfig)
326   ::uint32_t cached_has_bits = 0;
327   (void) cached_has_bits;
328 
329   cached_has_bits = _impl_._has_bits_[0];
330   // optional string trace_config = 1;
331   if (cached_has_bits & 0x00000001u) {
332     target = stream->WriteStringMaybeAliased(
333         1, this->_internal_trace_config(), target);
334   }
335 
336   // optional bool privacy_filtering_enabled = 2;
337   if (cached_has_bits & 0x00000004u) {
338     target = stream->EnsureSpace(target);
339     target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_privacy_filtering_enabled(), target);
340   }
341 
342   // optional bool convert_to_legacy_json = 3;
343   if (cached_has_bits & 0x00000008u) {
344     target = stream->EnsureSpace(target);
345     target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_convert_to_legacy_json(), target);
346   }
347 
348   // optional .perfetto.protos.ChromeConfig.ClientPriority client_priority = 4;
349   if (cached_has_bits & 0x00000010u) {
350     target = stream->EnsureSpace(target);
351     target = ::_pbi::WireFormatLite::WriteEnumToArray(
352       4, this->_internal_client_priority(), target);
353   }
354 
355   // optional string json_agent_label_filter = 5;
356   if (cached_has_bits & 0x00000002u) {
357     target = stream->WriteStringMaybeAliased(
358         5, this->_internal_json_agent_label_filter(), target);
359   }
360 
361   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
362     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
363         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
364   }
365   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeConfig)
366   return target;
367 }
368 
ByteSizeLong() const369 size_t ChromeConfig::ByteSizeLong() const {
370 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeConfig)
371   size_t total_size = 0;
372 
373   ::uint32_t cached_has_bits = 0;
374   // Prevent compiler warnings about cached_has_bits being unused
375   (void) cached_has_bits;
376 
377   cached_has_bits = _impl_._has_bits_[0];
378   if (cached_has_bits & 0x0000001fu) {
379     // optional string trace_config = 1;
380     if (cached_has_bits & 0x00000001u) {
381       total_size += 1 +
382         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
383           this->_internal_trace_config());
384     }
385 
386     // optional string json_agent_label_filter = 5;
387     if (cached_has_bits & 0x00000002u) {
388       total_size += 1 +
389         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
390           this->_internal_json_agent_label_filter());
391     }
392 
393     // optional bool privacy_filtering_enabled = 2;
394     if (cached_has_bits & 0x00000004u) {
395       total_size += 1 + 1;
396     }
397 
398     // optional bool convert_to_legacy_json = 3;
399     if (cached_has_bits & 0x00000008u) {
400       total_size += 1 + 1;
401     }
402 
403     // optional .perfetto.protos.ChromeConfig.ClientPriority client_priority = 4;
404     if (cached_has_bits & 0x00000010u) {
405       total_size += 1 +
406         ::_pbi::WireFormatLite::EnumSize(this->_internal_client_priority());
407     }
408 
409   }
410   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
411     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
412   }
413   int cached_size = ::_pbi::ToCachedSize(total_size);
414   SetCachedSize(cached_size);
415   return total_size;
416 }
417 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)418 void ChromeConfig::CheckTypeAndMergeFrom(
419     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
420   MergeFrom(*::_pbi::DownCast<const ChromeConfig*>(
421       &from));
422 }
423 
MergeFrom(const ChromeConfig & from)424 void ChromeConfig::MergeFrom(const ChromeConfig& from) {
425   ChromeConfig* const _this = this;
426   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeConfig)
427   GOOGLE_DCHECK_NE(&from, _this);
428   ::uint32_t cached_has_bits = 0;
429   (void) cached_has_bits;
430 
431   cached_has_bits = from._impl_._has_bits_[0];
432   if (cached_has_bits & 0x0000001fu) {
433     if (cached_has_bits & 0x00000001u) {
434       _this->_internal_set_trace_config(from._internal_trace_config());
435     }
436     if (cached_has_bits & 0x00000002u) {
437       _this->_internal_set_json_agent_label_filter(from._internal_json_agent_label_filter());
438     }
439     if (cached_has_bits & 0x00000004u) {
440       _this->_impl_.privacy_filtering_enabled_ = from._impl_.privacy_filtering_enabled_;
441     }
442     if (cached_has_bits & 0x00000008u) {
443       _this->_impl_.convert_to_legacy_json_ = from._impl_.convert_to_legacy_json_;
444     }
445     if (cached_has_bits & 0x00000010u) {
446       _this->_impl_.client_priority_ = from._impl_.client_priority_;
447     }
448     _this->_impl_._has_bits_[0] |= cached_has_bits;
449   }
450   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
451 }
452 
CopyFrom(const ChromeConfig & from)453 void ChromeConfig::CopyFrom(const ChromeConfig& from) {
454 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeConfig)
455   if (&from == this) return;
456   Clear();
457   MergeFrom(from);
458 }
459 
IsInitialized() const460 bool ChromeConfig::IsInitialized() const {
461   return true;
462 }
463 
InternalSwap(ChromeConfig * other)464 void ChromeConfig::InternalSwap(ChromeConfig* other) {
465   using std::swap;
466   auto* lhs_arena = GetArenaForAllocation();
467   auto* rhs_arena = other->GetArenaForAllocation();
468   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
469   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
470   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
471       &_impl_.trace_config_, lhs_arena,
472       &other->_impl_.trace_config_, rhs_arena
473   );
474   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
475       &_impl_.json_agent_label_filter_, lhs_arena,
476       &other->_impl_.json_agent_label_filter_, rhs_arena
477   );
478   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
479       PROTOBUF_FIELD_OFFSET(ChromeConfig, _impl_.client_priority_)
480       + sizeof(ChromeConfig::_impl_.client_priority_)  // NOLINT
481       - PROTOBUF_FIELD_OFFSET(ChromeConfig, _impl_.privacy_filtering_enabled_)>(
482           reinterpret_cast<char*>(&_impl_.privacy_filtering_enabled_),
483           reinterpret_cast<char*>(&other->_impl_.privacy_filtering_enabled_));
484 }
485 
GetTypeName() const486 std::string ChromeConfig::GetTypeName() const {
487   return "perfetto.protos.ChromeConfig";
488 }
489 
490 
491 // @@protoc_insertion_point(namespace_scope)
492 }  // namespace protos
493 }  // namespace perfetto
494 PROTOBUF_NAMESPACE_OPEN
495 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeConfig*
CreateMaybeMessage(Arena * arena)496 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeConfig >(Arena* arena) {
497   return Arena::CreateMessageInternal< ::perfetto::protos::ChromeConfig >(arena);
498 }
499 PROTOBUF_NAMESPACE_CLOSE
500 
501 // @@protoc_insertion_point(global_scope)
502 #include <google/protobuf/port_undef.inc>
503