1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/track_event/chrome_frame_reporter.proto
3 
4 #include "protos/perfetto/trace/track_event/chrome_frame_reporter.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 {
ChromeFrameReporter(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR ChromeFrameReporter::ChromeFrameReporter(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.high_latency_contribution_stage_)*/{}
28   , /*decltype(_impl_.state_)*/0
29   , /*decltype(_impl_.reason_)*/0
30   , /*decltype(_impl_.frame_source_)*/::uint64_t{0u}
31   , /*decltype(_impl_.frame_sequence_)*/::uint64_t{0u}
32   , /*decltype(_impl_.scroll_state_)*/0
33   , /*decltype(_impl_.affects_smoothness_)*/false
34   , /*decltype(_impl_.has_main_animation_)*/false
35   , /*decltype(_impl_.has_compositor_animation_)*/false
36   , /*decltype(_impl_.has_smooth_input_main_)*/false
37   , /*decltype(_impl_.layer_tree_host_id_)*/::uint64_t{0u}
38   , /*decltype(_impl_.frame_type_)*/0
39   , /*decltype(_impl_.has_missing_content_)*/false
40   , /*decltype(_impl_.has_high_latency_)*/false
41   , /*decltype(_impl_.checkerboarded_needs_raster_)*/false
42   , /*decltype(_impl_.checkerboarded_needs_record_)*/false} {}
43 struct ChromeFrameReporterDefaultTypeInternal {
ChromeFrameReporterDefaultTypeInternalperfetto::protos::ChromeFrameReporterDefaultTypeInternal44   PROTOBUF_CONSTEXPR ChromeFrameReporterDefaultTypeInternal()
45       : _instance(::_pbi::ConstantInitialized{}) {}
~ChromeFrameReporterDefaultTypeInternalperfetto::protos::ChromeFrameReporterDefaultTypeInternal46   ~ChromeFrameReporterDefaultTypeInternal() {}
47   union {  // NOLINT(misc-non-private-member-variables-in-classes)
48     ChromeFrameReporter _instance;
49   };
50 };
51 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ChromeFrameReporterDefaultTypeInternal _ChromeFrameReporter_default_instance_;
52 }  // namespace protos
53 }  // namespace perfetto
54 namespace perfetto {
55 namespace protos {
ChromeFrameReporter_State_IsValid(int value)56 bool ChromeFrameReporter_State_IsValid(int value) {
57   switch (value) {
58     case 0:
59     case 1:
60     case 2:
61     case 3:
62       return true;
63     default:
64       return false;
65   }
66 }
67 
68 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeFrameReporter_State_strings[4] = {};
69 
70 static const char ChromeFrameReporter_State_names[] =
71   "STATE_DROPPED"
72   "STATE_NO_UPDATE_DESIRED"
73   "STATE_PRESENTED_ALL"
74   "STATE_PRESENTED_PARTIAL";
75 
76 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeFrameReporter_State_entries[] = {
77   { {ChromeFrameReporter_State_names + 0, 13}, 3 },
78   { {ChromeFrameReporter_State_names + 13, 23}, 0 },
79   { {ChromeFrameReporter_State_names + 36, 19}, 1 },
80   { {ChromeFrameReporter_State_names + 55, 23}, 2 },
81 };
82 
83 static const int ChromeFrameReporter_State_entries_by_number[] = {
84   1, // 0 -> STATE_NO_UPDATE_DESIRED
85   2, // 1 -> STATE_PRESENTED_ALL
86   3, // 2 -> STATE_PRESENTED_PARTIAL
87   0, // 3 -> STATE_DROPPED
88 };
89 
ChromeFrameReporter_State_Name(ChromeFrameReporter_State value)90 const std::string& ChromeFrameReporter_State_Name(
91     ChromeFrameReporter_State value) {
92   static const bool dummy =
93       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
94           ChromeFrameReporter_State_entries,
95           ChromeFrameReporter_State_entries_by_number,
96           4, ChromeFrameReporter_State_strings);
97   (void) dummy;
98   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
99       ChromeFrameReporter_State_entries,
100       ChromeFrameReporter_State_entries_by_number,
101       4, value);
102   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
103                      ChromeFrameReporter_State_strings[idx].get();
104 }
ChromeFrameReporter_State_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeFrameReporter_State * value)105 bool ChromeFrameReporter_State_Parse(
106     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeFrameReporter_State* value) {
107   int int_value;
108   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
109       ChromeFrameReporter_State_entries, 4, name, &int_value);
110   if (success) {
111     *value = static_cast<ChromeFrameReporter_State>(int_value);
112   }
113   return success;
114 }
115 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
116 constexpr ChromeFrameReporter_State ChromeFrameReporter::STATE_NO_UPDATE_DESIRED;
117 constexpr ChromeFrameReporter_State ChromeFrameReporter::STATE_PRESENTED_ALL;
118 constexpr ChromeFrameReporter_State ChromeFrameReporter::STATE_PRESENTED_PARTIAL;
119 constexpr ChromeFrameReporter_State ChromeFrameReporter::STATE_DROPPED;
120 constexpr ChromeFrameReporter_State ChromeFrameReporter::State_MIN;
121 constexpr ChromeFrameReporter_State ChromeFrameReporter::State_MAX;
122 constexpr int ChromeFrameReporter::State_ARRAYSIZE;
123 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
ChromeFrameReporter_FrameDropReason_IsValid(int value)124 bool ChromeFrameReporter_FrameDropReason_IsValid(int value) {
125   switch (value) {
126     case 0:
127     case 1:
128     case 2:
129     case 3:
130       return true;
131     default:
132       return false;
133   }
134 }
135 
136 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeFrameReporter_FrameDropReason_strings[4] = {};
137 
138 static const char ChromeFrameReporter_FrameDropReason_names[] =
139   "REASON_CLIENT_COMPOSITOR"
140   "REASON_DISPLAY_COMPOSITOR"
141   "REASON_MAIN_THREAD"
142   "REASON_UNSPECIFIED";
143 
144 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeFrameReporter_FrameDropReason_entries[] = {
145   { {ChromeFrameReporter_FrameDropReason_names + 0, 24}, 3 },
146   { {ChromeFrameReporter_FrameDropReason_names + 24, 25}, 1 },
147   { {ChromeFrameReporter_FrameDropReason_names + 49, 18}, 2 },
148   { {ChromeFrameReporter_FrameDropReason_names + 67, 18}, 0 },
149 };
150 
151 static const int ChromeFrameReporter_FrameDropReason_entries_by_number[] = {
152   3, // 0 -> REASON_UNSPECIFIED
153   1, // 1 -> REASON_DISPLAY_COMPOSITOR
154   2, // 2 -> REASON_MAIN_THREAD
155   0, // 3 -> REASON_CLIENT_COMPOSITOR
156 };
157 
ChromeFrameReporter_FrameDropReason_Name(ChromeFrameReporter_FrameDropReason value)158 const std::string& ChromeFrameReporter_FrameDropReason_Name(
159     ChromeFrameReporter_FrameDropReason value) {
160   static const bool dummy =
161       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
162           ChromeFrameReporter_FrameDropReason_entries,
163           ChromeFrameReporter_FrameDropReason_entries_by_number,
164           4, ChromeFrameReporter_FrameDropReason_strings);
165   (void) dummy;
166   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
167       ChromeFrameReporter_FrameDropReason_entries,
168       ChromeFrameReporter_FrameDropReason_entries_by_number,
169       4, value);
170   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
171                      ChromeFrameReporter_FrameDropReason_strings[idx].get();
172 }
ChromeFrameReporter_FrameDropReason_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeFrameReporter_FrameDropReason * value)173 bool ChromeFrameReporter_FrameDropReason_Parse(
174     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeFrameReporter_FrameDropReason* value) {
175   int int_value;
176   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
177       ChromeFrameReporter_FrameDropReason_entries, 4, name, &int_value);
178   if (success) {
179     *value = static_cast<ChromeFrameReporter_FrameDropReason>(int_value);
180   }
181   return success;
182 }
183 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
184 constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter::REASON_UNSPECIFIED;
185 constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter::REASON_DISPLAY_COMPOSITOR;
186 constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter::REASON_MAIN_THREAD;
187 constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter::REASON_CLIENT_COMPOSITOR;
188 constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter::FrameDropReason_MIN;
189 constexpr ChromeFrameReporter_FrameDropReason ChromeFrameReporter::FrameDropReason_MAX;
190 constexpr int ChromeFrameReporter::FrameDropReason_ARRAYSIZE;
191 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
ChromeFrameReporter_ScrollState_IsValid(int value)192 bool ChromeFrameReporter_ScrollState_IsValid(int value) {
193   switch (value) {
194     case 0:
195     case 1:
196     case 2:
197     case 3:
198     case 4:
199       return true;
200     default:
201       return false;
202   }
203 }
204 
205 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeFrameReporter_ScrollState_strings[5] = {};
206 
207 static const char ChromeFrameReporter_ScrollState_names[] =
208   "SCROLL_COMPOSITOR_THREAD"
209   "SCROLL_MAIN_THREAD"
210   "SCROLL_NONE"
211   "SCROLL_RASTER"
212   "SCROLL_UNKNOWN";
213 
214 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeFrameReporter_ScrollState_entries[] = {
215   { {ChromeFrameReporter_ScrollState_names + 0, 24}, 2 },
216   { {ChromeFrameReporter_ScrollState_names + 24, 18}, 1 },
217   { {ChromeFrameReporter_ScrollState_names + 42, 11}, 0 },
218   { {ChromeFrameReporter_ScrollState_names + 53, 13}, 3 },
219   { {ChromeFrameReporter_ScrollState_names + 66, 14}, 4 },
220 };
221 
222 static const int ChromeFrameReporter_ScrollState_entries_by_number[] = {
223   2, // 0 -> SCROLL_NONE
224   1, // 1 -> SCROLL_MAIN_THREAD
225   0, // 2 -> SCROLL_COMPOSITOR_THREAD
226   3, // 3 -> SCROLL_RASTER
227   4, // 4 -> SCROLL_UNKNOWN
228 };
229 
ChromeFrameReporter_ScrollState_Name(ChromeFrameReporter_ScrollState value)230 const std::string& ChromeFrameReporter_ScrollState_Name(
231     ChromeFrameReporter_ScrollState value) {
232   static const bool dummy =
233       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
234           ChromeFrameReporter_ScrollState_entries,
235           ChromeFrameReporter_ScrollState_entries_by_number,
236           5, ChromeFrameReporter_ScrollState_strings);
237   (void) dummy;
238   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
239       ChromeFrameReporter_ScrollState_entries,
240       ChromeFrameReporter_ScrollState_entries_by_number,
241       5, value);
242   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
243                      ChromeFrameReporter_ScrollState_strings[idx].get();
244 }
ChromeFrameReporter_ScrollState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeFrameReporter_ScrollState * value)245 bool ChromeFrameReporter_ScrollState_Parse(
246     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeFrameReporter_ScrollState* value) {
247   int int_value;
248   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
249       ChromeFrameReporter_ScrollState_entries, 5, name, &int_value);
250   if (success) {
251     *value = static_cast<ChromeFrameReporter_ScrollState>(int_value);
252   }
253   return success;
254 }
255 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
256 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::SCROLL_NONE;
257 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::SCROLL_MAIN_THREAD;
258 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::SCROLL_COMPOSITOR_THREAD;
259 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::SCROLL_RASTER;
260 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::SCROLL_UNKNOWN;
261 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::ScrollState_MIN;
262 constexpr ChromeFrameReporter_ScrollState ChromeFrameReporter::ScrollState_MAX;
263 constexpr int ChromeFrameReporter::ScrollState_ARRAYSIZE;
264 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
ChromeFrameReporter_FrameType_IsValid(int value)265 bool ChromeFrameReporter_FrameType_IsValid(int value) {
266   switch (value) {
267     case 0:
268     case 1:
269       return true;
270     default:
271       return false;
272   }
273 }
274 
275 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ChromeFrameReporter_FrameType_strings[2] = {};
276 
277 static const char ChromeFrameReporter_FrameType_names[] =
278   "BACKFILL"
279   "FORKED";
280 
281 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ChromeFrameReporter_FrameType_entries[] = {
282   { {ChromeFrameReporter_FrameType_names + 0, 8}, 1 },
283   { {ChromeFrameReporter_FrameType_names + 8, 6}, 0 },
284 };
285 
286 static const int ChromeFrameReporter_FrameType_entries_by_number[] = {
287   1, // 0 -> FORKED
288   0, // 1 -> BACKFILL
289 };
290 
ChromeFrameReporter_FrameType_Name(ChromeFrameReporter_FrameType value)291 const std::string& ChromeFrameReporter_FrameType_Name(
292     ChromeFrameReporter_FrameType value) {
293   static const bool dummy =
294       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
295           ChromeFrameReporter_FrameType_entries,
296           ChromeFrameReporter_FrameType_entries_by_number,
297           2, ChromeFrameReporter_FrameType_strings);
298   (void) dummy;
299   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
300       ChromeFrameReporter_FrameType_entries,
301       ChromeFrameReporter_FrameType_entries_by_number,
302       2, value);
303   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
304                      ChromeFrameReporter_FrameType_strings[idx].get();
305 }
ChromeFrameReporter_FrameType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ChromeFrameReporter_FrameType * value)306 bool ChromeFrameReporter_FrameType_Parse(
307     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ChromeFrameReporter_FrameType* value) {
308   int int_value;
309   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
310       ChromeFrameReporter_FrameType_entries, 2, name, &int_value);
311   if (success) {
312     *value = static_cast<ChromeFrameReporter_FrameType>(int_value);
313   }
314   return success;
315 }
316 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
317 constexpr ChromeFrameReporter_FrameType ChromeFrameReporter::FORKED;
318 constexpr ChromeFrameReporter_FrameType ChromeFrameReporter::BACKFILL;
319 constexpr ChromeFrameReporter_FrameType ChromeFrameReporter::FrameType_MIN;
320 constexpr ChromeFrameReporter_FrameType ChromeFrameReporter::FrameType_MAX;
321 constexpr int ChromeFrameReporter::FrameType_ARRAYSIZE;
322 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
323 
324 // ===================================================================
325 
326 class ChromeFrameReporter::_Internal {
327  public:
328   using HasBits = decltype(std::declval<ChromeFrameReporter>()._impl_._has_bits_);
set_has_state(HasBits * has_bits)329   static void set_has_state(HasBits* has_bits) {
330     (*has_bits)[0] |= 1u;
331   }
set_has_reason(HasBits * has_bits)332   static void set_has_reason(HasBits* has_bits) {
333     (*has_bits)[0] |= 2u;
334   }
set_has_frame_source(HasBits * has_bits)335   static void set_has_frame_source(HasBits* has_bits) {
336     (*has_bits)[0] |= 4u;
337   }
set_has_frame_sequence(HasBits * has_bits)338   static void set_has_frame_sequence(HasBits* has_bits) {
339     (*has_bits)[0] |= 8u;
340   }
set_has_affects_smoothness(HasBits * has_bits)341   static void set_has_affects_smoothness(HasBits* has_bits) {
342     (*has_bits)[0] |= 32u;
343   }
set_has_scroll_state(HasBits * has_bits)344   static void set_has_scroll_state(HasBits* has_bits) {
345     (*has_bits)[0] |= 16u;
346   }
set_has_has_main_animation(HasBits * has_bits)347   static void set_has_has_main_animation(HasBits* has_bits) {
348     (*has_bits)[0] |= 64u;
349   }
set_has_has_compositor_animation(HasBits * has_bits)350   static void set_has_has_compositor_animation(HasBits* has_bits) {
351     (*has_bits)[0] |= 128u;
352   }
set_has_has_smooth_input_main(HasBits * has_bits)353   static void set_has_has_smooth_input_main(HasBits* has_bits) {
354     (*has_bits)[0] |= 256u;
355   }
set_has_has_missing_content(HasBits * has_bits)356   static void set_has_has_missing_content(HasBits* has_bits) {
357     (*has_bits)[0] |= 2048u;
358   }
set_has_layer_tree_host_id(HasBits * has_bits)359   static void set_has_layer_tree_host_id(HasBits* has_bits) {
360     (*has_bits)[0] |= 512u;
361   }
set_has_has_high_latency(HasBits * has_bits)362   static void set_has_has_high_latency(HasBits* has_bits) {
363     (*has_bits)[0] |= 4096u;
364   }
set_has_frame_type(HasBits * has_bits)365   static void set_has_frame_type(HasBits* has_bits) {
366     (*has_bits)[0] |= 1024u;
367   }
set_has_checkerboarded_needs_raster(HasBits * has_bits)368   static void set_has_checkerboarded_needs_raster(HasBits* has_bits) {
369     (*has_bits)[0] |= 8192u;
370   }
set_has_checkerboarded_needs_record(HasBits * has_bits)371   static void set_has_checkerboarded_needs_record(HasBits* has_bits) {
372     (*has_bits)[0] |= 16384u;
373   }
374 };
375 
ChromeFrameReporter(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)376 ChromeFrameReporter::ChromeFrameReporter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
377                          bool is_message_owned)
378   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
379   SharedCtor(arena, is_message_owned);
380   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ChromeFrameReporter)
381 }
ChromeFrameReporter(const ChromeFrameReporter & from)382 ChromeFrameReporter::ChromeFrameReporter(const ChromeFrameReporter& from)
383   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
384   ChromeFrameReporter* const _this = this; (void)_this;
385   new (&_impl_) Impl_{
386       decltype(_impl_._has_bits_){from._impl_._has_bits_}
387     , /*decltype(_impl_._cached_size_)*/{}
388     , decltype(_impl_.high_latency_contribution_stage_){from._impl_.high_latency_contribution_stage_}
389     , decltype(_impl_.state_){}
390     , decltype(_impl_.reason_){}
391     , decltype(_impl_.frame_source_){}
392     , decltype(_impl_.frame_sequence_){}
393     , decltype(_impl_.scroll_state_){}
394     , decltype(_impl_.affects_smoothness_){}
395     , decltype(_impl_.has_main_animation_){}
396     , decltype(_impl_.has_compositor_animation_){}
397     , decltype(_impl_.has_smooth_input_main_){}
398     , decltype(_impl_.layer_tree_host_id_){}
399     , decltype(_impl_.frame_type_){}
400     , decltype(_impl_.has_missing_content_){}
401     , decltype(_impl_.has_high_latency_){}
402     , decltype(_impl_.checkerboarded_needs_raster_){}
403     , decltype(_impl_.checkerboarded_needs_record_){}};
404 
405   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
406   ::memcpy(&_impl_.state_, &from._impl_.state_,
407     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.checkerboarded_needs_record_) -
408     reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.checkerboarded_needs_record_));
409   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ChromeFrameReporter)
410 }
411 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)412 inline void ChromeFrameReporter::SharedCtor(
413     ::_pb::Arena* arena, bool is_message_owned) {
414   (void)arena;
415   (void)is_message_owned;
416   new (&_impl_) Impl_{
417       decltype(_impl_._has_bits_){}
418     , /*decltype(_impl_._cached_size_)*/{}
419     , decltype(_impl_.high_latency_contribution_stage_){arena}
420     , decltype(_impl_.state_){0}
421     , decltype(_impl_.reason_){0}
422     , decltype(_impl_.frame_source_){::uint64_t{0u}}
423     , decltype(_impl_.frame_sequence_){::uint64_t{0u}}
424     , decltype(_impl_.scroll_state_){0}
425     , decltype(_impl_.affects_smoothness_){false}
426     , decltype(_impl_.has_main_animation_){false}
427     , decltype(_impl_.has_compositor_animation_){false}
428     , decltype(_impl_.has_smooth_input_main_){false}
429     , decltype(_impl_.layer_tree_host_id_){::uint64_t{0u}}
430     , decltype(_impl_.frame_type_){0}
431     , decltype(_impl_.has_missing_content_){false}
432     , decltype(_impl_.has_high_latency_){false}
433     , decltype(_impl_.checkerboarded_needs_raster_){false}
434     , decltype(_impl_.checkerboarded_needs_record_){false}
435   };
436 }
437 
~ChromeFrameReporter()438 ChromeFrameReporter::~ChromeFrameReporter() {
439   // @@protoc_insertion_point(destructor:perfetto.protos.ChromeFrameReporter)
440   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
441   (void)arena;
442     return;
443   }
444   SharedDtor();
445 }
446 
SharedDtor()447 inline void ChromeFrameReporter::SharedDtor() {
448   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
449   _impl_.high_latency_contribution_stage_.~RepeatedPtrField();
450 }
451 
SetCachedSize(int size) const452 void ChromeFrameReporter::SetCachedSize(int size) const {
453   _impl_._cached_size_.Set(size);
454 }
455 
Clear()456 void ChromeFrameReporter::Clear() {
457 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ChromeFrameReporter)
458   ::uint32_t cached_has_bits = 0;
459   // Prevent compiler warnings about cached_has_bits being unused
460   (void) cached_has_bits;
461 
462   _impl_.high_latency_contribution_stage_.Clear();
463   cached_has_bits = _impl_._has_bits_[0];
464   if (cached_has_bits & 0x000000ffu) {
465     ::memset(&_impl_.state_, 0, static_cast<size_t>(
466         reinterpret_cast<char*>(&_impl_.has_compositor_animation_) -
467         reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.has_compositor_animation_));
468   }
469   if (cached_has_bits & 0x00007f00u) {
470     ::memset(&_impl_.has_smooth_input_main_, 0, static_cast<size_t>(
471         reinterpret_cast<char*>(&_impl_.checkerboarded_needs_record_) -
472         reinterpret_cast<char*>(&_impl_.has_smooth_input_main_)) + sizeof(_impl_.checkerboarded_needs_record_));
473   }
474   _impl_._has_bits_.Clear();
475   _internal_metadata_.Clear<std::string>();
476 }
477 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)478 const char* ChromeFrameReporter::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
479 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
480   _Internal::HasBits has_bits{};
481   while (!ctx->Done(&ptr)) {
482     ::uint32_t tag;
483     ptr = ::_pbi::ReadTag(ptr, &tag);
484     switch (tag >> 3) {
485       // optional .perfetto.protos.ChromeFrameReporter.State state = 1;
486       case 1:
487         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
488           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
489           CHK_(ptr);
490           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeFrameReporter_State_IsValid(val))) {
491             _internal_set_state(static_cast<::perfetto::protos::ChromeFrameReporter_State>(val));
492           } else {
493             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
494           }
495         } else {
496           goto handle_unusual;
497         }
498         continue;
499       // optional .perfetto.protos.ChromeFrameReporter.FrameDropReason reason = 2;
500       case 2:
501         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
502           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
503           CHK_(ptr);
504           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeFrameReporter_FrameDropReason_IsValid(val))) {
505             _internal_set_reason(static_cast<::perfetto::protos::ChromeFrameReporter_FrameDropReason>(val));
506           } else {
507             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
508           }
509         } else {
510           goto handle_unusual;
511         }
512         continue;
513       // optional uint64 frame_source = 3;
514       case 3:
515         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
516           _Internal::set_has_frame_source(&has_bits);
517           _impl_.frame_source_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
518           CHK_(ptr);
519         } else {
520           goto handle_unusual;
521         }
522         continue;
523       // optional uint64 frame_sequence = 4;
524       case 4:
525         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
526           _Internal::set_has_frame_sequence(&has_bits);
527           _impl_.frame_sequence_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
528           CHK_(ptr);
529         } else {
530           goto handle_unusual;
531         }
532         continue;
533       // optional bool affects_smoothness = 5;
534       case 5:
535         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
536           _Internal::set_has_affects_smoothness(&has_bits);
537           _impl_.affects_smoothness_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
538           CHK_(ptr);
539         } else {
540           goto handle_unusual;
541         }
542         continue;
543       // optional .perfetto.protos.ChromeFrameReporter.ScrollState scroll_state = 6;
544       case 6:
545         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
546           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
547           CHK_(ptr);
548           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeFrameReporter_ScrollState_IsValid(val))) {
549             _internal_set_scroll_state(static_cast<::perfetto::protos::ChromeFrameReporter_ScrollState>(val));
550           } else {
551             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(6, val, mutable_unknown_fields());
552           }
553         } else {
554           goto handle_unusual;
555         }
556         continue;
557       // optional bool has_main_animation = 7;
558       case 7:
559         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
560           _Internal::set_has_has_main_animation(&has_bits);
561           _impl_.has_main_animation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
562           CHK_(ptr);
563         } else {
564           goto handle_unusual;
565         }
566         continue;
567       // optional bool has_compositor_animation = 8;
568       case 8:
569         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
570           _Internal::set_has_has_compositor_animation(&has_bits);
571           _impl_.has_compositor_animation_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
572           CHK_(ptr);
573         } else {
574           goto handle_unusual;
575         }
576         continue;
577       // optional bool has_smooth_input_main = 9;
578       case 9:
579         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
580           _Internal::set_has_has_smooth_input_main(&has_bits);
581           _impl_.has_smooth_input_main_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
582           CHK_(ptr);
583         } else {
584           goto handle_unusual;
585         }
586         continue;
587       // optional bool has_missing_content = 10;
588       case 10:
589         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
590           _Internal::set_has_has_missing_content(&has_bits);
591           _impl_.has_missing_content_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
592           CHK_(ptr);
593         } else {
594           goto handle_unusual;
595         }
596         continue;
597       // optional uint64 layer_tree_host_id = 11;
598       case 11:
599         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
600           _Internal::set_has_layer_tree_host_id(&has_bits);
601           _impl_.layer_tree_host_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
602           CHK_(ptr);
603         } else {
604           goto handle_unusual;
605         }
606         continue;
607       // optional bool has_high_latency = 12;
608       case 12:
609         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
610           _Internal::set_has_has_high_latency(&has_bits);
611           _impl_.has_high_latency_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
612           CHK_(ptr);
613         } else {
614           goto handle_unusual;
615         }
616         continue;
617       // optional .perfetto.protos.ChromeFrameReporter.FrameType frame_type = 13;
618       case 13:
619         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
620           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
621           CHK_(ptr);
622           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ChromeFrameReporter_FrameType_IsValid(val))) {
623             _internal_set_frame_type(static_cast<::perfetto::protos::ChromeFrameReporter_FrameType>(val));
624           } else {
625             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(13, val, mutable_unknown_fields());
626           }
627         } else {
628           goto handle_unusual;
629         }
630         continue;
631       // repeated string high_latency_contribution_stage = 14;
632       case 14:
633         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 114)) {
634           ptr -= 1;
635           do {
636             ptr += 1;
637             auto str = _internal_add_high_latency_contribution_stage();
638             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
639             CHK_(ptr);
640             if (!ctx->DataAvailable(ptr)) break;
641           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<114>(ptr));
642         } else {
643           goto handle_unusual;
644         }
645         continue;
646       // optional bool checkerboarded_needs_raster = 15;
647       case 15:
648         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
649           _Internal::set_has_checkerboarded_needs_raster(&has_bits);
650           _impl_.checkerboarded_needs_raster_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
651           CHK_(ptr);
652         } else {
653           goto handle_unusual;
654         }
655         continue;
656       // optional bool checkerboarded_needs_record = 16;
657       case 16:
658         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
659           _Internal::set_has_checkerboarded_needs_record(&has_bits);
660           _impl_.checkerboarded_needs_record_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
661           CHK_(ptr);
662         } else {
663           goto handle_unusual;
664         }
665         continue;
666       default:
667         goto handle_unusual;
668     }  // switch
669   handle_unusual:
670     if ((tag == 0) || ((tag & 7) == 4)) {
671       CHK_(ptr);
672       ctx->SetLastTag(tag);
673       goto message_done;
674     }
675     ptr = UnknownFieldParse(
676         tag,
677         _internal_metadata_.mutable_unknown_fields<std::string>(),
678         ptr, ctx);
679     CHK_(ptr != nullptr);
680   }  // while
681 message_done:
682   _impl_._has_bits_.Or(has_bits);
683   return ptr;
684 failure:
685   ptr = nullptr;
686   goto message_done;
687 #undef CHK_
688 }
689 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const690 ::uint8_t* ChromeFrameReporter::_InternalSerialize(
691     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
692   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ChromeFrameReporter)
693   ::uint32_t cached_has_bits = 0;
694   (void) cached_has_bits;
695 
696   cached_has_bits = _impl_._has_bits_[0];
697   // optional .perfetto.protos.ChromeFrameReporter.State state = 1;
698   if (cached_has_bits & 0x00000001u) {
699     target = stream->EnsureSpace(target);
700     target = ::_pbi::WireFormatLite::WriteEnumToArray(
701       1, this->_internal_state(), target);
702   }
703 
704   // optional .perfetto.protos.ChromeFrameReporter.FrameDropReason reason = 2;
705   if (cached_has_bits & 0x00000002u) {
706     target = stream->EnsureSpace(target);
707     target = ::_pbi::WireFormatLite::WriteEnumToArray(
708       2, this->_internal_reason(), target);
709   }
710 
711   // optional uint64 frame_source = 3;
712   if (cached_has_bits & 0x00000004u) {
713     target = stream->EnsureSpace(target);
714     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_frame_source(), target);
715   }
716 
717   // optional uint64 frame_sequence = 4;
718   if (cached_has_bits & 0x00000008u) {
719     target = stream->EnsureSpace(target);
720     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_frame_sequence(), target);
721   }
722 
723   // optional bool affects_smoothness = 5;
724   if (cached_has_bits & 0x00000020u) {
725     target = stream->EnsureSpace(target);
726     target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_affects_smoothness(), target);
727   }
728 
729   // optional .perfetto.protos.ChromeFrameReporter.ScrollState scroll_state = 6;
730   if (cached_has_bits & 0x00000010u) {
731     target = stream->EnsureSpace(target);
732     target = ::_pbi::WireFormatLite::WriteEnumToArray(
733       6, this->_internal_scroll_state(), target);
734   }
735 
736   // optional bool has_main_animation = 7;
737   if (cached_has_bits & 0x00000040u) {
738     target = stream->EnsureSpace(target);
739     target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_has_main_animation(), target);
740   }
741 
742   // optional bool has_compositor_animation = 8;
743   if (cached_has_bits & 0x00000080u) {
744     target = stream->EnsureSpace(target);
745     target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_has_compositor_animation(), target);
746   }
747 
748   // optional bool has_smooth_input_main = 9;
749   if (cached_has_bits & 0x00000100u) {
750     target = stream->EnsureSpace(target);
751     target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_has_smooth_input_main(), target);
752   }
753 
754   // optional bool has_missing_content = 10;
755   if (cached_has_bits & 0x00000800u) {
756     target = stream->EnsureSpace(target);
757     target = ::_pbi::WireFormatLite::WriteBoolToArray(10, this->_internal_has_missing_content(), target);
758   }
759 
760   // optional uint64 layer_tree_host_id = 11;
761   if (cached_has_bits & 0x00000200u) {
762     target = stream->EnsureSpace(target);
763     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(11, this->_internal_layer_tree_host_id(), target);
764   }
765 
766   // optional bool has_high_latency = 12;
767   if (cached_has_bits & 0x00001000u) {
768     target = stream->EnsureSpace(target);
769     target = ::_pbi::WireFormatLite::WriteBoolToArray(12, this->_internal_has_high_latency(), target);
770   }
771 
772   // optional .perfetto.protos.ChromeFrameReporter.FrameType frame_type = 13;
773   if (cached_has_bits & 0x00000400u) {
774     target = stream->EnsureSpace(target);
775     target = ::_pbi::WireFormatLite::WriteEnumToArray(
776       13, this->_internal_frame_type(), target);
777   }
778 
779   // repeated string high_latency_contribution_stage = 14;
780   for (int i = 0, n = this->_internal_high_latency_contribution_stage_size(); i < n; i++) {
781     const auto& s = this->_internal_high_latency_contribution_stage(i);
782     target = stream->WriteString(14, s, target);
783   }
784 
785   // optional bool checkerboarded_needs_raster = 15;
786   if (cached_has_bits & 0x00002000u) {
787     target = stream->EnsureSpace(target);
788     target = ::_pbi::WireFormatLite::WriteBoolToArray(15, this->_internal_checkerboarded_needs_raster(), target);
789   }
790 
791   // optional bool checkerboarded_needs_record = 16;
792   if (cached_has_bits & 0x00004000u) {
793     target = stream->EnsureSpace(target);
794     target = ::_pbi::WireFormatLite::WriteBoolToArray(16, this->_internal_checkerboarded_needs_record(), target);
795   }
796 
797   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
798     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
799         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
800   }
801   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ChromeFrameReporter)
802   return target;
803 }
804 
ByteSizeLong() const805 size_t ChromeFrameReporter::ByteSizeLong() const {
806 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ChromeFrameReporter)
807   size_t total_size = 0;
808 
809   ::uint32_t cached_has_bits = 0;
810   // Prevent compiler warnings about cached_has_bits being unused
811   (void) cached_has_bits;
812 
813   // repeated string high_latency_contribution_stage = 14;
814   total_size += 1 *
815       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.high_latency_contribution_stage_.size());
816   for (int i = 0, n = _impl_.high_latency_contribution_stage_.size(); i < n; i++) {
817     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
818       _impl_.high_latency_contribution_stage_.Get(i));
819   }
820 
821   cached_has_bits = _impl_._has_bits_[0];
822   if (cached_has_bits & 0x000000ffu) {
823     // optional .perfetto.protos.ChromeFrameReporter.State state = 1;
824     if (cached_has_bits & 0x00000001u) {
825       total_size += 1 +
826         ::_pbi::WireFormatLite::EnumSize(this->_internal_state());
827     }
828 
829     // optional .perfetto.protos.ChromeFrameReporter.FrameDropReason reason = 2;
830     if (cached_has_bits & 0x00000002u) {
831       total_size += 1 +
832         ::_pbi::WireFormatLite::EnumSize(this->_internal_reason());
833     }
834 
835     // optional uint64 frame_source = 3;
836     if (cached_has_bits & 0x00000004u) {
837       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_frame_source());
838     }
839 
840     // optional uint64 frame_sequence = 4;
841     if (cached_has_bits & 0x00000008u) {
842       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_frame_sequence());
843     }
844 
845     // optional .perfetto.protos.ChromeFrameReporter.ScrollState scroll_state = 6;
846     if (cached_has_bits & 0x00000010u) {
847       total_size += 1 +
848         ::_pbi::WireFormatLite::EnumSize(this->_internal_scroll_state());
849     }
850 
851     // optional bool affects_smoothness = 5;
852     if (cached_has_bits & 0x00000020u) {
853       total_size += 1 + 1;
854     }
855 
856     // optional bool has_main_animation = 7;
857     if (cached_has_bits & 0x00000040u) {
858       total_size += 1 + 1;
859     }
860 
861     // optional bool has_compositor_animation = 8;
862     if (cached_has_bits & 0x00000080u) {
863       total_size += 1 + 1;
864     }
865 
866   }
867   if (cached_has_bits & 0x00007f00u) {
868     // optional bool has_smooth_input_main = 9;
869     if (cached_has_bits & 0x00000100u) {
870       total_size += 1 + 1;
871     }
872 
873     // optional uint64 layer_tree_host_id = 11;
874     if (cached_has_bits & 0x00000200u) {
875       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_layer_tree_host_id());
876     }
877 
878     // optional .perfetto.protos.ChromeFrameReporter.FrameType frame_type = 13;
879     if (cached_has_bits & 0x00000400u) {
880       total_size += 1 +
881         ::_pbi::WireFormatLite::EnumSize(this->_internal_frame_type());
882     }
883 
884     // optional bool has_missing_content = 10;
885     if (cached_has_bits & 0x00000800u) {
886       total_size += 1 + 1;
887     }
888 
889     // optional bool has_high_latency = 12;
890     if (cached_has_bits & 0x00001000u) {
891       total_size += 1 + 1;
892     }
893 
894     // optional bool checkerboarded_needs_raster = 15;
895     if (cached_has_bits & 0x00002000u) {
896       total_size += 1 + 1;
897     }
898 
899     // optional bool checkerboarded_needs_record = 16;
900     if (cached_has_bits & 0x00004000u) {
901       total_size += 2 + 1;
902     }
903 
904   }
905   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
906     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
907   }
908   int cached_size = ::_pbi::ToCachedSize(total_size);
909   SetCachedSize(cached_size);
910   return total_size;
911 }
912 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)913 void ChromeFrameReporter::CheckTypeAndMergeFrom(
914     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
915   MergeFrom(*::_pbi::DownCast<const ChromeFrameReporter*>(
916       &from));
917 }
918 
MergeFrom(const ChromeFrameReporter & from)919 void ChromeFrameReporter::MergeFrom(const ChromeFrameReporter& from) {
920   ChromeFrameReporter* const _this = this;
921   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ChromeFrameReporter)
922   GOOGLE_DCHECK_NE(&from, _this);
923   ::uint32_t cached_has_bits = 0;
924   (void) cached_has_bits;
925 
926   _this->_impl_.high_latency_contribution_stage_.MergeFrom(from._impl_.high_latency_contribution_stage_);
927   cached_has_bits = from._impl_._has_bits_[0];
928   if (cached_has_bits & 0x000000ffu) {
929     if (cached_has_bits & 0x00000001u) {
930       _this->_impl_.state_ = from._impl_.state_;
931     }
932     if (cached_has_bits & 0x00000002u) {
933       _this->_impl_.reason_ = from._impl_.reason_;
934     }
935     if (cached_has_bits & 0x00000004u) {
936       _this->_impl_.frame_source_ = from._impl_.frame_source_;
937     }
938     if (cached_has_bits & 0x00000008u) {
939       _this->_impl_.frame_sequence_ = from._impl_.frame_sequence_;
940     }
941     if (cached_has_bits & 0x00000010u) {
942       _this->_impl_.scroll_state_ = from._impl_.scroll_state_;
943     }
944     if (cached_has_bits & 0x00000020u) {
945       _this->_impl_.affects_smoothness_ = from._impl_.affects_smoothness_;
946     }
947     if (cached_has_bits & 0x00000040u) {
948       _this->_impl_.has_main_animation_ = from._impl_.has_main_animation_;
949     }
950     if (cached_has_bits & 0x00000080u) {
951       _this->_impl_.has_compositor_animation_ = from._impl_.has_compositor_animation_;
952     }
953     _this->_impl_._has_bits_[0] |= cached_has_bits;
954   }
955   if (cached_has_bits & 0x00007f00u) {
956     if (cached_has_bits & 0x00000100u) {
957       _this->_impl_.has_smooth_input_main_ = from._impl_.has_smooth_input_main_;
958     }
959     if (cached_has_bits & 0x00000200u) {
960       _this->_impl_.layer_tree_host_id_ = from._impl_.layer_tree_host_id_;
961     }
962     if (cached_has_bits & 0x00000400u) {
963       _this->_impl_.frame_type_ = from._impl_.frame_type_;
964     }
965     if (cached_has_bits & 0x00000800u) {
966       _this->_impl_.has_missing_content_ = from._impl_.has_missing_content_;
967     }
968     if (cached_has_bits & 0x00001000u) {
969       _this->_impl_.has_high_latency_ = from._impl_.has_high_latency_;
970     }
971     if (cached_has_bits & 0x00002000u) {
972       _this->_impl_.checkerboarded_needs_raster_ = from._impl_.checkerboarded_needs_raster_;
973     }
974     if (cached_has_bits & 0x00004000u) {
975       _this->_impl_.checkerboarded_needs_record_ = from._impl_.checkerboarded_needs_record_;
976     }
977     _this->_impl_._has_bits_[0] |= cached_has_bits;
978   }
979   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
980 }
981 
CopyFrom(const ChromeFrameReporter & from)982 void ChromeFrameReporter::CopyFrom(const ChromeFrameReporter& from) {
983 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ChromeFrameReporter)
984   if (&from == this) return;
985   Clear();
986   MergeFrom(from);
987 }
988 
IsInitialized() const989 bool ChromeFrameReporter::IsInitialized() const {
990   return true;
991 }
992 
InternalSwap(ChromeFrameReporter * other)993 void ChromeFrameReporter::InternalSwap(ChromeFrameReporter* other) {
994   using std::swap;
995   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
996   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
997   _impl_.high_latency_contribution_stage_.InternalSwap(&other->_impl_.high_latency_contribution_stage_);
998   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
999       PROTOBUF_FIELD_OFFSET(ChromeFrameReporter, _impl_.checkerboarded_needs_record_)
1000       + sizeof(ChromeFrameReporter::_impl_.checkerboarded_needs_record_)  // NOLINT
1001       - PROTOBUF_FIELD_OFFSET(ChromeFrameReporter, _impl_.state_)>(
1002           reinterpret_cast<char*>(&_impl_.state_),
1003           reinterpret_cast<char*>(&other->_impl_.state_));
1004 }
1005 
GetTypeName() const1006 std::string ChromeFrameReporter::GetTypeName() const {
1007   return "perfetto.protos.ChromeFrameReporter";
1008 }
1009 
1010 
1011 // @@protoc_insertion_point(namespace_scope)
1012 }  // namespace protos
1013 }  // namespace perfetto
1014 PROTOBUF_NAMESPACE_OPEN
1015 template<> PROTOBUF_NOINLINE ::perfetto::protos::ChromeFrameReporter*
CreateMaybeMessage(Arena * arena)1016 Arena::CreateMaybeMessage< ::perfetto::protos::ChromeFrameReporter >(Arena* arena) {
1017   return Arena::CreateMessageInternal< ::perfetto::protos::ChromeFrameReporter >(arena);
1018 }
1019 PROTOBUF_NAMESPACE_CLOSE
1020 
1021 // @@protoc_insertion_point(global_scope)
1022 #include <google/protobuf/port_undef.inc>
1023