From 7565fead212ec42e5fe4dc525e1ba518ddbf8d2b Mon Sep 17 00:00:00 2001 From: Denis Palmeiro Date: Thu, 18 Jul 2024 15:52:07 +0000 Subject: [PATCH] Bug 1907314: Update perfetto to v46.0. r=smaug Differential Revision: https://phabricator.services.mozilla.com/D216948 --- third_party/perfetto/moz.yaml | 4 +- third_party/perfetto/moz_attributes.patch | 13 +- third_party/perfetto/sdk/perfetto.cc | 533 +- third_party/perfetto/sdk/perfetto.h | 21831 ++++++++++++-------- 4 files changed, 13337 insertions(+), 9044 deletions(-) diff --git a/third_party/perfetto/moz.yaml b/third_party/perfetto/moz.yaml index 50c7151faa32..8863114e26dc 100644 --- a/third_party/perfetto/moz.yaml +++ b/third_party/perfetto/moz.yaml @@ -13,8 +13,8 @@ origin: url: "https://perfetto.dev" license: Apache-2.0 - release: v44.0 (2024-04-10T09:26:48+00:00). - revision: v44.0 + release: v46.0 (2024-06-13T17:08:13+00:00). + revision: v46.0 updatebot: maintainer-phab: denispal diff --git a/third_party/perfetto/moz_attributes.patch b/third_party/perfetto/moz_attributes.patch index 883c1dbea67e..a889882b32ad 100644 --- a/third_party/perfetto/moz_attributes.patch +++ b/third_party/perfetto/moz_attributes.patch @@ -1,8 +1,7 @@ diff --git a/sdk/perfetto.h b/sdk/perfetto.h -index 411806567..b64f864a9 100644 --- a/sdk/perfetto.h +++ b/sdk/perfetto.h -@@ -365,8 +365,7 @@ +@@ -371,8 +371,7 @@ #if defined(__clang__) #if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__) @@ -12,7 +11,7 @@ index 411806567..b64f864a9 100644 #define PERFETTO_ASAN_POISON(a, s) __asan_poison_memory_region((a), (s)) #define PERFETTO_ASAN_UNPOISON(a, s) __asan_unpoison_memory_region((a), (s)) #else -@@ -19479,6 +19478,7 @@ class TrackEventDataSource +@@ -19790,6 +19789,7 @@ class TrackEventDataSource #define PERFETTO_INTERNAL_EVENT_FINALIZER_KEYWORD default #endif @@ -20,12 +19,12 @@ index 411806567..b64f864a9 100644 #define PERFETTO_INTERNAL_SCOPED_EVENT_FINALIZER(category) \ struct PERFETTO_UID(ScopedEvent) { \ struct EventFinalizer { \ -@@ -19489,7 +19489,7 @@ class TrackEventDataSource +@@ -19800,7 +19800,7 @@ class TrackEventDataSource /* TrackEventArgumentFunction in |__VA_ARGS__|. This is required so */ \ /* that the scoped event is exactly ONE line and can't escape the */ \ /* scope if used in a single line if statement. */ \ - EventFinalizer(...) {} \ + MOZ_IMPLICIT EventFinalizer(...) {} \ - ~EventFinalizer() { TRACE_EVENT_END(category); } \ - \ - EventFinalizer(const EventFinalizer&) = delete; \ + ~EventFinalizer() { \ + TRACE_EVENT_END(category); \ + } \ diff --git a/third_party/perfetto/sdk/perfetto.cc b/third_party/perfetto/sdk/perfetto.cc index 7d0c4e86cf08..368c90ccfbd2 100644 --- a/third_party/perfetto/sdk/perfetto.cc +++ b/third_party/perfetto/sdk/perfetto.cc @@ -265,7 +265,7 @@ class Hasher { // Allow hashing anything that has a |data| field, a |size| field, // and has the kHashable trait (e.g., base::StringView). - template > + template > void Update(const T& t) { Update(t.data(), t.size()); } @@ -563,7 +563,7 @@ struct std::hash<::perfetto::base::StringView> { // This headers deals with sys types commonly used in the codebase that are // missing on Windows. -#include +#include // IWYU pragma: export #include // gen_amalgamated expanded: #include "perfetto/base/build_config.h" @@ -13185,7 +13185,8 @@ ObservableEvents_CloneTriggerHit& ObservableEvents_CloneTriggerHit::operator=(Ob bool ObservableEvents_CloneTriggerHit::operator==(const ObservableEvents_CloneTriggerHit& other) const { return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) - && ::protozero::internal::gen_helpers::EqualsField(tracing_session_id_, other.tracing_session_id_); + && ::protozero::internal::gen_helpers::EqualsField(tracing_session_id_, other.tracing_session_id_) + && ::protozero::internal::gen_helpers::EqualsField(trigger_name_, other.trigger_name_); } bool ObservableEvents_CloneTriggerHit::ParseFromArray(const void* raw, size_t size) { @@ -13201,6 +13202,9 @@ bool ObservableEvents_CloneTriggerHit::ParseFromArray(const void* raw, size_t si case 1 /* tracing_session_id */: field.get(&tracing_session_id_); break; + case 2 /* trigger_name */: + ::protozero::internal::gen_helpers::DeserializeString(field, &trigger_name_); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -13227,6 +13231,11 @@ void ObservableEvents_CloneTriggerHit::Serialize(::protozero::Message* msg) cons ::protozero::internal::gen_helpers::SerializeVarInt(1, tracing_session_id_, msg); } + // Field 2: trigger_name + if (_has_field_[2]) { + ::protozero::internal::gen_helpers::SerializeString(2, trigger_name_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -15876,6 +15885,105 @@ void PackagesListConfig::Serialize(::protozero::Message* msg) const { protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } +} // namespace perfetto +} // namespace protos +} // namespace gen +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic pop +#endif +// gen_amalgamated begin source: gen/protos/perfetto/config/android/pixel_modem_config.gen.cc +// gen_amalgamated expanded: #include "perfetto/protozero/gen_field_helpers.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/scattered_heap_buffer.h" +// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wfloat-equal" +#endif +// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h" + +namespace perfetto { +namespace protos { +namespace gen { + +PixelModemConfig::PixelModemConfig() = default; +PixelModemConfig::~PixelModemConfig() = default; +PixelModemConfig::PixelModemConfig(const PixelModemConfig&) = default; +PixelModemConfig& PixelModemConfig::operator=(const PixelModemConfig&) = default; +PixelModemConfig::PixelModemConfig(PixelModemConfig&&) noexcept = default; +PixelModemConfig& PixelModemConfig::operator=(PixelModemConfig&&) = default; + +bool PixelModemConfig::operator==(const PixelModemConfig& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) + && ::protozero::internal::gen_helpers::EqualsField(event_group_, other.event_group_) + && ::protozero::internal::gen_helpers::EqualsField(pigweed_hash_allow_list_, other.pigweed_hash_allow_list_) + && ::protozero::internal::gen_helpers::EqualsField(pigweed_hash_deny_list_, other.pigweed_hash_deny_list_); +} + +bool PixelModemConfig::ParseFromArray(const void* raw, size_t size) { + pigweed_hash_allow_list_.clear(); + pigweed_hash_deny_list_.clear(); + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + case 1 /* event_group */: + field.get(&event_group_); + break; + case 2 /* pigweed_hash_allow_list */: + pigweed_hash_allow_list_.emplace_back(); + field.get(&pigweed_hash_allow_list_.back()); + break; + case 3 /* pigweed_hash_deny_list */: + pigweed_hash_deny_list_.emplace_back(); + field.get(&pigweed_hash_deny_list_.back()); + break; + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string PixelModemConfig::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector PixelModemConfig::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void PixelModemConfig::Serialize(::protozero::Message* msg) const { + // Field 1: event_group + if (_has_field_[1]) { + ::protozero::internal::gen_helpers::SerializeVarInt(1, event_group_, msg); + } + + // Field 2: pigweed_hash_allow_list + for (auto& it : pigweed_hash_allow_list_) { + ::protozero::internal::gen_helpers::SerializeVarInt(2, it, msg); + } + + // Field 3: pigweed_hash_deny_list + for (auto& it : pigweed_hash_deny_list_) { + ::protozero::internal::gen_helpers::SerializeVarInt(3, it, msg); + } + + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + } // namespace perfetto } // namespace protos } // namespace gen @@ -19235,6 +19343,7 @@ void ChromeConfig::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" @@ -20005,6 +20114,7 @@ bool DataSourceConfig::operator==(const DataSourceConfig& other) const { && ::protozero::internal::gen_helpers::EqualsField(etw_config_, other.etw_config_) && ::protozero::internal::gen_helpers::EqualsField(protolog_config_, other.protolog_config_) && ::protozero::internal::gen_helpers::EqualsField(android_input_event_config_, other.android_input_event_config_) + && ::protozero::internal::gen_helpers::EqualsField(pixel_modem_config_, other.pixel_modem_config_) && ::protozero::internal::gen_helpers::EqualsField(legacy_config_, other.legacy_config_) && ::protozero::internal::gen_helpers::EqualsField(for_testing_, other.for_testing_); } @@ -20127,6 +20237,9 @@ bool DataSourceConfig::ParseFromArray(const void* raw, size_t size) { case 128 /* android_input_event_config */: ::protozero::internal::gen_helpers::DeserializeString(field, &android_input_event_config_); break; + case 129 /* pixel_modem_config */: + ::protozero::internal::gen_helpers::DeserializeString(field, &pixel_modem_config_); + break; case 1000 /* legacy_config */: ::protozero::internal::gen_helpers::DeserializeString(field, &legacy_config_); break; @@ -20334,6 +20447,11 @@ void DataSourceConfig::Serialize(::protozero::Message* msg) const { msg->AppendString(128, android_input_event_config_); } + // Field 129: pixel_modem_config + if (_has_field_[129]) { + msg->AppendString(129, pixel_modem_config_); + } + // Field 1000: legacy_config if (_has_field_[1000]) { ::protozero::internal::gen_helpers::SerializeString(1000, legacy_config_, msg); @@ -20559,6 +20677,7 @@ void InterceptorConfig::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" @@ -21148,6 +21267,7 @@ void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" @@ -21205,7 +21325,8 @@ bool TraceConfig::operator==(const TraceConfig& other) const { && ::protozero::internal::gen_helpers::EqualsField(trace_uuid_lsb_, other.trace_uuid_lsb_) && ::protozero::internal::gen_helpers::EqualsField(trace_filter_, other.trace_filter_) && ::protozero::internal::gen_helpers::EqualsField(android_report_config_, other.android_report_config_) - && ::protozero::internal::gen_helpers::EqualsField(cmd_trace_start_delay_, other.cmd_trace_start_delay_); + && ::protozero::internal::gen_helpers::EqualsField(cmd_trace_start_delay_, other.cmd_trace_start_delay_) + && ::protozero::internal::gen_helpers::EqualsField(session_semaphores_, other.session_semaphores_); } int TraceConfig::buffers_size() const { return static_cast(buffers_.size()); } @@ -21217,11 +21338,15 @@ TraceConfig_DataSource* TraceConfig::add_data_sources() { data_sources_.emplace_ int TraceConfig::producers_size() const { return static_cast(producers_.size()); } void TraceConfig::clear_producers() { producers_.clear(); } TraceConfig_ProducerConfig* TraceConfig::add_producers() { producers_.emplace_back(); return &producers_.back(); } +int TraceConfig::session_semaphores_size() const { return static_cast(session_semaphores_.size()); } +void TraceConfig::clear_session_semaphores() { session_semaphores_.clear(); } +TraceConfig_SessionSemaphore* TraceConfig::add_session_semaphores() { session_semaphores_.emplace_back(); return &session_semaphores_.back(); } bool TraceConfig::ParseFromArray(const void* raw, size_t size) { buffers_.clear(); data_sources_.clear(); producers_.clear(); activate_triggers_.clear(); + session_semaphores_.clear(); unknown_fields_.clear(); bool packed_error = false; @@ -21337,6 +21462,10 @@ bool TraceConfig::ParseFromArray(const void* raw, size_t size) { case 35 /* cmd_trace_start_delay */: (*cmd_trace_start_delay_).ParseFromArray(field.data(), field.size()); break; + case 39 /* session_semaphores */: + session_semaphores_.emplace_back(); + session_semaphores_.back().ParseFromArray(field.data(), field.size()); + break; default: field.SerializeAndAppendTo(&unknown_fields_); break; @@ -21528,6 +21657,75 @@ void TraceConfig::Serialize(::protozero::Message* msg) const { (*cmd_trace_start_delay_).Serialize(msg->BeginNestedMessage<::protozero::Message>(35)); } + // Field 39: session_semaphores + for (auto& it : session_semaphores_) { + it.Serialize(msg->BeginNestedMessage<::protozero::Message>(39)); + } + + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); +} + + +TraceConfig_SessionSemaphore::TraceConfig_SessionSemaphore() = default; +TraceConfig_SessionSemaphore::~TraceConfig_SessionSemaphore() = default; +TraceConfig_SessionSemaphore::TraceConfig_SessionSemaphore(const TraceConfig_SessionSemaphore&) = default; +TraceConfig_SessionSemaphore& TraceConfig_SessionSemaphore::operator=(const TraceConfig_SessionSemaphore&) = default; +TraceConfig_SessionSemaphore::TraceConfig_SessionSemaphore(TraceConfig_SessionSemaphore&&) noexcept = default; +TraceConfig_SessionSemaphore& TraceConfig_SessionSemaphore::operator=(TraceConfig_SessionSemaphore&&) = default; + +bool TraceConfig_SessionSemaphore::operator==(const TraceConfig_SessionSemaphore& other) const { + return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_) + && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_) + && ::protozero::internal::gen_helpers::EqualsField(max_other_session_count_, other.max_other_session_count_); +} + +bool TraceConfig_SessionSemaphore::ParseFromArray(const void* raw, size_t size) { + unknown_fields_.clear(); + bool packed_error = false; + + ::protozero::ProtoDecoder dec(raw, size); + for (auto field = dec.ReadField(); field.valid(); field = dec.ReadField()) { + if (field.id() < _has_field_.size()) { + _has_field_.set(field.id()); + } + switch (field.id()) { + case 1 /* name */: + ::protozero::internal::gen_helpers::DeserializeString(field, &name_); + break; + case 2 /* max_other_session_count */: + field.get(&max_other_session_count_); + break; + default: + field.SerializeAndAppendTo(&unknown_fields_); + break; + } + } + return !packed_error && !dec.bytes_left(); +} + +std::string TraceConfig_SessionSemaphore::SerializeAsString() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsString(); +} + +std::vector TraceConfig_SessionSemaphore::SerializeAsArray() const { + ::protozero::internal::gen_helpers::MessageSerializer msg; + Serialize(msg.get()); + return msg.SerializeAsArray(); +} + +void TraceConfig_SessionSemaphore::Serialize(::protozero::Message* msg) const { + // Field 1: name + if (_has_field_[1]) { + ::protozero::internal::gen_helpers::SerializeString(1, name_, msg); + } + + // Field 2: max_other_session_count + if (_has_field_[2]) { + ::protozero::internal::gen_helpers::SerializeVarInt(2, max_other_session_count_, msg); + } + protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg); } @@ -22743,9 +22941,23 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/common/track_event_descriptor.pbzero.cc // Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.cc +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics/point.pbzero.cc // Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_input_event.pbzero.cc +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/graphics/rect.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/winscope_extensions.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/protolog.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/shell_transition.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_common.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_layers.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_transactions.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_game_intervention_list.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/android/android_log.pbzero.cc // Intentionally empty (crbug.com/998165) @@ -22765,15 +22977,7 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/android/packages_list.pbzero.cc // Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/protolog.pbzero.cc -// Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/shell_transition.pbzero.cc -// Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_common.pbzero.cc -// Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_layers.pbzero.cc -// Intentionally empty (crbug.com/998165) -// gen_amalgamated begin source: gen/protos/perfetto/trace/android/surfaceflinger_transactions.pbzero.cc +// gen_amalgamated begin source: gen/protos/perfetto/trace/android/pixel_modem_events.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_benchmark_metadata.pbzero.cc // Intentionally empty (crbug.com/998165) @@ -22781,6 +22985,8 @@ void TraceConfig_BufferConfig::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_trace_event.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/chrome_trigger.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/chrome/v8.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/gpu/gpu_counter_event.pbzero.cc @@ -27507,6 +27713,7 @@ bool TrackDescriptor::operator==(const TrackDescriptor& other) const { && ::protozero::internal::gen_helpers::EqualsField(uuid_, other.uuid_) && ::protozero::internal::gen_helpers::EqualsField(parent_uuid_, other.parent_uuid_) && ::protozero::internal::gen_helpers::EqualsField(name_, other.name_) + && ::protozero::internal::gen_helpers::EqualsField(static_name_, other.static_name_) && ::protozero::internal::gen_helpers::EqualsField(process_, other.process_) && ::protozero::internal::gen_helpers::EqualsField(chrome_process_, other.chrome_process_) && ::protozero::internal::gen_helpers::EqualsField(thread_, other.thread_) @@ -27534,6 +27741,9 @@ bool TrackDescriptor::ParseFromArray(const void* raw, size_t size) { case 2 /* name */: ::protozero::internal::gen_helpers::DeserializeString(field, &name_); break; + case 10 /* static_name */: + ::protozero::internal::gen_helpers::DeserializeString(field, &static_name_); + break; case 3 /* process */: (*process_).ParseFromArray(field.data(), field.size()); break; @@ -27588,6 +27798,11 @@ void TrackDescriptor::Serialize(::protozero::Message* msg) const { ::protozero::internal::gen_helpers::SerializeString(2, name_, msg); } + // Field 10: static_name + if (_has_field_[10]) { + ::protozero::internal::gen_helpers::SerializeString(10, static_name_, msg); + } + // Field 3: process if (_has_field_[3]) { (*process_).Serialize(msg->BeginNestedMessage<::protozero::Message>(3)); @@ -28547,6 +28762,8 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/config/android/packages_list_config.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/config/android/pixel_modem_config.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/config/android/protolog_config.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/config/android/surfaceflinger_layers_config.pbzero.cc @@ -28645,6 +28862,8 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/cros_ec.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dcvsh.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dma_fence.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/dmabuf_heap.pbzero.cc @@ -28667,6 +28886,10 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/g2d.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/google_icc_trace.pbzero.cc +// Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/google_irm_trace.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/gpu_mem.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/gpu_scheduler.pbzero.cc @@ -28681,6 +28904,8 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/irq.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kgsl.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kmem.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/kvm.pbzero.cc @@ -28739,6 +28964,8 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const { // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/thermal.pbzero.cc // Intentionally empty (crbug.com/998165) +// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/thermal_exynos.pbzero.cc +// Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/trusty.pbzero.cc // Intentionally empty (crbug.com/998165) // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/ufs.pbzero.cc @@ -28936,6 +29163,12 @@ ClockSnapshotVector CaptureClockSnapshots() { ClockReading(protos::pbzero::BUILTIN_CLOCK_MONOTONIC, wall_time_ns)); #endif +#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64) + // X86-specific but OS-independent TSC clocksource + snapshot_data.push_back( + ClockReading(protos::pbzero::BUILTIN_CLOCK_TSC, base::Rdtsc())); +#endif // PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64) + return snapshot_data; } @@ -28963,6 +29196,7 @@ ClockSnapshotVector CaptureClockSnapshots() { #include +#include #include #include @@ -37744,7 +37978,10 @@ void TracingMuxerImpl::UpdateDataSourceOnAllBackends(RegisteredDataSource& rds, rds.descriptor.set_no_flush(rds.no_flush); } rds.descriptor.set_will_notify_on_start(true); - rds.descriptor.set_will_notify_on_stop(true); + if (!rds.descriptor.has_will_notify_on_stop()) { + rds.descriptor.set_will_notify_on_stop(true); + } + rds.descriptor.set_handles_incremental_state_clear(true); rds.descriptor.set_id(rds.static_state->id); if (is_registered) { @@ -39812,6 +40049,13 @@ void Track::Serialize(protos::pbzero::TrackDescriptor* desc) const { desc->AppendRawProtoBytes(bytes.data(), bytes.size()); } +// static +Track Track::ThreadScoped(const void* ptr, Track parent) { + if (parent.uuid == 0) + return Track::FromPointer(ptr, ThreadTrack::Current()); + return Track::FromPointer(ptr, parent); +} + protos::gen::TrackDescriptor ProcessTrack::Serialize() const { auto desc = Track::Serialize(); auto pd = desc.mutable_process(); @@ -39874,8 +40118,13 @@ void ThreadTrack::Serialize(protos::pbzero::TrackDescriptor* desc) const { protos::gen::TrackDescriptor CounterTrack::Serialize() const { auto desc = Track::Serialize(); - desc.set_name(name_); auto* counter = desc.mutable_counter(); + if (static_name_) { + desc.set_static_name(static_name_.value); + } else { + desc.set_name(dynamic_name_.value); + } + if (category_) counter->add_categories(category_); if (unit_ != perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED) @@ -39975,18 +40224,6 @@ void TrackRegistry::UpdateTrack(Track track, tracks_[track.uuid] = std::move(serialized_desc); } -void TrackRegistry::UpdateTrackImpl( - Track track, - std::function fill_function) { - constexpr size_t kInitialSliceSize = 32; - constexpr size_t kMaximumSliceSize = 4096; - protozero::HeapBuffered new_descriptor( - kInitialSliceSize, kMaximumSliceSize); - fill_function(new_descriptor.get()); - auto serialized_desc = new_descriptor.SerializeAsString(); - UpdateTrack(track, serialized_desc); -} - void TrackRegistry::EraseTrack(Track track) { std::lock_guard lock(mutex_); tracks_.erase(track.uuid); @@ -40394,7 +40631,11 @@ void TrackEventStateTracker::UpdateIncrementalState( track.index = static_cast(session_state->tracks.size() + 1); track.uuid = track_descriptor.uuid(); - track.name = track_descriptor.name().ToStdString(); + if (track_descriptor.has_name()) { + track.name = track_descriptor.name().ToStdString(); + } else if (track_descriptor.has_static_name()) { + track.name = track_descriptor.static_name().ToStdString(); + } track.pid = 0; track.tid = 0; if (track_descriptor.has_process()) { @@ -40516,6 +40757,8 @@ enum class PerfettoStatsdAtom { // Checkpoints inside perfetto_cmd before tracing is finished. kTraceBegin = 1, kBackgroundTraceBegin = 2, + kCloneTraceBegin = 55, + kCloneTriggerTraceBegin = 56, kOnConnect = 3, // Guardrails inside perfetto_cmd before tracing is finished. @@ -40559,6 +40802,7 @@ enum class PerfettoStatsdAtom { kTracedEnableTracingOobTargetBuffer = 48, kTracedEnableTracingInvalidTriggerMode = 52, kTracedEnableTracingInvalidBrFilename = 54, + kTracedEnableTracingFailedSessionSemaphoreCheck = 57, // Checkpoints inside perfetto_cmd after tracing has finished. kOnTracingDisabled = 4, @@ -40594,7 +40838,7 @@ enum class PerfettoStatsdAtom { // longer supports uploading traces using Dropbox. // reserved 5, 6, 7; - // Contained status of guardrail state initalization and upload limit in + // Contained status of guardrail state initialization and upload limit in // perfetto_cmd. Removed as perfetto no longer manages stateful guardrails // reserved 44, 45, 46; }; @@ -40640,6 +40884,7 @@ enum PerfettoTriggerAtom { #define SRC_ANDROID_STATS_STATSD_LOGGING_HELPER_H_ #include +#include #include #include @@ -40687,10 +40932,12 @@ void MaybeLogTriggerEvents(PerfettoTriggerAtom atom, // gen_amalgamated expanded: #include "src/android_stats/statsd_logging_helper.h" +#include #include +#include // gen_amalgamated expanded: #include "perfetto/base/build_config.h" -// gen_amalgamated expanded: #include "perfetto/base/compiler.h" +// gen_amalgamated expanded: #include "src/android_stats/perfetto_atoms.h" #if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) && \ PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) @@ -40698,8 +40945,7 @@ void MaybeLogTriggerEvents(PerfettoTriggerAtom atom, // gen_amalgamated expanded: #include "src/android_internal/statsd_logging.h" // nogncheck #endif -namespace perfetto { -namespace android_stats { +namespace perfetto::android_stats { // Make sure we don't accidentally log on non-Android tree build. Note that even // removing this ifdef still doesn't make uploads work on OS_ANDROID. @@ -40746,8 +40992,7 @@ void MaybeLogTriggerEvents(PerfettoTriggerAtom, const std::vector&) {} #endif -} // namespace android_stats -} // namespace perfetto +} // namespace perfetto::android_stats // gen_amalgamated begin source: src/base/version.cc // gen_amalgamated begin header: include/perfetto/ext/base/version.h /* @@ -40803,8 +41048,8 @@ const char* GetVersionCode(); #ifndef GEN_PERFETTO_VERSION_GEN_H_ #define GEN_PERFETTO_VERSION_GEN_H_ -#define PERFETTO_VERSION_STRING() "v44.0-94bdc3da5" -#define PERFETTO_VERSION_SCM_REVISION() "94bdc3da58ad5343e7db3c40fba76309103e342a" +#define PERFETTO_VERSION_STRING() "v46.0-7114ea53e" +#define PERFETTO_VERSION_SCM_REVISION() "7114ea53e3297191d34072cd64cf8a7be7076bb6" #endif // GEN_PERFETTO_VERSION_GEN_H_ /* @@ -42744,7 +42989,6 @@ bool PacketStreamValidator::Validate(const Slices& slices) { // gen_amalgamated expanded: #include "perfetto/ext/base/utils.h" #include -#include #include namespace perfetto { @@ -42766,6 +43010,11 @@ namespace base { // tsl::robin_map: 931,403,397 ns 243.622M insertions/s // absl::flat_hash_map: 998,013,459 ns 227.379M insertions/s // FollyF14FastMap: 1,181,480,602 ns 192.074M insertions/s +// +// TODO(primiano): the table regresses for heavy insert+erase workloads since we +// don't clean up tombstones outside of resizes. In the limit, the entire +// table's capacity is made up of values/tombstones, so each search has to +// exhaustively scan the full capacity. // The structs below define the probing algorithm used to probe slots upon a // collision. They are guaranteed to visit all slots as our table size is always @@ -45319,6 +45568,7 @@ class CircularQueue { // gen_amalgamated expanded: #include "perfetto/base/time.h" // gen_amalgamated expanded: #include "perfetto/ext/base/circular_queue.h" // gen_amalgamated expanded: #include "perfetto/ext/base/periodic_task.h" +// gen_amalgamated expanded: #include "perfetto/ext/base/string_view.h" // gen_amalgamated expanded: #include "perfetto/ext/base/uuid.h" // gen_amalgamated expanded: #include "perfetto/ext/base/weak_ptr.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/basic_types.h" @@ -45498,7 +45748,7 @@ class TracingServiceImpl : public TracingService { ~ConsumerEndpointImpl() override; void NotifyOnTracingDisabled(const std::string& error); - void NotifyCloneSnapshotTrigger(); + void NotifyCloneSnapshotTrigger(const std::string& trigger_name); // TracingService::ConsumerEndpoint implementation. void EnableTracing(const TraceConfig&, base::ScopedFile) override; @@ -45638,10 +45888,10 @@ class TracingServiceImpl : public TracingService { ConsumerEndpoint::FlushCallback, FlushFlags); void FlushAndDisableTracing(TracingSessionID); - void FlushAndCloneSession(ConsumerEndpointImpl*, - TracingSessionID, - bool skip_filter, - bool for_bugreport); + base::Status FlushAndCloneSession(ConsumerEndpointImpl*, + TracingSessionID, + bool skip_filter, + bool for_bugreport); // Starts reading the internal tracing buffers from the tracing session `tsid` // and sends them to `*consumer` (which must be != nullptr). @@ -46031,6 +46281,8 @@ class TracingServiceImpl : public TracingService { TracingServiceImpl(const TracingServiceImpl&) = delete; TracingServiceImpl& operator=(const TracingServiceImpl&) = delete; + bool IsInitiatorPrivileged(const TracingSession&); + DataSourceInstance* SetupDataSource(const TraceConfig::DataSource&, const TraceConfig::ProducerConfig&, const RegisteredDataSource&, @@ -46263,6 +46515,7 @@ class TracingServiceImpl : public TracingService { #include #include #include +#include #include // gen_amalgamated expanded: #include "perfetto/base/time.h" // gen_amalgamated expanded: #include "perfetto/ext/tracing/core/client_identity.h" @@ -46734,8 +46987,6 @@ void TracingServiceImpl::DisconnectConsumer(ConsumerEndpointImpl* consumer) { PERFETTO_DLOG("Consumer %p disconnected", reinterpret_cast(consumer)); PERFETTO_DCHECK(consumers_.count(consumer)); - // TODO(primiano) : Check that this is safe (what happens if there are - // ReadBuffers() calls posted in the meantime? They need to become noop). if (consumer->tracing_session_id_) FreeBuffers(consumer->tracing_session_id_); // Will also DisableTracing(). consumers_.erase(consumer); @@ -47017,6 +47268,57 @@ base::Status TracingServiceImpl::EnableTracing(ConsumerEndpointImpl* consumer, } } + if (!cfg.session_semaphores().empty()) { + struct SemaphoreSessionsState { + uint64_t smallest_max_other_session_count = + std::numeric_limits::max(); + uint64_t session_count = 0; + }; + // For each semaphore, compute the number of active sessions and the + // MIN(limit). + std::unordered_map + sem_to_sessions_state; + for (const auto& id_and_session : tracing_sessions_) { + const auto& session = id_and_session.second; + if (session.state == TracingSession::CLONED_READ_ONLY || + session.state == TracingSession::DISABLED) { + // Don't consider cloned or disabled sessions in checks. + continue; + } + for (const auto& sem : session.config.session_semaphores()) { + auto& sessions_state = sem_to_sessions_state[sem.name()]; + sessions_state.smallest_max_other_session_count = + std::min(sessions_state.smallest_max_other_session_count, + sem.max_other_session_count()); + sessions_state.session_count++; + } + } + + // Check if any of the semaphores declared by the config clashes with any of + // the currently active semaphores. + for (const auto& semaphore : cfg.session_semaphores()) { + auto it = sem_to_sessions_state.find(semaphore.name()); + if (it == sem_to_sessions_state.end()) { + continue; + } + uint64_t max_other_session_count = + std::min(semaphore.max_other_session_count(), + it->second.smallest_max_other_session_count); + if (it->second.session_count > max_other_session_count) { + MaybeLogUploadEvent( + cfg, uuid, + PerfettoStatsdAtom:: + kTracedEnableTracingFailedSessionSemaphoreCheck); + return PERFETTO_SVC_ERR( + "Semaphore \"%s\" exceeds maximum allowed other session count " + "(%" PRIu64 " > min(%" PRIu64 ", %" PRIu64 "))", + semaphore.name().c_str(), it->second.session_count, + semaphore.max_other_session_count(), + it->second.smallest_max_other_session_count); + } + } + } + if (cfg.enable_extra_guardrails()) { // unique_session_name can be empty const std::string& name = cfg.unique_session_name(); @@ -47928,13 +48230,14 @@ void TracingServiceImpl::ActivateTriggers( tracing_session.config, tracing_session.trace_uuid, PerfettoStatsdAtom::kTracedTriggerCloneSnapshot, iter->name()); task_runner_->PostDelayedTask( - [weak_this, tsid] { + [weak_this, tsid, trigger_name = iter->name()] { if (!weak_this) return; auto* tsess = weak_this->GetTracingSession(tsid); if (!tsess || !tsess->consumer_maybe_null) return; - tsess->consumer_maybe_null->NotifyCloneSnapshotTrigger(); + tsess->consumer_maybe_null->NotifyCloneSnapshotTrigger( + trigger_name); }, iter->stop_delay_ms()); break; @@ -48119,7 +48422,7 @@ void TracingServiceImpl::NotifyFlushDoneForProducer( it++; } } // for (pending_flushes) - } // for (tracing_session) + } // for (tracing_session) } void TracingServiceImpl::OnFlushTimeout(TracingSessionID tsid, @@ -48666,7 +48969,7 @@ std::vector TracingServiceImpl::ReadBuffers( did_hit_threshold = packets_bytes >= threshold; packets.emplace_back(std::move(packet)); } // for(packets...) - } // for(buffers...) + } // for(buffers...) *has_more = did_hit_threshold; @@ -48881,10 +49184,23 @@ void TracingServiceImpl::FreeBuffers(TracingSessionID tsid) { bool is_long_trace = (tracing_session->config.write_into_file() && tracing_session->config.file_write_period_ms() < kMillisPerDay); + auto pending_clones = std::move(tracing_session->pending_clones); tracing_sessions_.erase(tsid); tracing_session = nullptr; UpdateMemoryGuardrail(); + for (const auto& id_to_clone_op : pending_clones) { + const PendingClone& clone_op = id_to_clone_op.second; + if (clone_op.weak_consumer) { + task_runner_->PostTask([weak_consumer = clone_op.weak_consumer] { + if (weak_consumer) { + weak_consumer->consumer_->OnSessionCloned( + {false, "Original session ended", {}}); + } + }); + } + } + PERFETTO_LOG("Tracing session %" PRIu64 " ended, total sessions:%zu", tsid, tracing_sessions_.size()); #if PERFETTO_BUILDFLAG(PERFETTO_ANDROID_BUILD) && \ @@ -49063,6 +49379,37 @@ void TracingServiceImpl::UnregisterDataSource(ProducerID producer_id, name.c_str(), producer_id); } +bool TracingServiceImpl::IsInitiatorPrivileged( + const TracingSession& tracing_session) { +#if PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) + if (tracing_session.consumer_uid == 1066 /* AID_STATSD */ && + tracing_session.config.statsd_metadata().triggering_config_uid() != + 2000 /* AID_SHELL */ + && tracing_session.config.statsd_metadata().triggering_config_uid() != + 0 /* AID_ROOT */) { + // StatsD can be triggered either by shell, root or an app that has DUMP and + // USAGE_STATS permission. When triggered by shell or root, we do not want + // to consider the trace a trusted system trace, as it was initiated by the + // user. Otherwise, it has to come from an app with DUMP and + // PACKAGE_USAGE_STATS, which has to be preinstalled and trusted by the + // system. + // Check for shell / root: https://bit.ly/3b7oZNi + // Check for DUMP or PACKAGE_USAGE_STATS: https://bit.ly/3ep0NrR + return true; + } + if (tracing_session.consumer_uid == 1000 /* AID_SYSTEM */) { + // AID_SYSTEM is considered a privileged initiator so that system_server can + // profile apps that are not profileable by shell. Other AID_SYSTEM + // processes are not allowed by SELinux to connect to the consumer socket or + // to exec perfetto. + return true; + } +#else + base::ignore_result(tracing_session); +#endif + return false; +} + TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource( const TraceConfig::DataSource& cfg_data_source, const TraceConfig::ProducerConfig& producer_config, @@ -49139,19 +49486,7 @@ TracingServiceImpl::DataSourceInstance* TracingServiceImpl::SetupDataSource( ds_config.set_stop_timeout_ms(tracing_session->data_source_stop_timeout_ms()); ds_config.set_enable_extra_guardrails( tracing_session->config.enable_extra_guardrails()); - if (tracing_session->consumer_uid == 1066 /* AID_STATSD */ && - tracing_session->config.statsd_metadata().triggering_config_uid() != - 2000 /* AID_SHELL */ - && tracing_session->config.statsd_metadata().triggering_config_uid() != - 0 /* AID_ROOT */) { - // StatsD can be triggered either by shell, root or an app that has DUMP and - // USAGE_STATS permission. When triggered by shell or root, we do not want - // to consider the trace a trusted system trace, as it was initiated by the - // user. Otherwise, it has to come from an app with DUMP and - // PACKAGE_USAGE_STATS, which has to be preinstalled and trusted by the - // system. - // Check for shell / root: https://bit.ly/3b7oZNi - // Check for DUMP or PACKAGE_USAGE_STATS: https://bit.ly/3ep0NrR + if (IsInitiatorPrivileged(*tracing_session)) { ds_config.set_session_initiator( DataSourceConfig::SESSION_INITIATOR_TRUSTED_SYSTEM); } else { @@ -49435,9 +49770,9 @@ void TracingServiceImpl::UpdateMemoryGuardrail() { // Sum up all the cloned traced buffers. for (const auto& id_to_ts : tracing_sessions_) { const TracingSession& ts = id_to_ts.second; - for (const auto& id_to_pending_clone : ts.pending_clones) { - const PendingClone& pending_clone = id_to_pending_clone.second; - for (const std::unique_ptr& buf : pending_clone.buffers) { + for (const auto& id_to_clone_op : ts.pending_clones) { + const PendingClone& clone_op = id_to_clone_op.second; + for (const std::unique_ptr& buf : clone_op.buffers) { if (buf) { total_buffer_bytes += buf->size(); } @@ -49710,8 +50045,8 @@ TraceStats TracingServiceImpl::GetTraceStats(TracingSession* tracing_session) { wri_stats->add_chunk_payload_histogram_sum(hist.GetBucketSum(i)); } } // for each sequence (writer). - } // for each buffer. - } // if (!disable_chunk_usage_histograms) + } // for each buffer. + } // if (!disable_chunk_usage_histograms) return trace_stats; } @@ -49776,6 +50111,13 @@ void TracingServiceImpl::EmitSystemInfo(std::vector* packets) { } else { PERFETTO_ELOG("Unable to read ro.build.version.sdk"); } + + std::string soc_model_value = base::GetAndroidProp("ro.soc.model"); + if (!soc_model_value.empty()) { + info->set_android_soc_model(soc_model_value); + } else { + PERFETTO_ELOG("Unable to read ro.soc.model"); + } #endif // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID) packet->set_trusted_uid(static_cast(uid_)); packet->set_trusted_packet_sequence_id(kServicePacketSequenceID); @@ -49927,10 +50269,11 @@ size_t TracingServiceImpl::PurgeExpiredAndCountTriggerInWindow( return trigger_count; } -void TracingServiceImpl::FlushAndCloneSession(ConsumerEndpointImpl* consumer, - TracingSessionID tsid, - bool skip_trace_filter, - bool for_bugreport) { +base::Status TracingServiceImpl::FlushAndCloneSession( + ConsumerEndpointImpl* consumer, + TracingSessionID tsid, + bool skip_trace_filter, + bool for_bugreport) { PERFETTO_DCHECK_THREAD(thread_checker_); auto clone_target = FlushFlags::CloneTarget::kUnknown; @@ -49943,9 +50286,8 @@ void TracingServiceImpl::FlushAndCloneSession(ConsumerEndpointImpl* consumer, PERFETTO_LOG("Looking for sessions for bugreport"); TracingSession* session = FindTracingSessionWithMaxBugreportScore(); if (!session) { - consumer->consumer_->OnSessionCloned( - {false, "No tracing sessions eligible for bugreport found", {}}); - return; + return base::ErrStatus( + "No tracing sessions eligible for bugreport found"); } tsid = session->id; clone_target = FlushFlags::CloneTarget::kBugreport; @@ -49957,9 +50299,14 @@ void TracingServiceImpl::FlushAndCloneSession(ConsumerEndpointImpl* consumer, TracingSession* session = GetTracingSession(tsid); if (!session) { - consumer->consumer_->OnSessionCloned( - {false, "Tracing session not found", {}}); - return; + return base::ErrStatus("Tracing session not found"); + } + + // Skip the UID check for sessions marked with a bugreport_score > 0. + // Those sessions, by design, can be stolen by any other consumer for the + // sake of creating snapshots for bugreports. + if (!session->IsCloneAllowed(consumer->uid_)) { + return PERFETTO_SVC_ERR("Not allowed to clone a session from another UID"); } // If any of the buffers are marked as clear_before_clone, reset them before @@ -49991,9 +50338,8 @@ void TracingServiceImpl::FlushAndCloneSession(ConsumerEndpointImpl* consumer, // We cannot leave the original tracing session buffer-less as it would // cause crashes when data sources commit new data. buf = std::move(old_buf); - consumer->consumer_->OnSessionCloned( - {false, "Buffer allocation failed while attempting to clone", {}}); - return; + return base::ErrStatus( + "Buffer allocation failed while attempting to clone"); } } @@ -50039,6 +50385,8 @@ void TracingServiceImpl::FlushAndCloneSession(ConsumerEndpointImpl* consumer, FlushFlags(FlushFlags::Initiator::kTraced, FlushFlags::Reason::kTraceClone, clone_target)); } + + return base::OkStatus(); } std::map> @@ -50176,13 +50524,6 @@ base::Status TracingServiceImpl::FinishCloneSession( "The consumer is already attached to another tracing session"); } - // Skip the UID check for sessions marked with a bugreport_score > 0. - // Those sessions, by design, can be stolen by any other consumer for the - // sake of creating snapshots for bugreports. - if (!src->IsCloneAllowed(consumer->uid_)) { - return PERFETTO_SVC_ERR("Not allowed to clone a session from another UID"); - } - std::vector buf_ids = buffer_ids_.AllocateMultiple(buf_snaps.size()); if (buf_ids.size() != buf_snaps.size()) { @@ -50485,13 +50826,15 @@ void TracingServiceImpl::ConsumerEndpointImpl::OnAllDataSourcesStarted() { observable_events->set_all_data_sources_started(true); } -void TracingServiceImpl::ConsumerEndpointImpl::NotifyCloneSnapshotTrigger() { +void TracingServiceImpl::ConsumerEndpointImpl::NotifyCloneSnapshotTrigger( + const std::string& trigger_name) { if (!(observable_events_mask_ & ObservableEvents::TYPE_CLONE_TRIGGER_HIT)) { return; } auto* observable_events = AddObservableEvents(); auto* clone_trig = observable_events->mutable_clone_trigger_hit(); clone_trig->set_tracing_session_id(static_cast(tracing_session_id_)); + clone_trig->set_trigger_name(trigger_name); } ObservableEvents* @@ -50621,8 +50964,12 @@ void TracingServiceImpl::ConsumerEndpointImpl::CloneSession( CloneSessionArgs args) { PERFETTO_DCHECK_THREAD(thread_checker_); // FlushAndCloneSession will call OnSessionCloned after the async flush. - service_->FlushAndCloneSession(this, tsid, args.skip_trace_filter, - args.for_bugreport); + base::Status result = service_->FlushAndCloneSession( + this, tsid, args.skip_trace_filter, args.for_bugreport); + + if (!result.ok()) { + consumer_->OnSessionCloned({false, result.message(), {}}); + } } //////////////////////////////////////////////////////////////////////////////// @@ -51118,6 +51465,7 @@ TracingService* InProcessTracingBackend::GetOrCreateService( // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" @@ -52886,6 +53234,7 @@ void EnableTracingRequest::Serialize(::protozero::Message* msg) const { // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_layers_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/protolog_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/common/protolog_common.gen.h" +// gen_amalgamated expanded: #include "protos/perfetto/config/android/pixel_modem_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/packages_list_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/network_trace_config.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/config/android/android_sdk_sysprop_guard_config.gen.h" @@ -55447,7 +55796,7 @@ namespace base { // Define the ScopedSocketHandle type. #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) -int CloseSocket(SocketHandle); // A wrapper around ::closesocket(). +int CloseSocket(SocketHandle); // A wrapper around ::closesocket(). using ScopedSocketHandle = ScopedResource(-1)>; #else diff --git a/third_party/perfetto/sdk/perfetto.h b/third_party/perfetto/sdk/perfetto.h index 72f1187a282c..972e9dbff547 100644 --- a/third_party/perfetto/sdk/perfetto.h +++ b/third_party/perfetto/sdk/perfetto.h @@ -180,7 +180,7 @@ #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 1 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 0 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0 -#elif defined(__GNUC__) // Careful: Clang also defines this! +#elif defined(__GNUC__) // Careful: Clang also defines this! #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_CLANG() 0 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_GCC() 1 #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_COMPILER_MSVC() 0 @@ -210,6 +210,12 @@ #define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_ARM64() 0 #endif +#if defined(__x86_64__) || defined(_M_X64) +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_X86_64() 1 +#else +#define PERFETTO_BUILDFLAG_DEFINE_PERFETTO_ARCH_CPU_X86_64() 0 +#endif + // perfetto_build_flags.h contains the tweakable build flags defined via GN. // - In GN builds (e.g., standalone, chromium, v8) this file is generated at // build time via the gen_rule //gn/gen_buildflags. @@ -279,6 +285,16 @@ #define PERFETTO_NULL NULL #endif +#if defined(__clang__) +#define PERFETTO_ALWAYS_INLINE __attribute__((__always_inline__)) +#define PERFETTO_NO_INLINE __attribute__((__noinline__)) +#else +// GCC is too pedantic and often fails with the error: +// "always_inline function might not be inlinable" +#define PERFETTO_ALWAYS_INLINE +#define PERFETTO_NO_INLINE +#endif + #endif // INCLUDE_PERFETTO_PUBLIC_COMPILER_H_ /* * Copyright (C) 2019 The Android Open Source Project @@ -324,16 +340,6 @@ #define PERFETTO_UNUSED #endif -#if defined(__clang__) -#define PERFETTO_ALWAYS_INLINE __attribute__((__always_inline__)) -#define PERFETTO_NO_INLINE __attribute__((__noinline__)) -#else -// GCC is too pedantic and often fails with the error: -// "always_inline function might not be inlinable" -#define PERFETTO_ALWAYS_INLINE -#define PERFETTO_NO_INLINE -#endif - #if defined(__GNUC__) || defined(__clang__) #define PERFETTO_NORETURN __attribute__((__noreturn__)) #else @@ -677,8 +683,8 @@ inline void MaybeSerializeLastLogsForCrashReporting() {} __LINE__, ##__VA_ARGS__); \ } while (0) #elif defined(PERFETTO_DISABLE_LOG) -#define PERFETTO_XLOG(level, fmt, ...) ::perfetto::base::ignore_result(level, \ - fmt, ##__VA_ARGS__) +#define PERFETTO_XLOG(level, fmt, ...) \ + ::perfetto::base::ignore_result(level, fmt, ##__VA_ARGS__) #else #define PERFETTO_XLOG(level, fmt, ...) \ ::perfetto::base::LogMessage(level, ::perfetto::base::Basename(__FILE__), \ @@ -814,6 +820,12 @@ inline void MaybeSerializeLastLogsForCrashReporting() {} #include #endif +#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64) +#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC) +#include +#endif +#endif + namespace perfetto { namespace base { @@ -1049,6 +1061,20 @@ inline int64_t MkTime(int year, int month, int day, int h, int m, int s) { return TimeGm(&tms); } +#if PERFETTO_BUILDFLAG(PERFETTO_ARCH_CPU_X86_64) +inline uint64_t Rdtsc() { +#if PERFETTO_BUILDFLAG(PERFETTO_COMPILER_MSVC) + return static_cast(__rdtsc()); +#else + // Use inline asm for clang and gcc: rust ffi bindgen crashes in using + // intrinsics on ChromeOS. + uint64_t low, high; + __asm__ volatile("rdtsc" : "=a"(low), "=d"(high)); + return (high << 32) | low; +#endif +} +#endif + std::optional GetTimezoneOffsetMins(); } // namespace base @@ -2175,6 +2201,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag kEtwConfigFieldNumber = 125, kProtologConfigFieldNumber = 126, kAndroidInputEventConfigFieldNumber = 128, + kPixelModemConfigFieldNumber = 129, kLegacyConfigFieldNumber = 1000, kForTestingFieldNumber = 1001, }; @@ -2312,6 +2339,9 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag const std::string& android_input_event_config_raw() const { return android_input_event_config_; } void set_android_input_event_config_raw(const std::string& raw) { android_input_event_config_ = raw; _has_field_.set(128); } + const std::string& pixel_modem_config_raw() const { return pixel_modem_config_; } + void set_pixel_modem_config_raw(const std::string& raw) { pixel_modem_config_ = raw; _has_field_.set(129); } + bool has_legacy_config() const { return _has_field_[1000]; } const std::string& legacy_config() const { return legacy_config_; } void set_legacy_config(const std::string& value) { legacy_config_ = value; _has_field_.set(1000); } @@ -2357,6 +2387,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag std::string etw_config_; // [lazy=true] std::string protolog_config_; // [lazy=true] std::string android_input_event_config_; // [lazy=true] + std::string pixel_modem_config_; // [lazy=true] std::string legacy_config_{}; ::protozero::CopyablePtr for_testing_; @@ -6581,6 +6612,7 @@ namespace perfetto { namespace protos { namespace gen { class TraceConfig; +class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; class TraceConfig_AndroidReportConfig; class TraceConfig_TraceFilter; @@ -6672,6 +6704,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj using TraceFilter = TraceConfig_TraceFilter; using AndroidReportConfig = TraceConfig_AndroidReportConfig; using CmdTraceStartDelay = TraceConfig_CmdTraceStartDelay; + using SessionSemaphore = TraceConfig_SessionSemaphore; using LockdownModeOperation = TraceConfig_LockdownModeOperation; static constexpr auto LOCKDOWN_UNCHANGED = TraceConfig_LockdownModeOperation_LOCKDOWN_UNCHANGED; static constexpr auto LOCKDOWN_CLEAR = TraceConfig_LockdownModeOperation_LOCKDOWN_CLEAR; @@ -6724,6 +6757,7 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj kTraceFilterFieldNumber = 33, kAndroidReportConfigFieldNumber = 34, kCmdTraceStartDelayFieldNumber = 35, + kSessionSemaphoresFieldNumber = 39, }; TraceConfig(); @@ -6885,6 +6919,12 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj const TraceConfig_CmdTraceStartDelay& cmd_trace_start_delay() const { return *cmd_trace_start_delay_; } TraceConfig_CmdTraceStartDelay* mutable_cmd_trace_start_delay() { _has_field_.set(35); return cmd_trace_start_delay_.get(); } + const std::vector& session_semaphores() const { return session_semaphores_; } + std::vector* mutable_session_semaphores() { return &session_semaphores_; } + int session_semaphores_size() const; + void clear_session_semaphores(); + TraceConfig_SessionSemaphore* add_session_semaphores(); + private: std::vector buffers_; std::vector data_sources_; @@ -6920,12 +6960,54 @@ class PERFETTO_EXPORT_COMPONENT TraceConfig : public ::protozero::CppMessageObj ::protozero::CopyablePtr trace_filter_; ::protozero::CopyablePtr android_report_config_; ::protozero::CopyablePtr cmd_trace_start_delay_; + std::vector session_semaphores_; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<39> _has_field_{}; + std::bitset<40> _has_field_{}; +}; + + +class PERFETTO_EXPORT_COMPONENT TraceConfig_SessionSemaphore : public ::protozero::CppMessageObj { + public: + enum FieldNumbers { + kNameFieldNumber = 1, + kMaxOtherSessionCountFieldNumber = 2, + }; + + TraceConfig_SessionSemaphore(); + ~TraceConfig_SessionSemaphore() override; + TraceConfig_SessionSemaphore(TraceConfig_SessionSemaphore&&) noexcept; + TraceConfig_SessionSemaphore& operator=(TraceConfig_SessionSemaphore&&); + TraceConfig_SessionSemaphore(const TraceConfig_SessionSemaphore&); + TraceConfig_SessionSemaphore& operator=(const TraceConfig_SessionSemaphore&); + bool operator==(const TraceConfig_SessionSemaphore&) const; + bool operator!=(const TraceConfig_SessionSemaphore& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_name() const { return _has_field_[1]; } + const std::string& name() const { return name_; } + void set_name(const std::string& value) { name_ = value; _has_field_.set(1); } + + bool has_max_other_session_count() const { return _has_field_[2]; } + uint64_t max_other_session_count() const { return max_other_session_count_; } + void set_max_other_session_count(uint64_t value) { max_other_session_count_ = value; _has_field_.set(2); } + + private: + std::string name_{}; + uint64_t max_other_session_count_{}; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<3> _has_field_{}; }; @@ -8986,8 +9068,8 @@ class PERFETTO_EXPORT_COMPONENT StartupTracingSession { virtual void AbortBlocking() = 0; }; -PERFETTO_ALWAYS_INLINE inline std::unique_ptr -Tracing::NewTrace(BackendType backend) { +PERFETTO_ALWAYS_INLINE inline std::unique_ptr Tracing::NewTrace( + BackendType backend) { // This code is inlined to allow dead-code elimination for unused consumer // implementation. The logic behind it is the following: // Nothing other than the code below references the GetInstance() method @@ -9709,13 +9791,13 @@ class AndroidCameraFrameEvent; class AndroidCameraSessionStats; class AndroidEnergyEstimationBreakdown; class AndroidGameInterventionList; -class AndroidInputEvent; class AndroidLogPacket; class AndroidSystemProperty; class BatteryCounters; class ChromeBenchmarkMetadata; class ChromeEventBundle; class ChromeMetadataPacket; +class ChromeTrigger; class ClockSnapshot; class CpuInfo; class DeobfuscationMapping; @@ -9742,6 +9824,8 @@ class NetworkPacketEvent; class PackagesList; class PerfSample; class PerfettoMetatrace; +class PixelModemEvents; +class PixelModemTokenDatabase; class PowerRails; class ProcessDescriptor; class ProcessStats; @@ -9781,6 +9865,7 @@ class V8RegExpCode; class V8WasmCode; class VulkanApiEvent; class VulkanMemoryEvent; +class WinscopeExtensions; } // Namespace pbzero. } // Namespace protos. } // Namespace perfetto. @@ -9865,6 +9950,8 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_trigger() const { return at<46>().valid(); } ::protozero::ConstBytes trigger() const { return at<46>().as_bytes(); } + bool has_chrome_trigger() const { return at<109>().valid(); } + ::protozero::ConstBytes chrome_trigger() const { return at<109>().as_bytes(); } bool has_packages_list() const { return at<47>().valid(); } ::protozero::ConstBytes packages_list() const { return at<47>().as_bytes(); } bool has_chrome_benchmark_metadata() const { return at<48>().valid(); } @@ -9961,6 +10048,8 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_protolog_viewer_config() const { return at<105>().valid(); } ::protozero::ConstBytes protolog_viewer_config() const { return at<105>().as_bytes(); } + bool has_winscope_extensions() const { return at<112>().valid(); } + ::protozero::ConstBytes winscope_extensions() const { return at<112>().as_bytes(); } bool has_etw_events() const { return at<95>().valid(); } ::protozero::ConstBytes etw_events() const { return at<95>().as_bytes(); } bool has_v8_js_code() const { return at<99>().valid(); } @@ -9973,10 +10062,12 @@ class TracePacket_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_v8_code_move() const { return at<103>().valid(); } ::protozero::ConstBytes v8_code_move() const { return at<103>().as_bytes(); } - bool has_android_input_event() const { return at<106>().valid(); } - ::protozero::ConstBytes android_input_event() const { return at<106>().as_bytes(); } bool has_remote_clock_sync() const { return at<107>().valid(); } ::protozero::ConstBytes remote_clock_sync() const { return at<107>().as_bytes(); } + bool has_pixel_modem_events() const { return at<110>().valid(); } + ::protozero::ConstBytes pixel_modem_events() const { return at<110>().as_bytes(); } + bool has_pixel_modem_token_database() const { return at<111>().valid(); } + ::protozero::ConstBytes pixel_modem_token_database() const { return at<111>().as_bytes(); } bool has_for_testing() const { return at<900>().valid(); } ::protozero::ConstBytes for_testing() const { return at<900>().as_bytes(); } bool has_trusted_uid() const { return at<3>().valid(); } @@ -10026,6 +10117,7 @@ class TracePacket : public ::protozero::Message { kAndroidLogFieldNumber = 39, kSystemInfoFieldNumber = 45, kTriggerFieldNumber = 46, + kChromeTriggerFieldNumber = 109, kPackagesListFieldNumber = 47, kChromeBenchmarkMetadataFieldNumber = 48, kPerfettoMetatraceFieldNumber = 49, @@ -10074,14 +10166,16 @@ class TracePacket : public ::protozero::Message { kShellHandlerMappingsFieldNumber = 97, kProtologMessageFieldNumber = 104, kProtologViewerConfigFieldNumber = 105, + kWinscopeExtensionsFieldNumber = 112, kEtwEventsFieldNumber = 95, kV8JsCodeFieldNumber = 99, kV8InternalCodeFieldNumber = 100, kV8WasmCodeFieldNumber = 101, kV8RegExpCodeFieldNumber = 102, kV8CodeMoveFieldNumber = 103, - kAndroidInputEventFieldNumber = 106, kRemoteClockSyncFieldNumber = 107, + kPixelModemEventsFieldNumber = 110, + kPixelModemTokenDatabaseFieldNumber = 111, kForTestingFieldNumber = 900, kTrustedUidFieldNumber = 3, kTrustedPacketSequenceIdFieldNumber = 10, @@ -10407,6 +10501,20 @@ class TracePacket : public ::protozero::Message { } + using FieldMetadata_ChromeTrigger = + ::protozero::proto_utils::FieldMetadata< + 109, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ChromeTrigger, + TracePacket>; + + static constexpr FieldMetadata_ChromeTrigger kChromeTrigger{}; + template T* set_chrome_trigger() { + return BeginNestedMessage(109); + } + + using FieldMetadata_PackagesList = ::protozero::proto_utils::FieldMetadata< 47, @@ -11099,6 +11207,20 @@ class TracePacket : public ::protozero::Message { } + using FieldMetadata_WinscopeExtensions = + ::protozero::proto_utils::FieldMetadata< + 112, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + WinscopeExtensions, + TracePacket>; + + static constexpr FieldMetadata_WinscopeExtensions kWinscopeExtensions{}; + template T* set_winscope_extensions() { + return BeginNestedMessage(112); + } + + using FieldMetadata_EtwEvents = ::protozero::proto_utils::FieldMetadata< 95, @@ -11183,20 +11305,6 @@ class TracePacket : public ::protozero::Message { } - using FieldMetadata_AndroidInputEvent = - ::protozero::proto_utils::FieldMetadata< - 106, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidInputEvent, - TracePacket>; - - static constexpr FieldMetadata_AndroidInputEvent kAndroidInputEvent{}; - template T* set_android_input_event() { - return BeginNestedMessage(106); - } - - using FieldMetadata_RemoteClockSync = ::protozero::proto_utils::FieldMetadata< 107, @@ -11211,6 +11319,34 @@ class TracePacket : public ::protozero::Message { } + using FieldMetadata_PixelModemEvents = + ::protozero::proto_utils::FieldMetadata< + 110, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PixelModemEvents, + TracePacket>; + + static constexpr FieldMetadata_PixelModemEvents kPixelModemEvents{}; + template T* set_pixel_modem_events() { + return BeginNestedMessage(110); + } + + + using FieldMetadata_PixelModemTokenDatabase = + ::protozero::proto_utils::FieldMetadata< + 111, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PixelModemTokenDatabase, + TracePacket>; + + static constexpr FieldMetadata_PixelModemTokenDatabase kPixelModemTokenDatabase{}; + template T* set_pixel_modem_token_database() { + return BeginNestedMessage(111); + } + + using FieldMetadata_ForTesting = ::protozero::proto_utils::FieldMetadata< 900, @@ -13564,6 +13700,8 @@ class PERFETTO_EXPORT_COMPONENT StaticString { constexpr explicit StaticString(const char* str) : value(str) {} + operator bool() const { return !!value; } + const char* value; }; @@ -13578,6 +13716,9 @@ class PERFETTO_EXPORT_COMPONENT DynamicString { length = strlen(str); } DynamicString(const char* str, size_t len) : value(str), length(len) {} + constexpr DynamicString() : value(nullptr), length(0) {} + + operator bool() const { return !!value; } const char* value; size_t length; @@ -14823,6 +14964,7 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage kUuidFieldNumber = 1, kParentUuidFieldNumber = 5, kNameFieldNumber = 2, + kStaticNameFieldNumber = 10, kProcessFieldNumber = 3, kChromeProcessFieldNumber = 6, kThreadFieldNumber = 4, @@ -14857,6 +14999,10 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage const std::string& name() const { return name_; } void set_name(const std::string& value) { name_ = value; _has_field_.set(2); } + bool has_static_name() const { return _has_field_[10]; } + const std::string& static_name() const { return static_name_; } + void set_static_name(const std::string& value) { static_name_ = value; _has_field_.set(10); } + bool has_process() const { return _has_field_[3]; } const ProcessDescriptor& process() const { return *process_; } ProcessDescriptor* mutable_process() { _has_field_.set(3); return process_.get(); } @@ -14885,6 +15031,7 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage uint64_t uuid_{}; uint64_t parent_uuid_{}; std::string name_{}; + std::string static_name_{}; ::protozero::CopyablePtr process_; ::protozero::CopyablePtr chrome_process_; ::protozero::CopyablePtr thread_; @@ -14896,7 +15043,7 @@ class PERFETTO_EXPORT_COMPONENT TrackDescriptor : public ::protozero::CppMessage // with future versions of .proto files. std::string unknown_fields_; - std::bitset<10> _has_field_{}; + std::bitset<11> _has_field_{}; }; } // namespace perfetto @@ -14935,7 +15082,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder { +class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder { public: TrackDescriptor_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TrackDescriptor_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -14946,6 +15093,8 @@ class TrackDescriptor_Decoder : public ::protozero::TypedProtoDecoder().as_uint64(); } bool has_name() const { return at<2>().valid(); } ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_static_name() const { return at<10>().valid(); } + ::protozero::ConstChars static_name() const { return at<10>().as_string(); } bool has_process() const { return at<3>().valid(); } ::protozero::ConstBytes process() const { return at<3>().as_bytes(); } bool has_chrome_process() const { return at<6>().valid(); } @@ -14967,6 +15116,7 @@ class TrackDescriptor : public ::protozero::Message { kUuidFieldNumber = 1, kParentUuidFieldNumber = 5, kNameFieldNumber = 2, + kStaticNameFieldNumber = 10, kProcessFieldNumber = 3, kChromeProcessFieldNumber = 6, kThreadFieldNumber = 4, @@ -15037,6 +15187,30 @@ class TrackDescriptor : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_StaticName = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TrackDescriptor>; + + static constexpr FieldMetadata_StaticName kStaticName{}; + void set_static_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_StaticName::kFieldId, data, size); + } + void set_static_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_StaticName::kFieldId, chars.data, chars.size); + } + void set_static_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_StaticName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + using FieldMetadata_Process = ::protozero::proto_utils::FieldMetadata< 3, @@ -15157,6 +15331,7 @@ class TrackDescriptor : public ::protozero::Message { // gen_amalgamated expanded: #include "perfetto/tracing/internal/fnv1a.h" // gen_amalgamated expanded: #include "perfetto/tracing/internal/tracing_muxer.h" // gen_amalgamated expanded: #include "perfetto/tracing/platform.h" +// gen_amalgamated expanded: #include "perfetto/tracing/string_helpers.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/trace_packet.pbzero.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.gen.h" // gen_amalgamated expanded: #include "protos/perfetto/trace/track_event/counter_descriptor.pbzero.h" @@ -15252,11 +15427,7 @@ struct PERFETTO_EXPORT_COMPONENT Track { // Construct a track using |ptr| as identifier within thread-scope. // Shorthand for `Track::FromPointer(ptr, ThreadTrack::Current())` // Usage: TRACE_EVENT_BEGIN("...", "...", perfetto::Track::ThreadScoped(this)) - static Track ThreadScoped( - const void* ptr, - Track parent = MakeThreadTrack(base::GetThreadId())) { - return Track::FromPointer(ptr, parent); - } + static Track ThreadScoped(const void* ptr, Track parent = Track()); protected: constexpr Track(uint64_t uuid_, uint64_t parent_uuid_) @@ -15337,71 +15508,92 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track { perfetto::protos::gen::CounterDescriptor::BuiltinCounterType; // |name| must outlive this object. - constexpr explicit CounterTrack(const char* name, + constexpr explicit CounterTrack(StaticString name, Track parent = MakeProcessTrack()) - : Track(internal::Fnv1a(name) ^ kCounterMagic, parent), - name_(name), - category_(nullptr) {} + : CounterTrack( + name, + perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED, + nullptr, + parent) {} + + explicit CounterTrack(DynamicString name, Track parent = MakeProcessTrack()) + : CounterTrack( + name, + perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED, + nullptr, + parent) {} // |unit_name| is a free-form description of the unit used by this counter. It // must outlive this object. - constexpr CounterTrack(const char* name, + template + constexpr CounterTrack(TrackEventName&& name, const char* unit_name, Track parent = MakeProcessTrack()) - : Track(internal::Fnv1a(name) ^ kCounterMagic, parent), - name_(name), - category_(nullptr), - unit_name_(unit_name) {} + : CounterTrack( + std::forward(name), + perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED, + unit_name, + parent) {} - constexpr CounterTrack(const char* name, + template + constexpr CounterTrack(TrackEventName&& name, Unit unit, Track parent = MakeProcessTrack()) - : Track(internal::Fnv1a(name) ^ kCounterMagic, parent), - name_(name), - category_(nullptr), - unit_(unit) {} + : CounterTrack(std::forward(name), + unit, + nullptr, + parent) {} - static constexpr CounterTrack Global(const char* name, + template + static constexpr CounterTrack Global(TrackEventName&& name, const char* unit_name) { - return CounterTrack(name, unit_name, Track()); + return CounterTrack(std::forward(name), unit_name, Track()); } - static constexpr CounterTrack Global(const char* name, Unit unit) { - return CounterTrack(name, unit, Track()); + template + static constexpr CounterTrack Global(TrackEventName&& name, Unit unit) { + return CounterTrack(std::forward(name), unit, Track()); } - static constexpr CounterTrack Global(const char* name) { - return Global(name, nullptr); + template + static constexpr CounterTrack Global(TrackEventName&& name) { + return Global(std::forward(name), nullptr); } constexpr CounterTrack set_unit(Unit unit) const { - return CounterTrack(uuid, parent_uuid, name_, category_, unit, unit_name_, - unit_multiplier_, is_incremental_, type_); + return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_, + category_, unit, unit_name_, unit_multiplier_, + is_incremental_, type_); } constexpr CounterTrack set_type(CounterType type) const { - return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name_, - unit_multiplier_, is_incremental_, type); + return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_, + category_, unit_, unit_name_, unit_multiplier_, + is_incremental_, type); } constexpr CounterTrack set_unit_name(const char* unit_name) const { - return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name, - unit_multiplier_, is_incremental_, type_); + return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_, + category_, unit_, unit_name, unit_multiplier_, + is_incremental_, type_); } constexpr CounterTrack set_unit_multiplier(int64_t unit_multiplier) const { - return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name_, - unit_multiplier, is_incremental_, type_); + return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_, + category_, unit_, unit_name_, unit_multiplier, + is_incremental_, type_); } constexpr CounterTrack set_category(const char* category) const { - return CounterTrack(uuid, parent_uuid, name_, category, unit_, unit_name_, - unit_multiplier_, is_incremental_, type_); + return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_, + category, unit_, unit_name_, unit_multiplier_, + is_incremental_, type_); } constexpr CounterTrack set_is_incremental(bool is_incremental = true) const { - return CounterTrack(uuid, parent_uuid, name_, category_, unit_, unit_name_, - unit_multiplier_, is_incremental, type_); + return CounterTrack(uuid, parent_uuid, static_name_, dynamic_name_, + category_, unit_, unit_name_, unit_multiplier_, + is_incremental, type_); } constexpr bool is_incremental() const { return is_incremental_; } @@ -15410,9 +15602,29 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track { protos::gen::TrackDescriptor Serialize() const; private: + constexpr CounterTrack(StaticString name, + Unit unit, + const char* unit_name, + Track parent) + : Track(internal::Fnv1a(name.value) ^ kCounterMagic, parent), + static_name_(name), + category_(nullptr), + unit_(unit), + unit_name_(unit_name) {} + CounterTrack(DynamicString name, + Unit unit, + const char* unit_name, + Track parent) + : Track(internal::Fnv1a(name.value, name.length) ^ kCounterMagic, parent), + static_name_(nullptr), + dynamic_name_(name), + category_(nullptr), + unit_(unit), + unit_name_(unit_name) {} constexpr CounterTrack(uint64_t uuid_, uint64_t parent_uuid_, - const char* name, + StaticString static_name, + DynamicString dynamic_name, const char* category, Unit unit, const char* unit_name, @@ -15420,7 +15632,8 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track { bool is_incremental, CounterType type) : Track(uuid_, parent_uuid_), - name_(name), + static_name_(static_name), + dynamic_name_(dynamic_name), category_(category), unit_(unit), unit_name_(unit_name), @@ -15428,7 +15641,8 @@ class PERFETTO_EXPORT_COMPONENT CounterTrack : public Track { is_incremental_(is_incremental), type_(type) {} - const char* const name_; + StaticString static_name_; + DynamicString dynamic_name_; const char* const category_; Unit unit_ = perfetto::protos::pbzero::CounterDescriptor::UNIT_UNSPECIFIED; const char* const unit_name_ = nullptr; @@ -15464,18 +15678,6 @@ class PERFETTO_EXPORT_COMPONENT TrackRegistry { void EraseTrack(Track); - // Store metadata for |track| in the registry. |fill_function| is called - // synchronously to record additional properties for the track. - template - void UpdateTrack( - const TrackType& track, - std::function fill_function) { - UpdateTrackImpl(track, [&](protos::pbzero::TrackDescriptor* desc) { - track.Serialize(desc); - fill_function(desc); - }); - } - // This variant lets the user supply a serialized track descriptor directly. void UpdateTrack(Track, const std::string& serialized_desc); @@ -15512,10 +15714,6 @@ class PERFETTO_EXPORT_COMPONENT TrackRegistry { protozero::MessageHandle packet); private: - void UpdateTrackImpl( - Track, - std::function fill_function); - std::mutex mutex_; std::map tracks_; @@ -15554,6 +15752,7 @@ enum BuiltinClock : int32_t { BUILTIN_CLOCK_MONOTONIC_COARSE = 4, BUILTIN_CLOCK_MONOTONIC_RAW = 5, BUILTIN_CLOCK_BOOTTIME = 6, + BUILTIN_CLOCK_TSC = 9, BUILTIN_CLOCK_MAX_ID = 63, }; @@ -15585,6 +15784,9 @@ const char* BuiltinClock_Name(::perfetto::protos::pbzero::BuiltinClock value) { case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_BOOTTIME: return "BUILTIN_CLOCK_BOOTTIME"; + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_TSC: + return "BUILTIN_CLOCK_TSC"; + case ::perfetto::protos::pbzero::BuiltinClock::BUILTIN_CLOCK_MAX_ID: return "BUILTIN_CLOCK_MAX_ID"; } @@ -15642,7 +15844,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class InternedData_Decoder : public ::protozero::TypedProtoDecoder { +class InternedData_Decoder : public ::protozero::TypedProtoDecoder { public: InternedData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit InternedData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -15705,6 +15907,14 @@ class InternedData_Decoder : public ::protozero::TypedProtoDecoder protolog_string_args() const { return GetRepeated<::protozero::ConstBytes>(36); } bool has_protolog_stacktrace() const { return at<37>().valid(); } ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> protolog_stacktrace() const { return GetRepeated<::protozero::ConstBytes>(37); } + bool has_viewcapture_package_name() const { return at<38>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_package_name() const { return GetRepeated<::protozero::ConstBytes>(38); } + bool has_viewcapture_window_name() const { return at<39>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_window_name() const { return GetRepeated<::protozero::ConstBytes>(39); } + bool has_viewcapture_view_id() const { return at<40>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_view_id() const { return GetRepeated<::protozero::ConstBytes>(40); } + bool has_viewcapture_class_name() const { return at<41>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> viewcapture_class_name() const { return GetRepeated<::protozero::ConstBytes>(41); } }; class InternedData : public ::protozero::Message { @@ -15740,6 +15950,10 @@ class InternedData : public ::protozero::Message { kV8IsolateFieldNumber = 35, kProtologStringArgsFieldNumber = 36, kProtologStacktraceFieldNumber = 37, + kViewcapturePackageNameFieldNumber = 38, + kViewcaptureWindowNameFieldNumber = 39, + kViewcaptureViewIdFieldNumber = 40, + kViewcaptureClassNameFieldNumber = 41, }; static constexpr const char* GetName() { return ".perfetto.protos.InternedData"; } @@ -16149,6 +16363,62 @@ class InternedData : public ::protozero::Message { return BeginNestedMessage(37); } + + using FieldMetadata_ViewcapturePackageName = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_ViewcapturePackageName kViewcapturePackageName{}; + template T* add_viewcapture_package_name() { + return BeginNestedMessage(38); + } + + + using FieldMetadata_ViewcaptureWindowName = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_ViewcaptureWindowName kViewcaptureWindowName{}; + template T* add_viewcapture_window_name() { + return BeginNestedMessage(39); + } + + + using FieldMetadata_ViewcaptureViewId = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_ViewcaptureViewId kViewcaptureViewId{}; + template T* add_viewcapture_view_id() { + return BeginNestedMessage(40); + } + + + using FieldMetadata_ViewcaptureClassName = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InternedString, + InternedData>; + + static constexpr FieldMetadata_ViewcaptureClassName kViewcaptureClassName{}; + template T* add_viewcapture_class_name() { + return BeginNestedMessage(41); + } + }; } // Namespace. @@ -18366,7 +18636,8 @@ template <> struct TraceTimestampTraits { static inline TraceTimestamp ConvertTimestampToTraceTimeNs( const uint64_t& timestamp) { - return {static_cast(internal::TrackEventInternal::GetClockId()), timestamp}; + return {static_cast(internal::TrackEventInternal::GetClockId()), + timestamp}; } }; @@ -18398,14 +18669,15 @@ static constexpr bool IsValidNormalTrack() { // Because the user can use arbitrary timestamp types, we can't compare against // any known base type here. Instead, we check that a track or a trace lambda // isn't being interpreted as a timestamp. -template >::ConvertTimestampToTraceTimeNs(std::declval())), - typename NotTrackCheck = - typename std::enable_if()>::type, - typename NotLambdaCheck = - typename std::enable_if()>::type> +template < + typename T, + typename CanBeConvertedToNsCheck = + decltype(::perfetto::TraceTimestampTraits>::ConvertTimestampToTraceTimeNs(std::declval())), + typename NotTrackCheck = + typename std::enable_if()>::type, + typename NotLambdaCheck = + typename std::enable_if()>::type> static constexpr bool IsValidTimestamp() { return true; } @@ -18618,14 +18890,13 @@ class TrackEventDataSource } static void Flush() { - Base::template Trace([](typename Base::TraceContext ctx) { ctx.Flush(); }); + Base::Trace([](typename Base::TraceContext ctx) { ctx.Flush(); }); } // Determine if *any* tracing category is enabled. static bool IsEnabled() { bool enabled = false; - Base::template CallIfEnabled( - [&](uint32_t /*instances*/) { enabled = true; }); + Base::CallIfEnabled([&](uint32_t /*instances*/) { enabled = true; }); return enabled; } @@ -18639,7 +18910,7 @@ class TrackEventDataSource static bool IsDynamicCategoryEnabled( const DynamicCategory& dynamic_category) { bool enabled = false; - Base::template Trace([&](typename Base::TraceContext ctx) { + Base::Trace([&](typename Base::TraceContext ctx) { enabled = enabled || IsDynamicCategoryEnabled(&ctx, dynamic_category); }); return enabled; @@ -18786,34 +19057,13 @@ class TrackEventDataSource const protos::gen::TrackDescriptor& desc) { PERFETTO_DCHECK(track.uuid == desc.uuid()); TrackRegistry::Get()->UpdateTrack(track, desc.SerializeAsString()); - Base::template Trace([&](typename Base::TraceContext ctx) { + Base::Trace([&](typename Base::TraceContext ctx) { TrackEventInternal::WriteTrackDescriptor( track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(), *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime()); }); } - // DEPRECATED. Only kept for backwards compatibility. - static void SetTrackDescriptor( - const Track& track, - std::function callback) { - SetTrackDescriptorImpl(track, std::move(callback)); - } - - // DEPRECATED. Only kept for backwards compatibility. - static void SetProcessDescriptor( - std::function callback, - const ProcessTrack& track = ProcessTrack::Current()) { - SetTrackDescriptorImpl(std::move(track), std::move(callback)); - } - - // DEPRECATED. Only kept for backwards compatibility. - static void SetThreadDescriptor( - std::function callback, - const ThreadTrack& track = ThreadTrack::Current()) { - SetTrackDescriptorImpl(std::move(track), std::move(callback)); - } - static void EraseTrackDescriptor(const Track& track) { TrackRegistry::Get()->EraseTrack(track); } @@ -19337,27 +19587,13 @@ class TrackEventDataSource Lambda lambda) PERFETTO_ALWAYS_INLINE { using CatTraits = CategoryTraits; if (CatTraits::kIsDynamic) { - Base::template TraceWithInstances(instances, std::move(lambda)); + Base::TraceWithInstances(instances, std::move(lambda)); } else { Base::template TraceWithInstances( instances, std::move(lambda), {CatTraits::GetStaticIndex(category)}); } } - // Records a track descriptor into the track descriptor registry and, if we - // are tracing, also mirrors the descriptor into the trace. - template - static void SetTrackDescriptorImpl( - const TrackType& track, - std::function callback) { - TrackRegistry::Get()->UpdateTrack(track, std::move(callback)); - Base::template Trace([&](typename Base::TraceContext ctx) { - TrackEventInternal::WriteTrackDescriptor( - track, ctx.tls_inst_->trace_writer.get(), ctx.GetIncrementalState(), - *ctx.GetCustomTlsState(), TrackEventInternal::GetTraceTime()); - }); - } - // Determines if the given dynamic category is enabled, first by checking the // per-trace writer cache or by falling back to computing it based on the // trace config for the given session. @@ -19519,7 +19755,10 @@ class TrackEventDataSource category)) { \ tns::TrackEvent::CallIfEnabled( \ [&](uint32_t instances) PERFETTO_NO_THREAD_SAFETY_ANALYSIS { \ - tns::TrackEvent::method(instances, category, name, ##__VA_ARGS__); \ + tns::TrackEvent::method( \ + instances, category, \ + ::perfetto::internal::DecayEventNameType(name), \ + ##__VA_ARGS__); \ }); \ } else { \ tns::TrackEvent::CallIfCategoryEnabled( \ @@ -19529,7 +19768,8 @@ class TrackEventDataSource instances, \ PERFETTO_UID( \ kCatIndex_ADD_TO_PERFETTO_DEFINE_CATEGORIES_IF_FAILS_), \ - name, ##__VA_ARGS__); \ + ::perfetto::internal::DecayEventNameType(name), \ + ##__VA_ARGS__); \ }); \ } \ } while (false) @@ -19561,7 +19801,9 @@ class TrackEventDataSource /* that the scoped event is exactly ONE line and can't escape the */ \ /* scope if used in a single line if statement. */ \ MOZ_IMPLICIT EventFinalizer(...) {} \ - ~EventFinalizer() { TRACE_EVENT_END(category); } \ + ~EventFinalizer() { \ + TRACE_EVENT_END(category); \ + } \ \ EventFinalizer(const EventFinalizer&) = delete; \ inline EventFinalizer& operator=(const EventFinalizer&) = delete; \ @@ -19780,7 +20022,9 @@ class TrackEventDataSource // Deprecated; see perfetto::Category(). #define PERFETTO_CATEGORY(name) \ - ::perfetto::Category { #name } + ::perfetto::Category { \ + #name \ + } // Internal helpers for determining if a given category is defined at build or // runtime. @@ -19998,10 +20242,9 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) { // TRACE_EVENT("category", "Name", perfetto::Track(1234), // "arg", value, "arg2", value2); // -#define TRACE_EVENT_BEGIN(category, name, ...) \ - PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD( \ - TraceForCategory, category, \ - ::perfetto::internal::DecayEventNameType(name), \ +#define TRACE_EVENT_BEGIN(category, name, ...) \ + PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD( \ + TraceForCategory, category, name, \ ::perfetto::protos::pbzero::TrackEvent::TYPE_SLICE_BEGIN, ##__VA_ARGS__) // End a slice under |category|. @@ -20012,14 +20255,12 @@ constexpr bool IsDynamicCategory(const ::perfetto::DynamicCategory&) { // Begin a slice which gets automatically closed when going out of scope. #define TRACE_EVENT(category, name, ...) \ - PERFETTO_INTERNAL_SCOPED_TRACK_EVENT( \ - category, ::perfetto::internal::DecayEventNameType(name), ##__VA_ARGS__) + PERFETTO_INTERNAL_SCOPED_TRACK_EVENT(category, name, ##__VA_ARGS__) // Emit a slice which has zero duration. -#define TRACE_EVENT_INSTANT(category, name, ...) \ - PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD( \ - TraceForCategory, category, \ - ::perfetto::internal::DecayEventNameType(name), \ +#define TRACE_EVENT_INSTANT(category, name, ...) \ + PERFETTO_INTERNAL_TRACK_EVENT_WITH_METHOD( \ + TraceForCategory, category, name, \ ::perfetto::protos::pbzero::TrackEvent::TYPE_INSTANT, ##__VA_ARGS__) // Efficiently determine if the given static or dynamic trace category or @@ -21627,6 +21868,7 @@ enum BuiltinClock : int { BUILTIN_CLOCK_MONOTONIC_COARSE = 4, BUILTIN_CLOCK_MONOTONIC_RAW = 5, BUILTIN_CLOCK_BOOTTIME = 6, + BUILTIN_CLOCK_TSC = 9, BUILTIN_CLOCK_MAX_ID = 63, }; } // namespace perfetto @@ -23312,6 +23554,7 @@ class PERFETTO_EXPORT_COMPONENT ObservableEvents_CloneTriggerHit : public ::prot public: enum FieldNumbers { kTracingSessionIdFieldNumber = 1, + kTriggerNameFieldNumber = 2, }; ObservableEvents_CloneTriggerHit(); @@ -23332,14 +23575,19 @@ class PERFETTO_EXPORT_COMPONENT ObservableEvents_CloneTriggerHit : public ::prot int64_t tracing_session_id() const { return tracing_session_id_; } void set_tracing_session_id(int64_t value) { tracing_session_id_ = value; _has_field_.set(1); } + bool has_trigger_name() const { return _has_field_[2]; } + const std::string& trigger_name() const { return trigger_name_; } + void set_trigger_name(const std::string& value) { trigger_name_ = value; _has_field_.set(2); } + private: int64_t tracing_session_id_{}; + std::string trigger_name_{}; // Allows to preserve unknown protobuf fields for compatibility // with future versions of .proto files. std::string unknown_fields_; - std::bitset<2> _has_field_{}; + std::bitset<3> _has_field_{}; }; @@ -28489,13 +28737,15 @@ class ObservableEvents : public ::protozero::Message { }; -class ObservableEvents_CloneTriggerHit_Decoder : public ::protozero::TypedProtoDecoder { +class ObservableEvents_CloneTriggerHit_Decoder : public ::protozero::TypedProtoDecoder { public: ObservableEvents_CloneTriggerHit_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit ObservableEvents_CloneTriggerHit_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} explicit ObservableEvents_CloneTriggerHit_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} bool has_tracing_session_id() const { return at<1>().valid(); } int64_t tracing_session_id() const { return at<1>().as_int64(); } + bool has_trigger_name() const { return at<2>().valid(); } + ::protozero::ConstChars trigger_name() const { return at<2>().as_string(); } }; class ObservableEvents_CloneTriggerHit : public ::protozero::Message { @@ -28503,6 +28753,7 @@ class ObservableEvents_CloneTriggerHit : public ::protozero::Message { using Decoder = ObservableEvents_CloneTriggerHit_Decoder; enum : int32_t { kTracingSessionIdFieldNumber = 1, + kTriggerNameFieldNumber = 2, }; static constexpr const char* GetName() { return ".perfetto.protos.ObservableEvents.CloneTriggerHit"; } @@ -28524,6 +28775,30 @@ class ObservableEvents_CloneTriggerHit : public ::protozero::Message { ::protozero::proto_utils::ProtoSchemaType::kInt64> ::Append(*this, field_id, value); } + + using FieldMetadata_TriggerName = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ObservableEvents_CloneTriggerHit>; + + static constexpr FieldMetadata_TriggerName kTriggerName{}; + void set_trigger_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size); + } + void set_trigger_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size); + } + void set_trigger_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } }; class ObservableEvents_DataSourceInstanceStateChange_Decoder : public ::protozero::TypedProtoDecoder { @@ -32968,6 +33243,106 @@ class PERFETTO_EXPORT_COMPONENT PackagesListConfig : public ::protozero::CppMess } // namespace gen #endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PACKAGES_LIST_CONFIG_PROTO_CPP_H_ +// gen_amalgamated begin header: gen/protos/perfetto/config/android/pixel_modem_config.gen.h +// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_CPP_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_CPP_H_ + +#include +#include +#include +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/cpp_message_obj.h" +// gen_amalgamated expanded: #include "perfetto/protozero/copyable_ptr.h" +// gen_amalgamated expanded: #include "perfetto/base/export.h" + +namespace perfetto { +namespace protos { +namespace gen { +class PixelModemConfig; +enum PixelModemConfig_EventGroup : int; +} // namespace perfetto +} // namespace protos +} // namespace gen + +namespace protozero { +class Message; +} // namespace protozero + +namespace perfetto { +namespace protos { +namespace gen { +enum PixelModemConfig_EventGroup : int { + PixelModemConfig_EventGroup_EVENT_GROUP_UNKNOWN = 0, + PixelModemConfig_EventGroup_EVENT_GROUP_LOW_BANDWIDTH = 1, + PixelModemConfig_EventGroup_EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = 2, +}; + +class PERFETTO_EXPORT_COMPONENT PixelModemConfig : public ::protozero::CppMessageObj { + public: + using EventGroup = PixelModemConfig_EventGroup; + static constexpr auto EVENT_GROUP_UNKNOWN = PixelModemConfig_EventGroup_EVENT_GROUP_UNKNOWN; + static constexpr auto EVENT_GROUP_LOW_BANDWIDTH = PixelModemConfig_EventGroup_EVENT_GROUP_LOW_BANDWIDTH; + static constexpr auto EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = PixelModemConfig_EventGroup_EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH; + static constexpr auto EventGroup_MIN = PixelModemConfig_EventGroup_EVENT_GROUP_UNKNOWN; + static constexpr auto EventGroup_MAX = PixelModemConfig_EventGroup_EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH; + enum FieldNumbers { + kEventGroupFieldNumber = 1, + kPigweedHashAllowListFieldNumber = 2, + kPigweedHashDenyListFieldNumber = 3, + }; + + PixelModemConfig(); + ~PixelModemConfig() override; + PixelModemConfig(PixelModemConfig&&) noexcept; + PixelModemConfig& operator=(PixelModemConfig&&); + PixelModemConfig(const PixelModemConfig&); + PixelModemConfig& operator=(const PixelModemConfig&); + bool operator==(const PixelModemConfig&) const; + bool operator!=(const PixelModemConfig& other) const { return !(*this == other); } + + bool ParseFromArray(const void*, size_t) override; + std::string SerializeAsString() const override; + std::vector SerializeAsArray() const override; + void Serialize(::protozero::Message*) const; + + bool has_event_group() const { return _has_field_[1]; } + PixelModemConfig_EventGroup event_group() const { return event_group_; } + void set_event_group(PixelModemConfig_EventGroup value) { event_group_ = value; _has_field_.set(1); } + + const std::vector& pigweed_hash_allow_list() const { return pigweed_hash_allow_list_; } + std::vector* mutable_pigweed_hash_allow_list() { return &pigweed_hash_allow_list_; } + int pigweed_hash_allow_list_size() const { return static_cast(pigweed_hash_allow_list_.size()); } + void clear_pigweed_hash_allow_list() { pigweed_hash_allow_list_.clear(); } + void add_pigweed_hash_allow_list(int64_t value) { pigweed_hash_allow_list_.emplace_back(value); } + int64_t* add_pigweed_hash_allow_list() { pigweed_hash_allow_list_.emplace_back(); return &pigweed_hash_allow_list_.back(); } + + const std::vector& pigweed_hash_deny_list() const { return pigweed_hash_deny_list_; } + std::vector* mutable_pigweed_hash_deny_list() { return &pigweed_hash_deny_list_; } + int pigweed_hash_deny_list_size() const { return static_cast(pigweed_hash_deny_list_.size()); } + void clear_pigweed_hash_deny_list() { pigweed_hash_deny_list_.clear(); } + void add_pigweed_hash_deny_list(int64_t value) { pigweed_hash_deny_list_.emplace_back(value); } + int64_t* add_pigweed_hash_deny_list() { pigweed_hash_deny_list_.emplace_back(); return &pigweed_hash_deny_list_.back(); } + + private: + PixelModemConfig_EventGroup event_group_{}; + std::vector pigweed_hash_allow_list_; + std::vector pigweed_hash_deny_list_; + + // Allows to preserve unknown protobuf fields for compatibility + // with future versions of .proto files. + std::string unknown_fields_; + + std::bitset<4> _has_field_{}; +}; + +} // namespace perfetto +} // namespace protos +} // namespace gen + +#endif // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_CPP_H_ // gen_amalgamated begin header: gen/protos/perfetto/config/android/protolog_config.gen.h // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PROTOLOG_CONFIG_PROTO_CPP_H_ @@ -36543,6 +36918,7 @@ class ChromeFieldTracingConfig; class ScenarioConfig; class NestedScenarioConfig; class TraceConfig; +class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; class TraceConfig_AndroidReportConfig; class TraceConfig_TraceFilter; @@ -37224,6 +37600,7 @@ namespace gen { class StressTestConfig; class StressTestConfig_WriterTiming; class TraceConfig; +class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; class TraceConfig_AndroidReportConfig; class TraceConfig_TraceFilter; @@ -38652,6 +39029,156 @@ class PackagesListConfig : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/config/android/pixel_modem_config.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_PIXEL_MODEM_CONFIG_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +namespace perfetto_pbzero_enum_PixelModemConfig { +enum EventGroup : int32_t; +} // namespace perfetto_pbzero_enum_PixelModemConfig +using PixelModemConfig_EventGroup = perfetto_pbzero_enum_PixelModemConfig::EventGroup; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +namespace perfetto_pbzero_enum_PixelModemConfig { +enum EventGroup : int32_t { + EVENT_GROUP_UNKNOWN = 0, + EVENT_GROUP_LOW_BANDWIDTH = 1, + EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = 2, +}; +} // namespace perfetto_pbzero_enum_PixelModemConfig +using PixelModemConfig_EventGroup = perfetto_pbzero_enum_PixelModemConfig::EventGroup; + + +constexpr PixelModemConfig_EventGroup PixelModemConfig_EventGroup_MIN = PixelModemConfig_EventGroup::EVENT_GROUP_UNKNOWN; +constexpr PixelModemConfig_EventGroup PixelModemConfig_EventGroup_MAX = PixelModemConfig_EventGroup::EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* PixelModemConfig_EventGroup_Name(::perfetto::protos::pbzero::PixelModemConfig_EventGroup value) { + switch (value) { + case ::perfetto::protos::pbzero::PixelModemConfig_EventGroup::EVENT_GROUP_UNKNOWN: + return "EVENT_GROUP_UNKNOWN"; + + case ::perfetto::protos::pbzero::PixelModemConfig_EventGroup::EVENT_GROUP_LOW_BANDWIDTH: + return "EVENT_GROUP_LOW_BANDWIDTH"; + + case ::perfetto::protos::pbzero::PixelModemConfig_EventGroup::EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH: + return "EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class PixelModemConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + PixelModemConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PixelModemConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PixelModemConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event_group() const { return at<1>().valid(); } + int32_t event_group() const { return at<1>().as_int32(); } + bool has_pigweed_hash_allow_list() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator pigweed_hash_allow_list() const { return GetRepeated(2); } + bool has_pigweed_hash_deny_list() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator pigweed_hash_deny_list() const { return GetRepeated(3); } +}; + +class PixelModemConfig : public ::protozero::Message { + public: + using Decoder = PixelModemConfig_Decoder; + enum : int32_t { + kEventGroupFieldNumber = 1, + kPigweedHashAllowListFieldNumber = 2, + kPigweedHashDenyListFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PixelModemConfig"; } + + + using EventGroup = ::perfetto::protos::pbzero::PixelModemConfig_EventGroup; + static inline const char* EventGroup_Name(EventGroup value) { + return ::perfetto::protos::pbzero::PixelModemConfig_EventGroup_Name(value); + } + static inline const EventGroup EVENT_GROUP_UNKNOWN = EventGroup::EVENT_GROUP_UNKNOWN; + static inline const EventGroup EVENT_GROUP_LOW_BANDWIDTH = EventGroup::EVENT_GROUP_LOW_BANDWIDTH; + static inline const EventGroup EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH = EventGroup::EVENT_GROUP_HIGH_AND_LOW_BANDWIDTH; + + using FieldMetadata_EventGroup = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + PixelModemConfig_EventGroup, + PixelModemConfig>; + + static constexpr FieldMetadata_EventGroup kEventGroup{}; + void set_event_group(PixelModemConfig_EventGroup value) { + static constexpr uint32_t field_id = FieldMetadata_EventGroup::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PigweedHashAllowList = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + PixelModemConfig>; + + static constexpr FieldMetadata_PigweedHashAllowList kPigweedHashAllowList{}; + void add_pigweed_hash_allow_list(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PigweedHashAllowList::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PigweedHashDenyList = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + PixelModemConfig>; + + static constexpr FieldMetadata_PigweedHashDenyList kPigweedHashDenyList{}; + void add_pigweed_hash_deny_list(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PigweedHashDenyList::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -48038,6 +48565,7 @@ class JavaHprofConfig; class NetworkPacketTraceConfig; class PackagesListConfig; class PerfEventConfig; +class PixelModemConfig; class ProcessStatsConfig; class ProtoLogConfig; class StatsdTracingConfig; @@ -48086,7 +48614,7 @@ const char* DataSourceConfig_SessionInitiator_Name(::perfetto::protos::pbzero::D return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder { +class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder { public: DataSourceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit DataSourceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -48163,6 +48691,8 @@ class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_android_input_event_config() const { return at<128>().valid(); } ::protozero::ConstBytes android_input_event_config() const { return at<128>().as_bytes(); } + bool has_pixel_modem_config() const { return at<129>().valid(); } + ::protozero::ConstBytes pixel_modem_config() const { return at<129>().as_bytes(); } // field legacy_config omitted because its id is too high // field for_testing omitted because its id is too high }; @@ -48207,6 +48737,7 @@ class DataSourceConfig : public ::protozero::Message { kEtwConfigFieldNumber = 125, kProtologConfigFieldNumber = 126, kAndroidInputEventConfigFieldNumber = 128, + kPixelModemConfigFieldNumber = 129, kLegacyConfigFieldNumber = 1000, kForTestingFieldNumber = 1001, }; @@ -48862,6 +49393,24 @@ class DataSourceConfig : public ::protozero::Message { } + using FieldMetadata_PixelModemConfig = + ::protozero::proto_utils::FieldMetadata< + 129, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PixelModemConfig, + DataSourceConfig>; + + static constexpr FieldMetadata_PixelModemConfig kPixelModemConfig{}; + template T* set_pixel_modem_config() { + return BeginNestedMessage(129); + } + + void set_pixel_modem_config_raw(const std::string& raw) { + return AppendBytes(129, raw.data(), raw.size()); + } + + using FieldMetadata_LegacyConfig = ::protozero::proto_utils::FieldMetadata< 1000, @@ -50008,6 +50557,7 @@ class TraceConfig_GuardrailOverrides; class TraceConfig_IncidentReportConfig; class TraceConfig_IncrementalStateConfig; class TraceConfig_ProducerConfig; +class TraceConfig_SessionSemaphore; class TraceConfig_StatsdMetadata; class TraceConfig_TraceFilter; class TraceConfig_TraceFilter_StringFilterChain; @@ -50233,7 +50783,7 @@ const char* TraceConfig_BufferConfig_FillPolicy_Name(::perfetto::protos::pbzero: return "PBZERO_UNKNOWN_ENUM_VALUE"; } -class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { +class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder { public: TraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -50306,6 +50856,8 @@ class TraceConfig_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_cmd_trace_start_delay() const { return at<35>().valid(); } ::protozero::ConstBytes cmd_trace_start_delay() const { return at<35>().as_bytes(); } + bool has_session_semaphores() const { return at<39>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> session_semaphores() const { return GetRepeated<::protozero::ConstBytes>(39); } }; class TraceConfig : public ::protozero::Message { @@ -50346,6 +50898,7 @@ class TraceConfig : public ::protozero::Message { kTraceFilterFieldNumber = 33, kAndroidReportConfigFieldNumber = 34, kCmdTraceStartDelayFieldNumber = 35, + kSessionSemaphoresFieldNumber = 39, }; static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig"; } @@ -50361,6 +50914,7 @@ class TraceConfig : public ::protozero::Message { using TraceFilter = ::perfetto::protos::pbzero::TraceConfig_TraceFilter; using AndroidReportConfig = ::perfetto::protos::pbzero::TraceConfig_AndroidReportConfig; using CmdTraceStartDelay = ::perfetto::protos::pbzero::TraceConfig_CmdTraceStartDelay; + using SessionSemaphore = ::perfetto::protos::pbzero::TraceConfig_SessionSemaphore; using LockdownModeOperation = ::perfetto::protos::pbzero::TraceConfig_LockdownModeOperation; static inline const char* LockdownModeOperation_Name(LockdownModeOperation value) { @@ -50972,6 +51526,84 @@ class TraceConfig : public ::protozero::Message { return BeginNestedMessage(35); } + + using FieldMetadata_SessionSemaphores = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TraceConfig_SessionSemaphore, + TraceConfig>; + + static constexpr FieldMetadata_SessionSemaphores kSessionSemaphores{}; + template T* add_session_semaphores() { + return BeginNestedMessage(39); + } + +}; + +class TraceConfig_SessionSemaphore_Decoder : public ::protozero::TypedProtoDecoder { + public: + TraceConfig_SessionSemaphore_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TraceConfig_SessionSemaphore_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TraceConfig_SessionSemaphore_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_name() const { return at<1>().valid(); } + ::protozero::ConstChars name() const { return at<1>().as_string(); } + bool has_max_other_session_count() const { return at<2>().valid(); } + uint64_t max_other_session_count() const { return at<2>().as_uint64(); } +}; + +class TraceConfig_SessionSemaphore : public ::protozero::Message { + public: + using Decoder = TraceConfig_SessionSemaphore_Decoder; + enum : int32_t { + kNameFieldNumber = 1, + kMaxOtherSessionCountFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TraceConfig.SessionSemaphore"; } + + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + TraceConfig_SessionSemaphore>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MaxOtherSessionCount = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TraceConfig_SessionSemaphore>; + + static constexpr FieldMetadata_MaxOtherSessionCount kMaxOtherSessionCount{}; + void set_max_other_session_count(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MaxOtherSessionCount::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } }; class TraceConfig_CmdTraceStartDelay_Decoder : public ::protozero::TypedProtoDecoder { @@ -52876,7 +53508,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder { +class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder { public: SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -52885,6 +53517,8 @@ class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_android_build_fingerprint() const { return at<2>().valid(); } ::protozero::ConstChars android_build_fingerprint() const { return at<2>().as_string(); } + bool has_android_soc_model() const { return at<9>().valid(); } + ::protozero::ConstChars android_soc_model() const { return at<9>().as_string(); } bool has_tracing_service_version() const { return at<4>().valid(); } ::protozero::ConstChars tracing_service_version() const { return at<4>().as_string(); } bool has_android_sdk_version() const { return at<5>().valid(); } @@ -52905,6 +53539,7 @@ class SystemInfo : public ::protozero::Message { enum : int32_t { kUtsnameFieldNumber = 1, kAndroidBuildFingerprintFieldNumber = 2, + kAndroidSocModelFieldNumber = 9, kTracingServiceVersionFieldNumber = 4, kAndroidSdkVersionFieldNumber = 5, kPageSizeFieldNumber = 6, @@ -52953,6 +53588,30 @@ class SystemInfo : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_AndroidSocModel = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + SystemInfo>; + + static constexpr FieldMetadata_AndroidSocModel kAndroidSocModel{}; + void set_android_soc_model(const char* data, size_t size) { + AppendBytes(FieldMetadata_AndroidSocModel::kFieldId, data, size); + } + void set_android_soc_model(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_AndroidSocModel::kFieldId, chars.data, chars.size); + } + void set_android_soc_model(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_AndroidSocModel::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + using FieldMetadata_TracingServiceVersion = ::protozero::proto_utils::FieldMetadata< 4, @@ -53192,6 +53851,7864 @@ class Utsname : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics/point.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_POINT_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_POINT_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class PointProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + PointProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PointProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PointProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_x() const { return at<1>().valid(); } + int32_t x() const { return at<1>().as_int32(); } + bool has_y() const { return at<2>().valid(); } + int32_t y() const { return at<2>().as_int32(); } +}; + +class PointProto : public ::protozero::Message { + public: + using Decoder = PointProto_Decoder; + enum : int32_t { + kXFieldNumber = 1, + kYFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PointProto"; } + + + using FieldMetadata_X = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PointProto>; + + static constexpr FieldMetadata_X kX{}; + void set_x(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Y = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + PointProto>; + + static constexpr FieldMetadata_Y kY{}; + void set_y(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/graphics/rect.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_RECT_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_GRAPHICS_RECT_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class RectProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + RectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_left() const { return at<1>().valid(); } + int32_t left() const { return at<1>().as_int32(); } + bool has_top() const { return at<2>().valid(); } + int32_t top() const { return at<2>().as_int32(); } + bool has_right() const { return at<3>().valid(); } + int32_t right() const { return at<3>().as_int32(); } + bool has_bottom() const { return at<4>().valid(); } + int32_t bottom() const { return at<4>().as_int32(); } +}; + +class RectProto : public ::protozero::Message { + public: + using Decoder = RectProto_Decoder; + enum : int32_t { + kLeftFieldNumber = 1, + kTopFieldNumber = 2, + kRightFieldNumber = 3, + kBottomFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RectProto"; } + + + using FieldMetadata_Left = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Left kLeft{}; + void set_left(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Top = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Top kTop{}; + void set_top(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Right = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Right kRight{}; + void set_right(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bottom = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + RectProto>; + + static constexpr FieldMetadata_Bottom kBottom{}; + void set_bottom(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/winscope_extensions.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_WINSCOPE_EXTENSIONS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_WINSCOPE_EXTENSIONS_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class WinscopeExtensions_Decoder : public ::protozero::TypedProtoDecoder { + public: + WinscopeExtensions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit WinscopeExtensions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit WinscopeExtensions_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} +}; + +class WinscopeExtensions : public ::protozero::Message { + public: + using Decoder = WinscopeExtensions_Decoder; + static constexpr const char* GetName() { return ".perfetto.protos.WinscopeExtensions"; } + +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/protolog.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PROTOLOG_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PROTOLOG_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class ProtoLogViewerConfig_Group; +class ProtoLogViewerConfig_MessageData; +enum ProtoLogLevel : int32_t; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +class ProtoLogViewerConfig_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogViewerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogViewerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogViewerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_messages() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> messages() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_groups() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> groups() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class ProtoLogViewerConfig : public ::protozero::Message { + public: + using Decoder = ProtoLogViewerConfig_Decoder; + enum : int32_t { + kMessagesFieldNumber = 1, + kGroupsFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig"; } + + using MessageData = ::perfetto::protos::pbzero::ProtoLogViewerConfig_MessageData; + using Group = ::perfetto::protos::pbzero::ProtoLogViewerConfig_Group; + + using FieldMetadata_Messages = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogViewerConfig_MessageData, + ProtoLogViewerConfig>; + + static constexpr FieldMetadata_Messages kMessages{}; + template T* add_messages() { + return BeginNestedMessage(1); + } + + + using FieldMetadata_Groups = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProtoLogViewerConfig_Group, + ProtoLogViewerConfig>; + + static constexpr FieldMetadata_Groups kGroups{}; + template T* add_groups() { + return BeginNestedMessage(2); + } + +}; + +class ProtoLogViewerConfig_Group_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogViewerConfig_Group_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogViewerConfig_Group_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogViewerConfig_Group_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint32_t id() const { return at<1>().as_uint32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_tag() const { return at<3>().valid(); } + ::protozero::ConstChars tag() const { return at<3>().as_string(); } +}; + +class ProtoLogViewerConfig_Group : public ::protozero::Message { + public: + using Decoder = ProtoLogViewerConfig_Group_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kTagFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.Group"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogViewerConfig_Group>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogViewerConfig_Group>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tag = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogViewerConfig_Group>; + + static constexpr FieldMetadata_Tag kTag{}; + void set_tag(const char* data, size_t size) { + AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + } + void set_tag(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + } + void set_tag(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogViewerConfig_MessageData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogViewerConfig_MessageData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogViewerConfig_MessageData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_message_id() const { return at<1>().valid(); } + uint64_t message_id() const { return at<1>().as_uint64(); } + bool has_message() const { return at<2>().valid(); } + ::protozero::ConstChars message() const { return at<2>().as_string(); } + bool has_level() const { return at<3>().valid(); } + int32_t level() const { return at<3>().as_int32(); } + bool has_group_id() const { return at<4>().valid(); } + uint32_t group_id() const { return at<4>().as_uint32(); } +}; + +class ProtoLogViewerConfig_MessageData : public ::protozero::Message { + public: + using Decoder = ProtoLogViewerConfig_MessageData_Decoder; + enum : int32_t { + kMessageIdFieldNumber = 1, + kMessageFieldNumber = 2, + kLevelFieldNumber = 3, + kGroupIdFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.MessageData"; } + + + using FieldMetadata_MessageId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_MessageId kMessageId{}; + void set_message_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Message = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_Message kMessage{}; + void set_message(const char* data, size_t size) { + AppendBytes(FieldMetadata_Message::kFieldId, data, size); + } + void set_message(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size); + } + void set_message(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Level = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + ProtoLogLevel, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_Level kLevel{}; + void set_level(ProtoLogLevel value) { + static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GroupId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogViewerConfig_MessageData>; + + static constexpr FieldMetadata_GroupId kGroupId{}; + void set_group_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ProtoLogMessage_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProtoLogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProtoLogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProtoLogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_message_id() const { return at<1>().valid(); } + uint64_t message_id() const { return at<1>().as_uint64(); } + bool has_str_param_iids() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator str_param_iids() const { return GetRepeated(2); } + bool has_sint64_params() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator sint64_params() const { return GetRepeated(3); } + bool has_double_params() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator double_params() const { return GetRepeated(4); } + bool has_boolean_params() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator boolean_params() const { return GetRepeated(5); } + bool has_stacktrace_iid() const { return at<6>().valid(); } + uint32_t stacktrace_iid() const { return at<6>().as_uint32(); } +}; + +class ProtoLogMessage : public ::protozero::Message { + public: + using Decoder = ProtoLogMessage_Decoder; + enum : int32_t { + kMessageIdFieldNumber = 1, + kStrParamIidsFieldNumber = 2, + kSint64ParamsFieldNumber = 3, + kDoubleParamsFieldNumber = 4, + kBooleanParamsFieldNumber = 5, + kStacktraceIidFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogMessage"; } + + + using FieldMetadata_MessageId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_MessageId kMessageId{}; + void set_message_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StrParamIids = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_StrParamIids kStrParamIids{}; + void add_str_param_iids(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StrParamIids::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Sint64Params = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kSint64, + int64_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_Sint64Params kSint64Params{}; + void add_sint64_params(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Sint64Params::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DoubleParams = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + ProtoLogMessage>; + + static constexpr FieldMetadata_DoubleParams kDoubleParams{}; + void add_double_params(double value) { + static constexpr uint32_t field_id = FieldMetadata_DoubleParams::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BooleanParams = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_BooleanParams kBooleanParams{}; + void add_boolean_params(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BooleanParams::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StacktraceIid = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ProtoLogMessage>; + + static constexpr FieldMetadata_StacktraceIid kStacktraceIid{}; + void set_stacktrace_iid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_StacktraceIid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/shell_transition.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SHELL_TRANSITION_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SHELL_TRANSITION_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class ShellHandlerMapping; +class ShellTransition_Target; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +class ShellHandlerMapping_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellHandlerMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellHandlerMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellHandlerMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } +}; + +class ShellHandlerMapping : public ::protozero::Message { + public: + using Decoder = ShellHandlerMapping_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMapping"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellHandlerMapping>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ShellHandlerMapping>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class ShellHandlerMappings_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellHandlerMappings_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellHandlerMappings_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellHandlerMappings_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mapping() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mapping() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class ShellHandlerMappings : public ::protozero::Message { + public: + using Decoder = ShellHandlerMappings_Decoder; + enum : int32_t { + kMappingFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMappings"; } + + + using FieldMetadata_Mapping = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ShellHandlerMapping, + ShellHandlerMappings>; + + static constexpr FieldMetadata_Mapping kMapping{}; + template T* add_mapping() { + return BeginNestedMessage(1); + } + +}; + +class ShellTransition_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellTransition_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellTransition_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellTransition_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_create_time_ns() const { return at<2>().valid(); } + int64_t create_time_ns() const { return at<2>().as_int64(); } + bool has_send_time_ns() const { return at<3>().valid(); } + int64_t send_time_ns() const { return at<3>().as_int64(); } + bool has_dispatch_time_ns() const { return at<4>().valid(); } + int64_t dispatch_time_ns() const { return at<4>().as_int64(); } + bool has_merge_time_ns() const { return at<5>().valid(); } + int64_t merge_time_ns() const { return at<5>().as_int64(); } + bool has_merge_request_time_ns() const { return at<6>().valid(); } + int64_t merge_request_time_ns() const { return at<6>().as_int64(); } + bool has_shell_abort_time_ns() const { return at<7>().valid(); } + int64_t shell_abort_time_ns() const { return at<7>().as_int64(); } + bool has_wm_abort_time_ns() const { return at<8>().valid(); } + int64_t wm_abort_time_ns() const { return at<8>().as_int64(); } + bool has_finish_time_ns() const { return at<9>().valid(); } + int64_t finish_time_ns() const { return at<9>().as_int64(); } + bool has_start_transaction_id() const { return at<10>().valid(); } + uint64_t start_transaction_id() const { return at<10>().as_uint64(); } + bool has_finish_transaction_id() const { return at<11>().valid(); } + uint64_t finish_transaction_id() const { return at<11>().as_uint64(); } + bool has_handler() const { return at<12>().valid(); } + int32_t handler() const { return at<12>().as_int32(); } + bool has_type() const { return at<13>().valid(); } + int32_t type() const { return at<13>().as_int32(); } + bool has_targets() const { return at<14>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> targets() const { return GetRepeated<::protozero::ConstBytes>(14); } + bool has_merge_target() const { return at<15>().valid(); } + int32_t merge_target() const { return at<15>().as_int32(); } + bool has_flags() const { return at<16>().valid(); } + int32_t flags() const { return at<16>().as_int32(); } + bool has_starting_window_remove_time_ns() const { return at<17>().valid(); } + int64_t starting_window_remove_time_ns() const { return at<17>().as_int64(); } +}; + +class ShellTransition : public ::protozero::Message { + public: + using Decoder = ShellTransition_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kCreateTimeNsFieldNumber = 2, + kSendTimeNsFieldNumber = 3, + kDispatchTimeNsFieldNumber = 4, + kMergeTimeNsFieldNumber = 5, + kMergeRequestTimeNsFieldNumber = 6, + kShellAbortTimeNsFieldNumber = 7, + kWmAbortTimeNsFieldNumber = 8, + kFinishTimeNsFieldNumber = 9, + kStartTransactionIdFieldNumber = 10, + kFinishTransactionIdFieldNumber = 11, + kHandlerFieldNumber = 12, + kTypeFieldNumber = 13, + kTargetsFieldNumber = 14, + kMergeTargetFieldNumber = 15, + kFlagsFieldNumber = 16, + kStartingWindowRemoveTimeNsFieldNumber = 17, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition"; } + + using Target = ::perfetto::protos::pbzero::ShellTransition_Target; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CreateTimeNs = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_CreateTimeNs kCreateTimeNs{}; + void set_create_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CreateTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_SendTimeNs = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_SendTimeNs kSendTimeNs{}; + void set_send_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SendTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DispatchTimeNs = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_DispatchTimeNs kDispatchTimeNs{}; + void set_dispatch_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_DispatchTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MergeTimeNs = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_MergeTimeNs kMergeTimeNs{}; + void set_merge_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergeTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MergeRequestTimeNs = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_MergeRequestTimeNs kMergeRequestTimeNs{}; + void set_merge_request_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergeRequestTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShellAbortTimeNs = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_ShellAbortTimeNs kShellAbortTimeNs{}; + void set_shell_abort_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ShellAbortTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WmAbortTimeNs = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_WmAbortTimeNs kWmAbortTimeNs{}; + void set_wm_abort_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_WmAbortTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FinishTimeNs = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_FinishTimeNs kFinishTimeNs{}; + void set_finish_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FinishTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartTransactionId = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ShellTransition>; + + static constexpr FieldMetadata_StartTransactionId kStartTransactionId{}; + void set_start_transaction_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartTransactionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FinishTransactionId = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ShellTransition>; + + static constexpr FieldMetadata_FinishTransactionId kFinishTransactionId{}; + void set_finish_transaction_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FinishTransactionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Handler = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Handler kHandler{}; + void set_handler(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Targets = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ShellTransition_Target, + ShellTransition>; + + static constexpr FieldMetadata_Targets kTargets{}; + template T* add_targets() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_MergeTarget = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_MergeTarget kMergeTarget{}; + void set_merge_target(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergeTarget::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_StartingWindowRemoveTimeNs = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + ShellTransition>; + + static constexpr FieldMetadata_StartingWindowRemoveTimeNs kStartingWindowRemoveTimeNs{}; + void set_starting_window_remove_time_ns(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_StartingWindowRemoveTimeNs::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class ShellTransition_Target_Decoder : public ::protozero::TypedProtoDecoder { + public: + ShellTransition_Target_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ShellTransition_Target_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ShellTransition_Target_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_mode() const { return at<1>().valid(); } + int32_t mode() const { return at<1>().as_int32(); } + bool has_layer_id() const { return at<2>().valid(); } + int32_t layer_id() const { return at<2>().as_int32(); } + bool has_window_id() const { return at<3>().valid(); } + int32_t window_id() const { return at<3>().as_int32(); } + bool has_flags() const { return at<4>().valid(); } + int32_t flags() const { return at<4>().as_int32(); } +}; + +class ShellTransition_Target : public ::protozero::Message { + public: + using Decoder = ShellTransition_Target_Decoder; + enum : int32_t { + kModeFieldNumber = 1, + kLayerIdFieldNumber = 2, + kWindowIdFieldNumber = 3, + kFlagsFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition.Target"; } + + + using FieldMetadata_Mode = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_Mode kMode{}; + void set_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_LayerId kLayerId{}; + void set_layer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_WindowId kWindowId{}; + void set_window_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WindowId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ShellTransition_Target>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_common.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_COMMON_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_COMMON_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class RectProto; +class RegionProto; +class TransformProto; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +enum TrustedOverlay : int32_t { + UNSET = 0, + DISABLED = 1, + ENABLED = 2, +}; + +constexpr TrustedOverlay TrustedOverlay_MIN = TrustedOverlay::UNSET; +constexpr TrustedOverlay TrustedOverlay_MAX = TrustedOverlay::ENABLED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TrustedOverlay_Name(::perfetto::protos::pbzero::TrustedOverlay value) { + switch (value) { + case ::perfetto::protos::pbzero::TrustedOverlay::UNSET: + return "UNSET"; + + case ::perfetto::protos::pbzero::TrustedOverlay::DISABLED: + return "DISABLED"; + + case ::perfetto::protos::pbzero::TrustedOverlay::ENABLED: + return "ENABLED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class ColorTransformProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + ColorTransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ColorTransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ColorTransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_val() const { return at<1>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed32, float> val(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed32, float>(1, parse_error_ptr); } +}; + +class ColorTransformProto : public ::protozero::Message { + public: + using Decoder = ColorTransformProto_Decoder; + enum : int32_t { + kValFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ColorTransformProto"; } + + + using FieldMetadata_Val = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorTransformProto>; + + static constexpr FieldMetadata_Val kVal{}; + void set_val(const ::protozero::PackedFixedSizeInt& packed_buffer) { + AppendBytes(FieldMetadata_Val::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } +}; + +class BlurRegion_Decoder : public ::protozero::TypedProtoDecoder { + public: + BlurRegion_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BlurRegion_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BlurRegion_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_blur_radius() const { return at<1>().valid(); } + uint32_t blur_radius() const { return at<1>().as_uint32(); } + bool has_corner_radius_tl() const { return at<2>().valid(); } + uint32_t corner_radius_tl() const { return at<2>().as_uint32(); } + bool has_corner_radius_tr() const { return at<3>().valid(); } + uint32_t corner_radius_tr() const { return at<3>().as_uint32(); } + bool has_corner_radius_bl() const { return at<4>().valid(); } + uint32_t corner_radius_bl() const { return at<4>().as_uint32(); } + bool has_corner_radius_br() const { return at<5>().valid(); } + float corner_radius_br() const { return at<5>().as_float(); } + bool has_alpha() const { return at<6>().valid(); } + float alpha() const { return at<6>().as_float(); } + bool has_left() const { return at<7>().valid(); } + int32_t left() const { return at<7>().as_int32(); } + bool has_top() const { return at<8>().valid(); } + int32_t top() const { return at<8>().as_int32(); } + bool has_right() const { return at<9>().valid(); } + int32_t right() const { return at<9>().as_int32(); } + bool has_bottom() const { return at<10>().valid(); } + int32_t bottom() const { return at<10>().as_int32(); } +}; + +class BlurRegion : public ::protozero::Message { + public: + using Decoder = BlurRegion_Decoder; + enum : int32_t { + kBlurRadiusFieldNumber = 1, + kCornerRadiusTlFieldNumber = 2, + kCornerRadiusTrFieldNumber = 3, + kCornerRadiusBlFieldNumber = 4, + kCornerRadiusBrFieldNumber = 5, + kAlphaFieldNumber = 6, + kLeftFieldNumber = 7, + kTopFieldNumber = 8, + kRightFieldNumber = 9, + kBottomFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BlurRegion"; } + + + using FieldMetadata_BlurRadius = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_BlurRadius kBlurRadius{}; + void set_blur_radius(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BlurRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusTl = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusTl kCornerRadiusTl{}; + void set_corner_radius_tl(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusTr = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusTr kCornerRadiusTr{}; + void set_corner_radius_tr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusBl = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusBl kCornerRadiusBl{}; + void set_corner_radius_bl(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBl::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadiusBr = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + BlurRegion>; + + static constexpr FieldMetadata_CornerRadiusBr kCornerRadiusBr{}; + void set_corner_radius_br(float value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Alpha = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + BlurRegion>; + + static constexpr FieldMetadata_Alpha kAlpha{}; + void set_alpha(float value) { + static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Left = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Left kLeft{}; + void set_left(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Top = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Top kTop{}; + void set_top(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Right = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Right kRight{}; + void set_right(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bottom = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BlurRegion>; + + static constexpr FieldMetadata_Bottom kBottom{}; + void set_bottom(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class InputWindowInfoProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + InputWindowInfoProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit InputWindowInfoProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit InputWindowInfoProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layout_params_flags() const { return at<1>().valid(); } + uint32_t layout_params_flags() const { return at<1>().as_uint32(); } + bool has_layout_params_type() const { return at<2>().valid(); } + int32_t layout_params_type() const { return at<2>().as_int32(); } + bool has_frame() const { return at<3>().valid(); } + ::protozero::ConstBytes frame() const { return at<3>().as_bytes(); } + bool has_touchable_region() const { return at<4>().valid(); } + ::protozero::ConstBytes touchable_region() const { return at<4>().as_bytes(); } + bool has_surface_inset() const { return at<5>().valid(); } + int32_t surface_inset() const { return at<5>().as_int32(); } + bool has_visible() const { return at<6>().valid(); } + bool visible() const { return at<6>().as_bool(); } + bool has_can_receive_keys() const { return at<7>().valid(); } + bool can_receive_keys() const { return at<7>().as_bool(); } + bool has_focusable() const { return at<8>().valid(); } + bool focusable() const { return at<8>().as_bool(); } + bool has_has_wallpaper() const { return at<9>().valid(); } + bool has_wallpaper() const { return at<9>().as_bool(); } + bool has_global_scale_factor() const { return at<10>().valid(); } + float global_scale_factor() const { return at<10>().as_float(); } + bool has_window_x_scale() const { return at<11>().valid(); } + float window_x_scale() const { return at<11>().as_float(); } + bool has_window_y_scale() const { return at<12>().valid(); } + float window_y_scale() const { return at<12>().as_float(); } + bool has_crop_layer_id() const { return at<13>().valid(); } + int32_t crop_layer_id() const { return at<13>().as_int32(); } + bool has_replace_touchable_region_with_crop() const { return at<14>().valid(); } + bool replace_touchable_region_with_crop() const { return at<14>().as_bool(); } + bool has_touchable_region_crop() const { return at<15>().valid(); } + ::protozero::ConstBytes touchable_region_crop() const { return at<15>().as_bytes(); } + bool has_transform() const { return at<16>().valid(); } + ::protozero::ConstBytes transform() const { return at<16>().as_bytes(); } + bool has_input_config() const { return at<17>().valid(); } + uint32_t input_config() const { return at<17>().as_uint32(); } +}; + +class InputWindowInfoProto : public ::protozero::Message { + public: + using Decoder = InputWindowInfoProto_Decoder; + enum : int32_t { + kLayoutParamsFlagsFieldNumber = 1, + kLayoutParamsTypeFieldNumber = 2, + kFrameFieldNumber = 3, + kTouchableRegionFieldNumber = 4, + kSurfaceInsetFieldNumber = 5, + kVisibleFieldNumber = 6, + kCanReceiveKeysFieldNumber = 7, + kFocusableFieldNumber = 8, + kHasWallpaperFieldNumber = 9, + kGlobalScaleFactorFieldNumber = 10, + kWindowXScaleFieldNumber = 11, + kWindowYScaleFieldNumber = 12, + kCropLayerIdFieldNumber = 13, + kReplaceTouchableRegionWithCropFieldNumber = 14, + kTouchableRegionCropFieldNumber = 15, + kTransformFieldNumber = 16, + kInputConfigFieldNumber = 17, + }; + static constexpr const char* GetName() { return ".perfetto.protos.InputWindowInfoProto"; } + + + using FieldMetadata_LayoutParamsFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{}; + void set_layout_params_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayoutParamsType = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{}; + void set_layout_params_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Frame = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Frame kFrame{}; + template T* set_frame() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_TouchableRegion = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_TouchableRegion kTouchableRegion{}; + template T* set_touchable_region() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_SurfaceInset = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_SurfaceInset kSurfaceInset{}; + void set_surface_inset(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Visible = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Visible kVisible{}; + void set_visible(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CanReceiveKeys = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_CanReceiveKeys kCanReceiveKeys{}; + void set_can_receive_keys(bool value) { + static constexpr uint32_t field_id = FieldMetadata_CanReceiveKeys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Focusable = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Focusable kFocusable{}; + void set_focusable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasWallpaper = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_HasWallpaper kHasWallpaper{}; + void set_has_wallpaper(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GlobalScaleFactor = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + InputWindowInfoProto>; + + static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{}; + void set_global_scale_factor(float value) { + static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowXScale = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + InputWindowInfoProto>; + + static constexpr FieldMetadata_WindowXScale kWindowXScale{}; + void set_window_x_scale(float value) { + static constexpr uint32_t field_id = FieldMetadata_WindowXScale::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowYScale = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + InputWindowInfoProto>; + + static constexpr FieldMetadata_WindowYScale kWindowYScale{}; + void set_window_y_scale(float value) { + static constexpr uint32_t field_id = FieldMetadata_WindowYScale::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CropLayerId = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_CropLayerId kCropLayerId{}; + void set_crop_layer_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReplaceTouchableRegionWithCrop = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + InputWindowInfoProto>; + + static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{}; + void set_replace_touchable_region_with_crop(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchableRegionCrop = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{}; + template T* set_touchable_region_crop() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + InputWindowInfoProto>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(16); + } + + + using FieldMetadata_InputConfig = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + InputWindowInfoProto>; + + static constexpr FieldMetadata_InputConfig kInputConfig{}; + void set_input_config(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class ColorProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + ColorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ColorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ColorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_r() const { return at<1>().valid(); } + float r() const { return at<1>().as_float(); } + bool has_g() const { return at<2>().valid(); } + float g() const { return at<2>().as_float(); } + bool has_b() const { return at<3>().valid(); } + float b() const { return at<3>().as_float(); } + bool has_a() const { return at<4>().valid(); } + float a() const { return at<4>().as_float(); } +}; + +class ColorProto : public ::protozero::Message { + public: + using Decoder = ColorProto_Decoder; + enum : int32_t { + kRFieldNumber = 1, + kGFieldNumber = 2, + kBFieldNumber = 3, + kAFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ColorProto"; } + + + using FieldMetadata_R = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_R kR{}; + void set_r(float value) { + static constexpr uint32_t field_id = FieldMetadata_R::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_G = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_G kG{}; + void set_g(float value) { + static constexpr uint32_t field_id = FieldMetadata_G::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_B = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_B kB{}; + void set_b(float value) { + static constexpr uint32_t field_id = FieldMetadata_B::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_A = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + ColorProto>; + + static constexpr FieldMetadata_A kA{}; + void set_a(float value) { + static constexpr uint32_t field_id = FieldMetadata_A::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class TransformProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dsdx() const { return at<1>().valid(); } + float dsdx() const { return at<1>().as_float(); } + bool has_dtdx() const { return at<2>().valid(); } + float dtdx() const { return at<2>().as_float(); } + bool has_dsdy() const { return at<3>().valid(); } + float dsdy() const { return at<3>().as_float(); } + bool has_dtdy() const { return at<4>().valid(); } + float dtdy() const { return at<4>().as_float(); } + bool has_type() const { return at<5>().valid(); } + int32_t type() const { return at<5>().as_int32(); } +}; + +class TransformProto : public ::protozero::Message { + public: + using Decoder = TransformProto_Decoder; + enum : int32_t { + kDsdxFieldNumber = 1, + kDtdxFieldNumber = 2, + kDsdyFieldNumber = 3, + kDtdyFieldNumber = 4, + kTypeFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransformProto"; } + + + using FieldMetadata_Dsdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dsdx kDsdx{}; + void set_dsdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dtdx kDtdx{}; + void set_dtdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dsdy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dsdy kDsdy{}; + void set_dsdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + TransformProto>; + + static constexpr FieldMetadata_Dtdy kDtdy{}; + void set_dtdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransformProto>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class SizeProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + SizeProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit SizeProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit SizeProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_w() const { return at<1>().valid(); } + int32_t w() const { return at<1>().as_int32(); } + bool has_h() const { return at<2>().valid(); } + int32_t h() const { return at<2>().as_int32(); } +}; + +class SizeProto : public ::protozero::Message { + public: + using Decoder = SizeProto_Decoder; + enum : int32_t { + kWFieldNumber = 1, + kHFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.SizeProto"; } + + + using FieldMetadata_W = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SizeProto>; + + static constexpr FieldMetadata_W kW{}; + void set_w(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_W::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_H = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + SizeProto>; + + static constexpr FieldMetadata_H kH{}; + void set_h(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_H::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class RegionProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + RegionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit RegionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit RegionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_rect() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rect() const { return GetRepeated<::protozero::ConstBytes>(2); } +}; + +class RegionProto : public ::protozero::Message { + public: + using Decoder = RegionProto_Decoder; + enum : int32_t { + kRectFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.RegionProto"; } + + + using FieldMetadata_Rect = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + RegionProto>; + + static constexpr FieldMetadata_Rect kRect{}; + template T* add_rect() { + return BeginNestedMessage(2); + } + +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_layers.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_LAYERS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_LAYERS_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class ActiveBufferProto; +class BarrierLayerProto; +class BlurRegion; +class ColorProto; +class ColorTransformProto; +class DisplayProto; +class FloatRectProto; +class InputWindowInfoProto; +class LayerProto; +class LayerProto_MetadataEntry; +class LayersProto; +class LayersSnapshotProto; +class PositionProto; +class RectProto; +class RegionProto; +class SizeProto; +class TransformProto; +enum HwcCompositionType : int32_t; +enum TrustedOverlay : int32_t; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +enum HwcCompositionType : int32_t { + HWC_TYPE_UNSPECIFIED = 0, + HWC_TYPE_CLIENT = 1, + HWC_TYPE_DEVICE = 2, + HWC_TYPE_SOLID_COLOR = 3, + HWC_TYPE_CURSOR = 4, + HWC_TYPE_SIDEBAND = 5, + HWC_TYPE_DISPLAY_DECORATION = 6, +}; + +constexpr HwcCompositionType HwcCompositionType_MIN = HwcCompositionType::HWC_TYPE_UNSPECIFIED; +constexpr HwcCompositionType HwcCompositionType_MAX = HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* HwcCompositionType_Name(::perfetto::protos::pbzero::HwcCompositionType value) { + switch (value) { + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_UNSPECIFIED: + return "HWC_TYPE_UNSPECIFIED"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CLIENT: + return "HWC_TYPE_CLIENT"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DEVICE: + return "HWC_TYPE_DEVICE"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SOLID_COLOR: + return "HWC_TYPE_SOLID_COLOR"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CURSOR: + return "HWC_TYPE_CURSOR"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SIDEBAND: + return "HWC_TYPE_SIDEBAND"; + + case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION: + return "HWC_TYPE_DISPLAY_DECORATION"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayersTraceFileProto { +enum MagicNumber : int32_t { + INVALID = 0, + MAGIC_NUMBER_L = 1414682956, + MAGIC_NUMBER_H = 1162035538, +}; +} // namespace perfetto_pbzero_enum_LayersTraceFileProto +using LayersTraceFileProto_MagicNumber = perfetto_pbzero_enum_LayersTraceFileProto::MagicNumber; + + +constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MIN = LayersTraceFileProto_MagicNumber::INVALID; +constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MAX = LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayersTraceFileProto_MagicNumber_Name(::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber value) { + switch (value) { + case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::INVALID: + return "INVALID"; + + case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L: + return "MAGIC_NUMBER_L"; + + case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_H: + return "MAGIC_NUMBER_H"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class BarrierLayerProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + BarrierLayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit BarrierLayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit BarrierLayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_frame_number() const { return at<2>().valid(); } + uint64_t frame_number() const { return at<2>().as_uint64(); } +}; + +class BarrierLayerProto : public ::protozero::Message { + public: + using Decoder = BarrierLayerProto_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kFrameNumberFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.BarrierLayerProto"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + BarrierLayerProto>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + BarrierLayerProto>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class ActiveBufferProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + ActiveBufferProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ActiveBufferProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ActiveBufferProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_width() const { return at<1>().valid(); } + uint32_t width() const { return at<1>().as_uint32(); } + bool has_height() const { return at<2>().valid(); } + uint32_t height() const { return at<2>().as_uint32(); } + bool has_stride() const { return at<3>().valid(); } + uint32_t stride() const { return at<3>().as_uint32(); } + bool has_format() const { return at<4>().valid(); } + int32_t format() const { return at<4>().as_int32(); } + bool has_usage() const { return at<5>().valid(); } + uint64_t usage() const { return at<5>().as_uint64(); } +}; + +class ActiveBufferProto : public ::protozero::Message { + public: + using Decoder = ActiveBufferProto_Decoder; + enum : int32_t { + kWidthFieldNumber = 1, + kHeightFieldNumber = 2, + kStrideFieldNumber = 3, + kFormatFieldNumber = 4, + kUsageFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ActiveBufferProto"; } + + + using FieldMetadata_Width = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Width kWidth{}; + void set_width(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Height = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Height kHeight{}; + void set_height(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Stride = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Stride kStride{}; + void set_stride(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Stride::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Format = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Format kFormat{}; + void set_format(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Usage = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ActiveBufferProto>; + + static constexpr FieldMetadata_Usage kUsage{}; + void set_usage(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FloatRectProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + FloatRectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FloatRectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FloatRectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_left() const { return at<1>().valid(); } + float left() const { return at<1>().as_float(); } + bool has_top() const { return at<2>().valid(); } + float top() const { return at<2>().as_float(); } + bool has_right() const { return at<3>().valid(); } + float right() const { return at<3>().as_float(); } + bool has_bottom() const { return at<4>().valid(); } + float bottom() const { return at<4>().as_float(); } +}; + +class FloatRectProto : public ::protozero::Message { + public: + using Decoder = FloatRectProto_Decoder; + enum : int32_t { + kLeftFieldNumber = 1, + kTopFieldNumber = 2, + kRightFieldNumber = 3, + kBottomFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FloatRectProto"; } + + + using FieldMetadata_Left = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Left kLeft{}; + void set_left(float value) { + static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Top = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Top kTop{}; + void set_top(float value) { + static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Right = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Right kRight{}; + void set_right(float value) { + static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Bottom = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + FloatRectProto>; + + static constexpr FieldMetadata_Bottom kBottom{}; + void set_bottom(float value) { + static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class PositionProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + PositionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PositionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PositionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_x() const { return at<1>().valid(); } + float x() const { return at<1>().as_float(); } + bool has_y() const { return at<2>().valid(); } + float y() const { return at<2>().as_float(); } +}; + +class PositionProto : public ::protozero::Message { + public: + using Decoder = PositionProto_Decoder; + enum : int32_t { + kXFieldNumber = 1, + kYFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PositionProto"; } + + + using FieldMetadata_X = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + PositionProto>; + + static constexpr FieldMetadata_X kX{}; + void set_x(float value) { + static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Y = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + PositionProto>; + + static constexpr FieldMetadata_Y kY{}; + void set_y(float value) { + static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class LayerProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_children() const { return at<3>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> children(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(3, parse_error_ptr); } + bool has_relatives() const { return at<4>().valid(); } + ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> relatives(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(4, parse_error_ptr); } + bool has_type() const { return at<5>().valid(); } + ::protozero::ConstChars type() const { return at<5>().as_string(); } + bool has_transparent_region() const { return at<6>().valid(); } + ::protozero::ConstBytes transparent_region() const { return at<6>().as_bytes(); } + bool has_visible_region() const { return at<7>().valid(); } + ::protozero::ConstBytes visible_region() const { return at<7>().as_bytes(); } + bool has_damage_region() const { return at<8>().valid(); } + ::protozero::ConstBytes damage_region() const { return at<8>().as_bytes(); } + bool has_layer_stack() const { return at<9>().valid(); } + uint32_t layer_stack() const { return at<9>().as_uint32(); } + bool has_z() const { return at<10>().valid(); } + int32_t z() const { return at<10>().as_int32(); } + bool has_position() const { return at<11>().valid(); } + ::protozero::ConstBytes position() const { return at<11>().as_bytes(); } + bool has_requested_position() const { return at<12>().valid(); } + ::protozero::ConstBytes requested_position() const { return at<12>().as_bytes(); } + bool has_size() const { return at<13>().valid(); } + ::protozero::ConstBytes size() const { return at<13>().as_bytes(); } + bool has_crop() const { return at<14>().valid(); } + ::protozero::ConstBytes crop() const { return at<14>().as_bytes(); } + bool has_final_crop() const { return at<15>().valid(); } + ::protozero::ConstBytes final_crop() const { return at<15>().as_bytes(); } + bool has_is_opaque() const { return at<16>().valid(); } + bool is_opaque() const { return at<16>().as_bool(); } + bool has_invalidate() const { return at<17>().valid(); } + bool invalidate() const { return at<17>().as_bool(); } + bool has_dataspace() const { return at<18>().valid(); } + ::protozero::ConstChars dataspace() const { return at<18>().as_string(); } + bool has_pixel_format() const { return at<19>().valid(); } + ::protozero::ConstChars pixel_format() const { return at<19>().as_string(); } + bool has_color() const { return at<20>().valid(); } + ::protozero::ConstBytes color() const { return at<20>().as_bytes(); } + bool has_requested_color() const { return at<21>().valid(); } + ::protozero::ConstBytes requested_color() const { return at<21>().as_bytes(); } + bool has_flags() const { return at<22>().valid(); } + uint32_t flags() const { return at<22>().as_uint32(); } + bool has_transform() const { return at<23>().valid(); } + ::protozero::ConstBytes transform() const { return at<23>().as_bytes(); } + bool has_requested_transform() const { return at<24>().valid(); } + ::protozero::ConstBytes requested_transform() const { return at<24>().as_bytes(); } + bool has_parent() const { return at<25>().valid(); } + int32_t parent() const { return at<25>().as_int32(); } + bool has_z_order_relative_of() const { return at<26>().valid(); } + int32_t z_order_relative_of() const { return at<26>().as_int32(); } + bool has_active_buffer() const { return at<27>().valid(); } + ::protozero::ConstBytes active_buffer() const { return at<27>().as_bytes(); } + bool has_queued_frames() const { return at<28>().valid(); } + int32_t queued_frames() const { return at<28>().as_int32(); } + bool has_refresh_pending() const { return at<29>().valid(); } + bool refresh_pending() const { return at<29>().as_bool(); } + bool has_hwc_frame() const { return at<30>().valid(); } + ::protozero::ConstBytes hwc_frame() const { return at<30>().as_bytes(); } + bool has_hwc_crop() const { return at<31>().valid(); } + ::protozero::ConstBytes hwc_crop() const { return at<31>().as_bytes(); } + bool has_hwc_transform() const { return at<32>().valid(); } + int32_t hwc_transform() const { return at<32>().as_int32(); } + bool has_window_type() const { return at<33>().valid(); } + int32_t window_type() const { return at<33>().as_int32(); } + bool has_app_id() const { return at<34>().valid(); } + int32_t app_id() const { return at<34>().as_int32(); } + bool has_hwc_composition_type() const { return at<35>().valid(); } + int32_t hwc_composition_type() const { return at<35>().as_int32(); } + bool has_is_protected() const { return at<36>().valid(); } + bool is_protected() const { return at<36>().as_bool(); } + bool has_curr_frame() const { return at<37>().valid(); } + uint64_t curr_frame() const { return at<37>().as_uint64(); } + bool has_barrier_layer() const { return at<38>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> barrier_layer() const { return GetRepeated<::protozero::ConstBytes>(38); } + bool has_buffer_transform() const { return at<39>().valid(); } + ::protozero::ConstBytes buffer_transform() const { return at<39>().as_bytes(); } + bool has_effective_scaling_mode() const { return at<40>().valid(); } + int32_t effective_scaling_mode() const { return at<40>().as_int32(); } + bool has_corner_radius() const { return at<41>().valid(); } + float corner_radius() const { return at<41>().as_float(); } + bool has_metadata() const { return at<42>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(42); } + bool has_effective_transform() const { return at<43>().valid(); } + ::protozero::ConstBytes effective_transform() const { return at<43>().as_bytes(); } + bool has_source_bounds() const { return at<44>().valid(); } + ::protozero::ConstBytes source_bounds() const { return at<44>().as_bytes(); } + bool has_bounds() const { return at<45>().valid(); } + ::protozero::ConstBytes bounds() const { return at<45>().as_bytes(); } + bool has_screen_bounds() const { return at<46>().valid(); } + ::protozero::ConstBytes screen_bounds() const { return at<46>().as_bytes(); } + bool has_input_window_info() const { return at<47>().valid(); } + ::protozero::ConstBytes input_window_info() const { return at<47>().as_bytes(); } + bool has_corner_radius_crop() const { return at<48>().valid(); } + ::protozero::ConstBytes corner_radius_crop() const { return at<48>().as_bytes(); } + bool has_shadow_radius() const { return at<49>().valid(); } + float shadow_radius() const { return at<49>().as_float(); } + bool has_color_transform() const { return at<50>().valid(); } + ::protozero::ConstBytes color_transform() const { return at<50>().as_bytes(); } + bool has_is_relative_of() const { return at<51>().valid(); } + bool is_relative_of() const { return at<51>().as_bool(); } + bool has_background_blur_radius() const { return at<52>().valid(); } + int32_t background_blur_radius() const { return at<52>().as_int32(); } + bool has_owner_uid() const { return at<53>().valid(); } + uint32_t owner_uid() const { return at<53>().as_uint32(); } + bool has_blur_regions() const { return at<54>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(54); } + bool has_is_trusted_overlay() const { return at<55>().valid(); } + bool is_trusted_overlay() const { return at<55>().as_bool(); } + bool has_requested_corner_radius() const { return at<56>().valid(); } + float requested_corner_radius() const { return at<56>().as_float(); } + bool has_destination_frame() const { return at<57>().valid(); } + ::protozero::ConstBytes destination_frame() const { return at<57>().as_bytes(); } + bool has_original_id() const { return at<58>().valid(); } + uint32_t original_id() const { return at<58>().as_uint32(); } + bool has_trusted_overlay() const { return at<59>().valid(); } + int32_t trusted_overlay() const { return at<59>().as_int32(); } +}; + +class LayerProto : public ::protozero::Message { + public: + using Decoder = LayerProto_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kChildrenFieldNumber = 3, + kRelativesFieldNumber = 4, + kTypeFieldNumber = 5, + kTransparentRegionFieldNumber = 6, + kVisibleRegionFieldNumber = 7, + kDamageRegionFieldNumber = 8, + kLayerStackFieldNumber = 9, + kZFieldNumber = 10, + kPositionFieldNumber = 11, + kRequestedPositionFieldNumber = 12, + kSizeFieldNumber = 13, + kCropFieldNumber = 14, + kFinalCropFieldNumber = 15, + kIsOpaqueFieldNumber = 16, + kInvalidateFieldNumber = 17, + kDataspaceFieldNumber = 18, + kPixelFormatFieldNumber = 19, + kColorFieldNumber = 20, + kRequestedColorFieldNumber = 21, + kFlagsFieldNumber = 22, + kTransformFieldNumber = 23, + kRequestedTransformFieldNumber = 24, + kParentFieldNumber = 25, + kZOrderRelativeOfFieldNumber = 26, + kActiveBufferFieldNumber = 27, + kQueuedFramesFieldNumber = 28, + kRefreshPendingFieldNumber = 29, + kHwcFrameFieldNumber = 30, + kHwcCropFieldNumber = 31, + kHwcTransformFieldNumber = 32, + kWindowTypeFieldNumber = 33, + kAppIdFieldNumber = 34, + kHwcCompositionTypeFieldNumber = 35, + kIsProtectedFieldNumber = 36, + kCurrFrameFieldNumber = 37, + kBarrierLayerFieldNumber = 38, + kBufferTransformFieldNumber = 39, + kEffectiveScalingModeFieldNumber = 40, + kCornerRadiusFieldNumber = 41, + kMetadataFieldNumber = 42, + kEffectiveTransformFieldNumber = 43, + kSourceBoundsFieldNumber = 44, + kBoundsFieldNumber = 45, + kScreenBoundsFieldNumber = 46, + kInputWindowInfoFieldNumber = 47, + kCornerRadiusCropFieldNumber = 48, + kShadowRadiusFieldNumber = 49, + kColorTransformFieldNumber = 50, + kIsRelativeOfFieldNumber = 51, + kBackgroundBlurRadiusFieldNumber = 52, + kOwnerUidFieldNumber = 53, + kBlurRegionsFieldNumber = 54, + kIsTrustedOverlayFieldNumber = 55, + kRequestedCornerRadiusFieldNumber = 56, + kDestinationFrameFieldNumber = 57, + kOriginalIdFieldNumber = 58, + kTrustedOverlayFieldNumber = 59, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerProto"; } + + using MetadataEntry = ::perfetto::protos::pbzero::LayerProto_MetadataEntry; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Children = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Children kChildren{}; + void set_children(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_Children::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_Relatives = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Relatives kRelatives{}; + void set_relatives(const ::protozero::PackedVarInt& packed_buffer) { + AppendBytes(FieldMetadata_Relatives::kFieldId, packed_buffer.data(), + packed_buffer.size()); + } + + using FieldMetadata_Type = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_Type kType{}; + void set_type(const char* data, size_t size) { + AppendBytes(FieldMetadata_Type::kFieldId, data, size); + } + void set_type(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size); + } + void set_type(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransparentRegion = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerProto>; + + static constexpr FieldMetadata_TransparentRegion kTransparentRegion{}; + template T* set_transparent_region() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_VisibleRegion = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerProto>; + + static constexpr FieldMetadata_VisibleRegion kVisibleRegion{}; + template T* set_visible_region() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_DamageRegion = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerProto>; + + static constexpr FieldMetadata_DamageRegion kDamageRegion{}; + template T* set_damage_region() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Z = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Z kZ{}; + void set_z(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Position = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PositionProto, + LayerProto>; + + static constexpr FieldMetadata_Position kPosition{}; + template T* set_position() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_RequestedPosition = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + PositionProto, + LayerProto>; + + static constexpr FieldMetadata_RequestedPosition kRequestedPosition{}; + template T* set_requested_position() { + return BeginNestedMessage(12); + } + + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SizeProto, + LayerProto>; + + static constexpr FieldMetadata_Size kSize{}; + template T* set_size() { + return BeginNestedMessage(13); + } + + + using FieldMetadata_Crop = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_Crop kCrop{}; + template T* set_crop() { + return BeginNestedMessage(14); + } + + + using FieldMetadata_FinalCrop = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_FinalCrop kFinalCrop{}; + template T* set_final_crop() { + return BeginNestedMessage(15); + } + + + using FieldMetadata_IsOpaque = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsOpaque kIsOpaque{}; + void set_is_opaque(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsOpaque::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Invalidate = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_Invalidate kInvalidate{}; + void set_invalidate(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Invalidate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dataspace = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_Dataspace kDataspace{}; + void set_dataspace(const char* data, size_t size) { + AppendBytes(FieldMetadata_Dataspace::kFieldId, data, size); + } + void set_dataspace(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Dataspace::kFieldId, chars.data, chars.size); + } + void set_dataspace(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Dataspace::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PixelFormat = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto>; + + static constexpr FieldMetadata_PixelFormat kPixelFormat{}; + void set_pixel_format(const char* data, size_t size) { + AppendBytes(FieldMetadata_PixelFormat::kFieldId, data, size); + } + void set_pixel_format(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PixelFormat::kFieldId, chars.data, chars.size); + } + void set_pixel_format(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Color = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorProto, + LayerProto>; + + static constexpr FieldMetadata_Color kColor{}; + template T* set_color() { + return BeginNestedMessage(20); + } + + + using FieldMetadata_RequestedColor = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorProto, + LayerProto>; + + static constexpr FieldMetadata_RequestedColor kRequestedColor{}; + template T* set_requested_color() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(23); + } + + + using FieldMetadata_RequestedTransform = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_RequestedTransform kRequestedTransform{}; + template T* set_requested_transform() { + return BeginNestedMessage(24); + } + + + using FieldMetadata_Parent = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_Parent kParent{}; + void set_parent(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ZOrderRelativeOf = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_ZOrderRelativeOf kZOrderRelativeOf{}; + void set_z_order_relative_of(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ZOrderRelativeOf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ActiveBuffer = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ActiveBufferProto, + LayerProto>; + + static constexpr FieldMetadata_ActiveBuffer kActiveBuffer{}; + template T* set_active_buffer() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_QueuedFrames = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_QueuedFrames kQueuedFrames{}; + void set_queued_frames(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_QueuedFrames::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RefreshPending = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_RefreshPending kRefreshPending{}; + void set_refresh_pending(bool value) { + static constexpr uint32_t field_id = FieldMetadata_RefreshPending::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwcFrame = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_HwcFrame kHwcFrame{}; + template T* set_hwc_frame() { + return BeginNestedMessage(30); + } + + + using FieldMetadata_HwcCrop = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_HwcCrop kHwcCrop{}; + template T* set_hwc_crop() { + return BeginNestedMessage(31); + } + + + using FieldMetadata_HwcTransform = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_HwcTransform kHwcTransform{}; + void set_hwc_transform(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_HwcTransform::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_WindowType = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_WindowType kWindowType{}; + void set_window_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_WindowType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AppId = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_AppId kAppId{}; + void set_app_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_AppId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HwcCompositionType = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + HwcCompositionType, + LayerProto>; + + static constexpr FieldMetadata_HwcCompositionType kHwcCompositionType{}; + void set_hwc_composition_type(HwcCompositionType value) { + static constexpr uint32_t field_id = FieldMetadata_HwcCompositionType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsProtected = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsProtected kIsProtected{}; + void set_is_protected(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsProtected::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrFrame = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerProto>; + + static constexpr FieldMetadata_CurrFrame kCurrFrame{}; + void set_curr_frame(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrFrame::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BarrierLayer = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BarrierLayerProto, + LayerProto>; + + static constexpr FieldMetadata_BarrierLayer kBarrierLayer{}; + template T* add_barrier_layer() { + return BeginNestedMessage(38); + } + + + using FieldMetadata_BufferTransform = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_BufferTransform kBufferTransform{}; + template T* set_buffer_transform() { + return BeginNestedMessage(39); + } + + + using FieldMetadata_EffectiveScalingMode = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_EffectiveScalingMode kEffectiveScalingMode{}; + void set_effective_scaling_mode(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_EffectiveScalingMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CornerRadius = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerProto>; + + static constexpr FieldMetadata_CornerRadius kCornerRadius{}; + void set_corner_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Metadata = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerProto_MetadataEntry, + LayerProto>; + + static constexpr FieldMetadata_Metadata kMetadata{}; + template T* add_metadata() { + return BeginNestedMessage(42); + } + + + using FieldMetadata_EffectiveTransform = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + LayerProto>; + + static constexpr FieldMetadata_EffectiveTransform kEffectiveTransform{}; + template T* set_effective_transform() { + return BeginNestedMessage(43); + } + + + using FieldMetadata_SourceBounds = + ::protozero::proto_utils::FieldMetadata< + 44, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_SourceBounds kSourceBounds{}; + template T* set_source_bounds() { + return BeginNestedMessage(44); + } + + + using FieldMetadata_Bounds = + ::protozero::proto_utils::FieldMetadata< + 45, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_Bounds kBounds{}; + template T* set_bounds() { + return BeginNestedMessage(45); + } + + + using FieldMetadata_ScreenBounds = + ::protozero::proto_utils::FieldMetadata< + 46, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_ScreenBounds kScreenBounds{}; + template T* set_screen_bounds() { + return BeginNestedMessage(46); + } + + + using FieldMetadata_InputWindowInfo = + ::protozero::proto_utils::FieldMetadata< + 47, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + InputWindowInfoProto, + LayerProto>; + + static constexpr FieldMetadata_InputWindowInfo kInputWindowInfo{}; + template T* set_input_window_info() { + return BeginNestedMessage(47); + } + + + using FieldMetadata_CornerRadiusCrop = + ::protozero::proto_utils::FieldMetadata< + 48, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FloatRectProto, + LayerProto>; + + static constexpr FieldMetadata_CornerRadiusCrop kCornerRadiusCrop{}; + template T* set_corner_radius_crop() { + return BeginNestedMessage(48); + } + + + using FieldMetadata_ShadowRadius = + ::protozero::proto_utils::FieldMetadata< + 49, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerProto>; + + static constexpr FieldMetadata_ShadowRadius kShadowRadius{}; + void set_shadow_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ColorTransform = + ::protozero::proto_utils::FieldMetadata< + 50, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorTransformProto, + LayerProto>; + + static constexpr FieldMetadata_ColorTransform kColorTransform{}; + template T* set_color_transform() { + return BeginNestedMessage(50); + } + + + using FieldMetadata_IsRelativeOf = + ::protozero::proto_utils::FieldMetadata< + 51, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsRelativeOf kIsRelativeOf{}; + void set_is_relative_of(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsRelativeOf::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BackgroundBlurRadius = + ::protozero::proto_utils::FieldMetadata< + 52, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto>; + + static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{}; + void set_background_blur_radius(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_OwnerUid = + ::protozero::proto_utils::FieldMetadata< + 53, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_OwnerUid kOwnerUid{}; + void set_owner_uid(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OwnerUid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BlurRegions = + ::protozero::proto_utils::FieldMetadata< + 54, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlurRegion, + LayerProto>; + + static constexpr FieldMetadata_BlurRegions kBlurRegions{}; + template T* add_blur_regions() { + return BeginNestedMessage(54); + } + + + using FieldMetadata_IsTrustedOverlay = + ::protozero::proto_utils::FieldMetadata< + 55, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerProto>; + + static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{}; + void set_is_trusted_overlay(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RequestedCornerRadius = + ::protozero::proto_utils::FieldMetadata< + 56, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerProto>; + + static constexpr FieldMetadata_RequestedCornerRadius kRequestedCornerRadius{}; + void set_requested_corner_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_RequestedCornerRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DestinationFrame = + ::protozero::proto_utils::FieldMetadata< + 57, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerProto>; + + static constexpr FieldMetadata_DestinationFrame kDestinationFrame{}; + template T* set_destination_frame() { + return BeginNestedMessage(57); + } + + + using FieldMetadata_OriginalId = + ::protozero::proto_utils::FieldMetadata< + 58, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerProto>; + + static constexpr FieldMetadata_OriginalId kOriginalId{}; + void set_original_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_OriginalId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrustedOverlay = + ::protozero::proto_utils::FieldMetadata< + 59, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TrustedOverlay, + LayerProto>; + + static constexpr FieldMetadata_TrustedOverlay kTrustedOverlay{}; + void set_trusted_overlay(TrustedOverlay value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedOverlay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class LayerProto_MetadataEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerProto_MetadataEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerProto_MetadataEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerProto_MetadataEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + int32_t key() const { return at<1>().as_int32(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class LayerProto_MetadataEntry : public ::protozero::Message { + public: + using Decoder = LayerProto_MetadataEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerProto.MetadataEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerProto_MetadataEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerProto_MetadataEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + +class DisplayProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + DisplayProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DisplayProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DisplayProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + uint64_t id() const { return at<1>().as_uint64(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_layer_stack() const { return at<3>().valid(); } + uint32_t layer_stack() const { return at<3>().as_uint32(); } + bool has_size() const { return at<4>().valid(); } + ::protozero::ConstBytes size() const { return at<4>().as_bytes(); } + bool has_layer_stack_space_rect() const { return at<5>().valid(); } + ::protozero::ConstBytes layer_stack_space_rect() const { return at<5>().as_bytes(); } + bool has_transform() const { return at<6>().valid(); } + ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); } + bool has_is_virtual() const { return at<7>().valid(); } + bool is_virtual() const { return at<7>().as_bool(); } + bool has_dpi_x() const { return at<8>().valid(); } + double dpi_x() const { return at<8>().as_double(); } + bool has_dpi_y() const { return at<9>().valid(); } + double dpi_y() const { return at<9>().as_double(); } +}; + +class DisplayProto : public ::protozero::Message { + public: + using Decoder = DisplayProto_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kNameFieldNumber = 2, + kLayerStackFieldNumber = 3, + kSizeFieldNumber = 4, + kLayerStackSpaceRectFieldNumber = 5, + kTransformFieldNumber = 6, + kIsVirtualFieldNumber = 7, + kDpiXFieldNumber = 8, + kDpiYFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DisplayProto"; } + + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DisplayProto>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DisplayProto>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayProto>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + SizeProto, + DisplayProto>; + + static constexpr FieldMetadata_Size kSize{}; + template T* set_size() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_LayerStackSpaceRect = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + DisplayProto>; + + static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{}; + template T* set_layer_stack_space_rect() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransformProto, + DisplayProto>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_IsVirtual = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayProto>; + + static constexpr FieldMetadata_IsVirtual kIsVirtual{}; + void set_is_virtual(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DpiX = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + DisplayProto>; + + static constexpr FieldMetadata_DpiX kDpiX{}; + void set_dpi_x(double value) { + static constexpr uint32_t field_id = FieldMetadata_DpiX::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DpiY = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kDouble, + double, + DisplayProto>; + + static constexpr FieldMetadata_DpiY kDpiY{}; + void set_dpi_y(double value) { + static constexpr uint32_t field_id = FieldMetadata_DpiY::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kDouble> + ::Append(*this, field_id, value); + } +}; + +class LayersProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayersProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayersProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayersProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layers() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layers() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class LayersProto : public ::protozero::Message { + public: + using Decoder = LayersProto_Decoder; + enum : int32_t { + kLayersFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayersProto"; } + + + using FieldMetadata_Layers = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerProto, + LayersProto>; + + static constexpr FieldMetadata_Layers kLayers{}; + template T* add_layers() { + return BeginNestedMessage(1); + } + +}; + +class LayersSnapshotProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayersSnapshotProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayersSnapshotProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayersSnapshotProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_elapsed_realtime_nanos() const { return at<1>().valid(); } + int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); } + bool has_where() const { return at<2>().valid(); } + ::protozero::ConstChars where() const { return at<2>().as_string(); } + bool has_layers() const { return at<3>().valid(); } + ::protozero::ConstBytes layers() const { return at<3>().as_bytes(); } + bool has_hwc_blob() const { return at<4>().valid(); } + ::protozero::ConstChars hwc_blob() const { return at<4>().as_string(); } + bool has_excludes_composition_state() const { return at<5>().valid(); } + bool excludes_composition_state() const { return at<5>().as_bool(); } + bool has_missed_entries() const { return at<6>().valid(); } + uint32_t missed_entries() const { return at<6>().as_uint32(); } + bool has_displays() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_vsync_id() const { return at<8>().valid(); } + int64_t vsync_id() const { return at<8>().as_int64(); } +}; + +class LayersSnapshotProto : public ::protozero::Message { + public: + using Decoder = LayersSnapshotProto_Decoder; + enum : int32_t { + kElapsedRealtimeNanosFieldNumber = 1, + kWhereFieldNumber = 2, + kLayersFieldNumber = 3, + kHwcBlobFieldNumber = 4, + kExcludesCompositionStateFieldNumber = 5, + kMissedEntriesFieldNumber = 6, + kDisplaysFieldNumber = 7, + kVsyncIdFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayersSnapshotProto"; } + + + using FieldMetadata_ElapsedRealtimeNanos = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kSfixed64, + int64_t, + LayersSnapshotProto>; + + static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{}; + void set_elapsed_realtime_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kSfixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Where = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayersSnapshotProto>; + + static constexpr FieldMetadata_Where kWhere{}; + void set_where(const char* data, size_t size) { + AppendBytes(FieldMetadata_Where::kFieldId, data, size); + } + void set_where(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Where::kFieldId, chars.data, chars.size); + } + void set_where(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Where::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Layers = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayersProto, + LayersSnapshotProto>; + + static constexpr FieldMetadata_Layers kLayers{}; + template T* set_layers() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_HwcBlob = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayersSnapshotProto>; + + static constexpr FieldMetadata_HwcBlob kHwcBlob{}; + void set_hwc_blob(const char* data, size_t size) { + AppendBytes(FieldMetadata_HwcBlob::kFieldId, data, size); + } + void set_hwc_blob(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_HwcBlob::kFieldId, chars.data, chars.size); + } + void set_hwc_blob(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_HwcBlob::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ExcludesCompositionState = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayersSnapshotProto>; + + static constexpr FieldMetadata_ExcludesCompositionState kExcludesCompositionState{}; + void set_excludes_composition_state(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ExcludesCompositionState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MissedEntries = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayersSnapshotProto>; + + static constexpr FieldMetadata_MissedEntries kMissedEntries{}; + void set_missed_entries(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MissedEntries::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Displays = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayProto, + LayersSnapshotProto>; + + static constexpr FieldMetadata_Displays kDisplays{}; + template T* add_displays() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + LayersSnapshotProto>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } +}; + +class LayersTraceFileProto_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayersTraceFileProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayersTraceFileProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayersTraceFileProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_magic_number() const { return at<1>().valid(); } + uint64_t magic_number() const { return at<1>().as_uint64(); } + bool has_entry() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); } + uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); } +}; + +class LayersTraceFileProto : public ::protozero::Message { + public: + using Decoder = LayersTraceFileProto_Decoder; + enum : int32_t { + kMagicNumberFieldNumber = 1, + kEntryFieldNumber = 2, + kRealToElapsedTimeOffsetNanosFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayersTraceFileProto"; } + + + using MagicNumber = ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber; + static inline const char* MagicNumber_Name(MagicNumber value) { + return ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber_Name(value); + } + static inline const MagicNumber INVALID = MagicNumber::INVALID; + static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L; + static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H; + + using FieldMetadata_MagicNumber = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + LayersTraceFileProto>; + + static constexpr FieldMetadata_MagicNumber kMagicNumber{}; + void set_magic_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entry = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayersSnapshotProto, + LayersTraceFileProto>; + + static constexpr FieldMetadata_Entry kEntry{}; + template T* add_entry() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_RealToElapsedTimeOffsetNanos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + LayersTraceFileProto>; + + static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{}; + void set_real_to_elapsed_time_offset_nanos(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_transactions.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_TRANSACTIONS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_TRANSACTIONS_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + +namespace perfetto { +namespace protos { +namespace pbzero { +class BlurRegion; +class ColorTransformProto; +class DisplayInfo; +class DisplayState; +class LayerCreationArgs; +class LayerState; +class LayerState_BufferData; +class LayerState_Color3; +class LayerState_Matrix22; +class LayerState_WindowInfo; +class RectProto; +class RegionProto; +class TransactionState; +class TransactionTraceEntry; +class Transform; +namespace perfetto_pbzero_enum_LayerState_BufferData { +enum PixelFormat : int32_t; +} // namespace perfetto_pbzero_enum_LayerState_BufferData +using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat; +namespace perfetto_pbzero_enum_LayerState { +enum DropInputMode : int32_t; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode; +enum TrustedOverlay : int32_t; +} // Namespace pbzero. +} // Namespace protos. +} // Namespace perfetto. + +namespace perfetto { +namespace protos { +namespace pbzero { + +namespace perfetto_pbzero_enum_DisplayState { +enum Changes : int32_t { + eChangesNone = 0, + eSurfaceChanged = 1, + eLayerStackChanged = 2, + eDisplayProjectionChanged = 4, + eDisplaySizeChanged = 8, + eFlagsChanged = 16, +}; +} // namespace perfetto_pbzero_enum_DisplayState +using DisplayState_Changes = perfetto_pbzero_enum_DisplayState::Changes; + + +constexpr DisplayState_Changes DisplayState_Changes_MIN = DisplayState_Changes::eChangesNone; +constexpr DisplayState_Changes DisplayState_Changes_MAX = DisplayState_Changes::eFlagsChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* DisplayState_Changes_Name(::perfetto::protos::pbzero::DisplayState_Changes value) { + switch (value) { + case ::perfetto::protos::pbzero::DisplayState_Changes::eChangesNone: + return "eChangesNone"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eSurfaceChanged: + return "eSurfaceChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eLayerStackChanged: + return "eLayerStackChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplayProjectionChanged: + return "eDisplayProjectionChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplaySizeChanged: + return "eDisplaySizeChanged"; + + case ::perfetto::protos::pbzero::DisplayState_Changes::eFlagsChanged: + return "eFlagsChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum ChangesLsb : int32_t { + eChangesLsbNone = 0, + ePositionChanged = 1, + eLayerChanged = 2, + eAlphaChanged = 8, + eMatrixChanged = 16, + eTransparentRegionChanged = 32, + eFlagsChanged = 64, + eLayerStackChanged = 128, + eReleaseBufferListenerChanged = 1024, + eShadowRadiusChanged = 2048, + eBufferCropChanged = 8192, + eRelativeLayerChanged = 16384, + eReparent = 32768, + eColorChanged = 65536, + eBufferTransformChanged = 262144, + eTransformToDisplayInverseChanged = 524288, + eCropChanged = 1048576, + eBufferChanged = 2097152, + eAcquireFenceChanged = 4194304, + eDataspaceChanged = 8388608, + eHdrMetadataChanged = 16777216, + eSurfaceDamageRegionChanged = 33554432, + eApiChanged = 67108864, + eSidebandStreamChanged = 134217728, + eColorTransformChanged = 268435456, + eHasListenerCallbacksChanged = 536870912, + eInputInfoChanged = 1073741824, + eCornerRadiusChanged = -2147483648, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_ChangesLsb = perfetto_pbzero_enum_LayerState::ChangesLsb; + + +constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MIN = LayerState_ChangesLsb::eCornerRadiusChanged; +constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MAX = LayerState_ChangesLsb::eInputInfoChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_ChangesLsb_Name(::perfetto::protos::pbzero::LayerState_ChangesLsb value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eChangesLsbNone: + return "eChangesLsbNone"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::ePositionChanged: + return "ePositionChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerChanged: + return "eLayerChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAlphaChanged: + return "eAlphaChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eMatrixChanged: + return "eMatrixChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransparentRegionChanged: + return "eTransparentRegionChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eFlagsChanged: + return "eFlagsChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerStackChanged: + return "eLayerStackChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReleaseBufferListenerChanged: + return "eReleaseBufferListenerChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eShadowRadiusChanged: + return "eShadowRadiusChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferCropChanged: + return "eBufferCropChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eRelativeLayerChanged: + return "eRelativeLayerChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReparent: + return "eReparent"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorChanged: + return "eColorChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferTransformChanged: + return "eBufferTransformChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransformToDisplayInverseChanged: + return "eTransformToDisplayInverseChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCropChanged: + return "eCropChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferChanged: + return "eBufferChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAcquireFenceChanged: + return "eAcquireFenceChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eDataspaceChanged: + return "eDataspaceChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHdrMetadataChanged: + return "eHdrMetadataChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSurfaceDamageRegionChanged: + return "eSurfaceDamageRegionChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eApiChanged: + return "eApiChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSidebandStreamChanged: + return "eSidebandStreamChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorTransformChanged: + return "eColorTransformChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHasListenerCallbacksChanged: + return "eHasListenerCallbacksChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eInputInfoChanged: + return "eInputInfoChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCornerRadiusChanged: + return "eCornerRadiusChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum ChangesMsb : int32_t { + eChangesMsbNone = 0, + eDestinationFrameChanged = 1, + eCachedBufferChanged = 2, + eBackgroundColorChanged = 4, + eMetadataChanged = 8, + eColorSpaceAgnosticChanged = 16, + eFrameRateSelectionPriority = 32, + eFrameRateChanged = 64, + eBackgroundBlurRadiusChanged = 128, + eProducerDisconnect = 256, + eFixedTransformHintChanged = 512, + eFrameNumberChanged = 1024, + eBlurRegionsChanged = 2048, + eAutoRefreshChanged = 4096, + eStretchChanged = 8192, + eTrustedOverlayChanged = 16384, + eDropInputModeChanged = 32768, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_ChangesMsb = perfetto_pbzero_enum_LayerState::ChangesMsb; + + +constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MIN = LayerState_ChangesMsb::eChangesMsbNone; +constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MAX = LayerState_ChangesMsb::eDropInputModeChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_ChangesMsb_Name(::perfetto::protos::pbzero::LayerState_ChangesMsb value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eChangesMsbNone: + return "eChangesMsbNone"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDestinationFrameChanged: + return "eDestinationFrameChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eCachedBufferChanged: + return "eCachedBufferChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundColorChanged: + return "eBackgroundColorChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eMetadataChanged: + return "eMetadataChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eColorSpaceAgnosticChanged: + return "eColorSpaceAgnosticChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateSelectionPriority: + return "eFrameRateSelectionPriority"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateChanged: + return "eFrameRateChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundBlurRadiusChanged: + return "eBackgroundBlurRadiusChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eProducerDisconnect: + return "eProducerDisconnect"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFixedTransformHintChanged: + return "eFixedTransformHintChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameNumberChanged: + return "eFrameNumberChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBlurRegionsChanged: + return "eBlurRegionsChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eAutoRefreshChanged: + return "eAutoRefreshChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eStretchChanged: + return "eStretchChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eTrustedOverlayChanged: + return "eTrustedOverlayChanged"; + + case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDropInputModeChanged: + return "eDropInputModeChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum Flags : int32_t { + eFlagsNone = 0, + eLayerHidden = 1, + eLayerOpaque = 2, + eLayerSkipScreenshot = 64, + eLayerSecure = 128, + eEnableBackpressure = 256, + eLayerIsDisplayDecoration = 512, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_Flags = perfetto_pbzero_enum_LayerState::Flags; + + +constexpr LayerState_Flags LayerState_Flags_MIN = LayerState_Flags::eFlagsNone; +constexpr LayerState_Flags LayerState_Flags_MAX = LayerState_Flags::eLayerIsDisplayDecoration; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_Flags_Name(::perfetto::protos::pbzero::LayerState_Flags value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_Flags::eFlagsNone: + return "eFlagsNone"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerHidden: + return "eLayerHidden"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerOpaque: + return "eLayerOpaque"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSkipScreenshot: + return "eLayerSkipScreenshot"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSecure: + return "eLayerSecure"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eEnableBackpressure: + return "eEnableBackpressure"; + + case ::perfetto::protos::pbzero::LayerState_Flags::eLayerIsDisplayDecoration: + return "eLayerIsDisplayDecoration"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState { +enum DropInputMode : int32_t { + NONE = 0, + ALL = 1, + OBSCURED = 2, +}; +} // namespace perfetto_pbzero_enum_LayerState +using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode; + + +constexpr LayerState_DropInputMode LayerState_DropInputMode_MIN = LayerState_DropInputMode::NONE; +constexpr LayerState_DropInputMode LayerState_DropInputMode_MAX = LayerState_DropInputMode::OBSCURED; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_DropInputMode_Name(::perfetto::protos::pbzero::LayerState_DropInputMode value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_DropInputMode::NONE: + return "NONE"; + + case ::perfetto::protos::pbzero::LayerState_DropInputMode::ALL: + return "ALL"; + + case ::perfetto::protos::pbzero::LayerState_DropInputMode::OBSCURED: + return "OBSCURED"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState_BufferData { +enum BufferDataChange : int32_t { + BufferDataChangeNone = 0, + fenceChanged = 1, + frameNumberChanged = 2, + cachedBufferChanged = 4, +}; +} // namespace perfetto_pbzero_enum_LayerState_BufferData +using LayerState_BufferData_BufferDataChange = perfetto_pbzero_enum_LayerState_BufferData::BufferDataChange; + + +constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MIN = LayerState_BufferData_BufferDataChange::BufferDataChangeNone; +constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MAX = LayerState_BufferData_BufferDataChange::cachedBufferChanged; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_BufferData_BufferDataChange_Name(::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::BufferDataChangeNone: + return "BufferDataChangeNone"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::fenceChanged: + return "fenceChanged"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::frameNumberChanged: + return "frameNumberChanged"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::cachedBufferChanged: + return "cachedBufferChanged"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_LayerState_BufferData { +enum PixelFormat : int32_t { + PIXEL_FORMAT_UNKNOWN = 0, + PIXEL_FORMAT_CUSTOM = -4, + PIXEL_FORMAT_TRANSLUCENT = -3, + PIXEL_FORMAT_TRANSPARENT = -2, + PIXEL_FORMAT_OPAQUE = -1, + PIXEL_FORMAT_RGBA_8888 = 1, + PIXEL_FORMAT_RGBX_8888 = 2, + PIXEL_FORMAT_RGB_888 = 3, + PIXEL_FORMAT_RGB_565 = 4, + PIXEL_FORMAT_BGRA_8888 = 5, + PIXEL_FORMAT_RGBA_5551 = 6, + PIXEL_FORMAT_RGBA_4444 = 7, + PIXEL_FORMAT_RGBA_FP16 = 22, + PIXEL_FORMAT_RGBA_1010102 = 43, + PIXEL_FORMAT_R_8 = 56, +}; +} // namespace perfetto_pbzero_enum_LayerState_BufferData +using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat; + + +constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MIN = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM; +constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MAX = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* LayerState_BufferData_PixelFormat_Name(::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat value) { + switch (value) { + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_UNKNOWN: + return "PIXEL_FORMAT_UNKNOWN"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM: + return "PIXEL_FORMAT_CUSTOM"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSLUCENT: + return "PIXEL_FORMAT_TRANSLUCENT"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSPARENT: + return "PIXEL_FORMAT_TRANSPARENT"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_OPAQUE: + return "PIXEL_FORMAT_OPAQUE"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_8888: + return "PIXEL_FORMAT_RGBA_8888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBX_8888: + return "PIXEL_FORMAT_RGBX_8888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_888: + return "PIXEL_FORMAT_RGB_888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_565: + return "PIXEL_FORMAT_RGB_565"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_BGRA_8888: + return "PIXEL_FORMAT_BGRA_8888"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_5551: + return "PIXEL_FORMAT_RGBA_5551"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_4444: + return "PIXEL_FORMAT_RGBA_4444"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_FP16: + return "PIXEL_FORMAT_RGBA_FP16"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_1010102: + return "PIXEL_FORMAT_RGBA_1010102"; + + case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8: + return "PIXEL_FORMAT_R_8"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +namespace perfetto_pbzero_enum_TransactionTraceFile { +enum MagicNumber : int32_t { + INVALID = 0, + MAGIC_NUMBER_L = 1415073364, + MAGIC_NUMBER_H = 1162035538, +}; +} // namespace perfetto_pbzero_enum_TransactionTraceFile +using TransactionTraceFile_MagicNumber = perfetto_pbzero_enum_TransactionTraceFile::MagicNumber; + + +constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MIN = TransactionTraceFile_MagicNumber::INVALID; +constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MAX = TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L; + + +PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE +const char* TransactionTraceFile_MagicNumber_Name(::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber value) { + switch (value) { + case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::INVALID: + return "INVALID"; + + case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L: + return "MAGIC_NUMBER_L"; + + case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_H: + return "MAGIC_NUMBER_H"; + } + return "PBZERO_UNKNOWN_ENUM_VALUE"; +} + +class DisplayState_Decoder : public ::protozero::TypedProtoDecoder { + public: + DisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_id() const { return at<1>().valid(); } + int32_t id() const { return at<1>().as_int32(); } + bool has_what() const { return at<2>().valid(); } + uint32_t what() const { return at<2>().as_uint32(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_layer_stack() const { return at<4>().valid(); } + uint32_t layer_stack() const { return at<4>().as_uint32(); } + bool has_orientation() const { return at<5>().valid(); } + uint32_t orientation() const { return at<5>().as_uint32(); } + bool has_layer_stack_space_rect() const { return at<6>().valid(); } + ::protozero::ConstBytes layer_stack_space_rect() const { return at<6>().as_bytes(); } + bool has_oriented_display_space_rect() const { return at<7>().valid(); } + ::protozero::ConstBytes oriented_display_space_rect() const { return at<7>().as_bytes(); } + bool has_width() const { return at<8>().valid(); } + uint32_t width() const { return at<8>().as_uint32(); } + bool has_height() const { return at<9>().valid(); } + uint32_t height() const { return at<9>().as_uint32(); } +}; + +class DisplayState : public ::protozero::Message { + public: + using Decoder = DisplayState_Decoder; + enum : int32_t { + kIdFieldNumber = 1, + kWhatFieldNumber = 2, + kFlagsFieldNumber = 3, + kLayerStackFieldNumber = 4, + kOrientationFieldNumber = 5, + kLayerStackSpaceRectFieldNumber = 6, + kOrientedDisplaySpaceRectFieldNumber = 7, + kWidthFieldNumber = 8, + kHeightFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DisplayState"; } + + + using Changes = ::perfetto::protos::pbzero::DisplayState_Changes; + static inline const char* Changes_Name(Changes value) { + return ::perfetto::protos::pbzero::DisplayState_Changes_Name(value); + } + static inline const Changes eChangesNone = Changes::eChangesNone; + static inline const Changes eSurfaceChanged = Changes::eSurfaceChanged; + static inline const Changes eLayerStackChanged = Changes::eLayerStackChanged; + static inline const Changes eDisplayProjectionChanged = Changes::eDisplayProjectionChanged; + static inline const Changes eDisplaySizeChanged = Changes::eDisplaySizeChanged; + static inline const Changes eFlagsChanged = Changes::eFlagsChanged; + + using FieldMetadata_Id = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayState>; + + static constexpr FieldMetadata_Id kId{}; + void set_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_What = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_What kWhat{}; + void set_what(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_What::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Orientation = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Orientation kOrientation{}; + void set_orientation(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Orientation::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStackSpaceRect = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + DisplayState>; + + static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{}; + template T* set_layer_stack_space_rect() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_OrientedDisplaySpaceRect = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + DisplayState>; + + static constexpr FieldMetadata_OrientedDisplaySpaceRect kOrientedDisplaySpaceRect{}; + template T* set_oriented_display_space_rect() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_Width = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Width kWidth{}; + void set_width(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Height = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayState>; + + static constexpr FieldMetadata_Height kHeight{}; + void set_height(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class LayerState_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layer_id() const { return at<1>().valid(); } + uint32_t layer_id() const { return at<1>().as_uint32(); } + bool has_what() const { return at<2>().valid(); } + uint64_t what() const { return at<2>().as_uint64(); } + bool has_x() const { return at<3>().valid(); } + float x() const { return at<3>().as_float(); } + bool has_y() const { return at<4>().valid(); } + float y() const { return at<4>().as_float(); } + bool has_z() const { return at<5>().valid(); } + int32_t z() const { return at<5>().as_int32(); } + bool has_w() const { return at<6>().valid(); } + uint32_t w() const { return at<6>().as_uint32(); } + bool has_h() const { return at<7>().valid(); } + uint32_t h() const { return at<7>().as_uint32(); } + bool has_layer_stack() const { return at<8>().valid(); } + uint32_t layer_stack() const { return at<8>().as_uint32(); } + bool has_flags() const { return at<9>().valid(); } + uint32_t flags() const { return at<9>().as_uint32(); } + bool has_mask() const { return at<10>().valid(); } + uint32_t mask() const { return at<10>().as_uint32(); } + bool has_matrix() const { return at<11>().valid(); } + ::protozero::ConstBytes matrix() const { return at<11>().as_bytes(); } + bool has_corner_radius() const { return at<12>().valid(); } + float corner_radius() const { return at<12>().as_float(); } + bool has_background_blur_radius() const { return at<13>().valid(); } + uint32_t background_blur_radius() const { return at<13>().as_uint32(); } + bool has_parent_id() const { return at<14>().valid(); } + uint32_t parent_id() const { return at<14>().as_uint32(); } + bool has_relative_parent_id() const { return at<15>().valid(); } + uint32_t relative_parent_id() const { return at<15>().as_uint32(); } + bool has_alpha() const { return at<16>().valid(); } + float alpha() const { return at<16>().as_float(); } + bool has_color() const { return at<17>().valid(); } + ::protozero::ConstBytes color() const { return at<17>().as_bytes(); } + bool has_transparent_region() const { return at<18>().valid(); } + ::protozero::ConstBytes transparent_region() const { return at<18>().as_bytes(); } + bool has_transform() const { return at<19>().valid(); } + uint32_t transform() const { return at<19>().as_uint32(); } + bool has_transform_to_display_inverse() const { return at<20>().valid(); } + bool transform_to_display_inverse() const { return at<20>().as_bool(); } + bool has_crop() const { return at<21>().valid(); } + ::protozero::ConstBytes crop() const { return at<21>().as_bytes(); } + bool has_buffer_data() const { return at<22>().valid(); } + ::protozero::ConstBytes buffer_data() const { return at<22>().as_bytes(); } + bool has_api() const { return at<23>().valid(); } + int32_t api() const { return at<23>().as_int32(); } + bool has_has_sideband_stream() const { return at<24>().valid(); } + bool has_sideband_stream() const { return at<24>().as_bool(); } + bool has_color_transform() const { return at<25>().valid(); } + ::protozero::ConstBytes color_transform() const { return at<25>().as_bytes(); } + bool has_blur_regions() const { return at<26>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(26); } + bool has_window_info_handle() const { return at<27>().valid(); } + ::protozero::ConstBytes window_info_handle() const { return at<27>().as_bytes(); } + bool has_bg_color_alpha() const { return at<28>().valid(); } + float bg_color_alpha() const { return at<28>().as_float(); } + bool has_bg_color_dataspace() const { return at<29>().valid(); } + int32_t bg_color_dataspace() const { return at<29>().as_int32(); } + bool has_color_space_agnostic() const { return at<30>().valid(); } + bool color_space_agnostic() const { return at<30>().as_bool(); } + bool has_shadow_radius() const { return at<31>().valid(); } + float shadow_radius() const { return at<31>().as_float(); } + bool has_frame_rate_selection_priority() const { return at<32>().valid(); } + int32_t frame_rate_selection_priority() const { return at<32>().as_int32(); } + bool has_frame_rate() const { return at<33>().valid(); } + float frame_rate() const { return at<33>().as_float(); } + bool has_frame_rate_compatibility() const { return at<34>().valid(); } + int32_t frame_rate_compatibility() const { return at<34>().as_int32(); } + bool has_change_frame_rate_strategy() const { return at<35>().valid(); } + int32_t change_frame_rate_strategy() const { return at<35>().as_int32(); } + bool has_fixed_transform_hint() const { return at<36>().valid(); } + uint32_t fixed_transform_hint() const { return at<36>().as_uint32(); } + bool has_frame_number() const { return at<37>().valid(); } + uint64_t frame_number() const { return at<37>().as_uint64(); } + bool has_auto_refresh() const { return at<38>().valid(); } + bool auto_refresh() const { return at<38>().as_bool(); } + bool has_is_trusted_overlay() const { return at<39>().valid(); } + bool is_trusted_overlay() const { return at<39>().as_bool(); } + bool has_buffer_crop() const { return at<40>().valid(); } + ::protozero::ConstBytes buffer_crop() const { return at<40>().as_bytes(); } + bool has_destination_frame() const { return at<41>().valid(); } + ::protozero::ConstBytes destination_frame() const { return at<41>().as_bytes(); } + bool has_drop_input_mode() const { return at<42>().valid(); } + int32_t drop_input_mode() const { return at<42>().as_int32(); } + bool has_trusted_overlay() const { return at<43>().valid(); } + int32_t trusted_overlay() const { return at<43>().as_int32(); } +}; + +class LayerState : public ::protozero::Message { + public: + using Decoder = LayerState_Decoder; + enum : int32_t { + kLayerIdFieldNumber = 1, + kWhatFieldNumber = 2, + kXFieldNumber = 3, + kYFieldNumber = 4, + kZFieldNumber = 5, + kWFieldNumber = 6, + kHFieldNumber = 7, + kLayerStackFieldNumber = 8, + kFlagsFieldNumber = 9, + kMaskFieldNumber = 10, + kMatrixFieldNumber = 11, + kCornerRadiusFieldNumber = 12, + kBackgroundBlurRadiusFieldNumber = 13, + kParentIdFieldNumber = 14, + kRelativeParentIdFieldNumber = 15, + kAlphaFieldNumber = 16, + kColorFieldNumber = 17, + kTransparentRegionFieldNumber = 18, + kTransformFieldNumber = 19, + kTransformToDisplayInverseFieldNumber = 20, + kCropFieldNumber = 21, + kBufferDataFieldNumber = 22, + kApiFieldNumber = 23, + kHasSidebandStreamFieldNumber = 24, + kColorTransformFieldNumber = 25, + kBlurRegionsFieldNumber = 26, + kWindowInfoHandleFieldNumber = 27, + kBgColorAlphaFieldNumber = 28, + kBgColorDataspaceFieldNumber = 29, + kColorSpaceAgnosticFieldNumber = 30, + kShadowRadiusFieldNumber = 31, + kFrameRateSelectionPriorityFieldNumber = 32, + kFrameRateFieldNumber = 33, + kFrameRateCompatibilityFieldNumber = 34, + kChangeFrameRateStrategyFieldNumber = 35, + kFixedTransformHintFieldNumber = 36, + kFrameNumberFieldNumber = 37, + kAutoRefreshFieldNumber = 38, + kIsTrustedOverlayFieldNumber = 39, + kBufferCropFieldNumber = 40, + kDestinationFrameFieldNumber = 41, + kDropInputModeFieldNumber = 42, + kTrustedOverlayFieldNumber = 43, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState"; } + + using Matrix22 = ::perfetto::protos::pbzero::LayerState_Matrix22; + using Color3 = ::perfetto::protos::pbzero::LayerState_Color3; + using BufferData = ::perfetto::protos::pbzero::LayerState_BufferData; + using WindowInfo = ::perfetto::protos::pbzero::LayerState_WindowInfo; + + using ChangesLsb = ::perfetto::protos::pbzero::LayerState_ChangesLsb; + static inline const char* ChangesLsb_Name(ChangesLsb value) { + return ::perfetto::protos::pbzero::LayerState_ChangesLsb_Name(value); + } + + using ChangesMsb = ::perfetto::protos::pbzero::LayerState_ChangesMsb; + static inline const char* ChangesMsb_Name(ChangesMsb value) { + return ::perfetto::protos::pbzero::LayerState_ChangesMsb_Name(value); + } + + using Flags = ::perfetto::protos::pbzero::LayerState_Flags; + static inline const char* Flags_Name(Flags value) { + return ::perfetto::protos::pbzero::LayerState_Flags_Name(value); + } + + using DropInputMode = ::perfetto::protos::pbzero::LayerState_DropInputMode; + static inline const char* DropInputMode_Name(DropInputMode value) { + return ::perfetto::protos::pbzero::LayerState_DropInputMode_Name(value); + } + static inline const ChangesLsb eChangesLsbNone = ChangesLsb::eChangesLsbNone; + static inline const ChangesLsb ePositionChanged = ChangesLsb::ePositionChanged; + static inline const ChangesLsb eLayerChanged = ChangesLsb::eLayerChanged; + static inline const ChangesLsb eAlphaChanged = ChangesLsb::eAlphaChanged; + static inline const ChangesLsb eMatrixChanged = ChangesLsb::eMatrixChanged; + static inline const ChangesLsb eTransparentRegionChanged = ChangesLsb::eTransparentRegionChanged; + static inline const ChangesLsb eFlagsChanged = ChangesLsb::eFlagsChanged; + static inline const ChangesLsb eLayerStackChanged = ChangesLsb::eLayerStackChanged; + static inline const ChangesLsb eReleaseBufferListenerChanged = ChangesLsb::eReleaseBufferListenerChanged; + static inline const ChangesLsb eShadowRadiusChanged = ChangesLsb::eShadowRadiusChanged; + static inline const ChangesLsb eBufferCropChanged = ChangesLsb::eBufferCropChanged; + static inline const ChangesLsb eRelativeLayerChanged = ChangesLsb::eRelativeLayerChanged; + static inline const ChangesLsb eReparent = ChangesLsb::eReparent; + static inline const ChangesLsb eColorChanged = ChangesLsb::eColorChanged; + static inline const ChangesLsb eBufferTransformChanged = ChangesLsb::eBufferTransformChanged; + static inline const ChangesLsb eTransformToDisplayInverseChanged = ChangesLsb::eTransformToDisplayInverseChanged; + static inline const ChangesLsb eCropChanged = ChangesLsb::eCropChanged; + static inline const ChangesLsb eBufferChanged = ChangesLsb::eBufferChanged; + static inline const ChangesLsb eAcquireFenceChanged = ChangesLsb::eAcquireFenceChanged; + static inline const ChangesLsb eDataspaceChanged = ChangesLsb::eDataspaceChanged; + static inline const ChangesLsb eHdrMetadataChanged = ChangesLsb::eHdrMetadataChanged; + static inline const ChangesLsb eSurfaceDamageRegionChanged = ChangesLsb::eSurfaceDamageRegionChanged; + static inline const ChangesLsb eApiChanged = ChangesLsb::eApiChanged; + static inline const ChangesLsb eSidebandStreamChanged = ChangesLsb::eSidebandStreamChanged; + static inline const ChangesLsb eColorTransformChanged = ChangesLsb::eColorTransformChanged; + static inline const ChangesLsb eHasListenerCallbacksChanged = ChangesLsb::eHasListenerCallbacksChanged; + static inline const ChangesLsb eInputInfoChanged = ChangesLsb::eInputInfoChanged; + static inline const ChangesLsb eCornerRadiusChanged = ChangesLsb::eCornerRadiusChanged; + static inline const ChangesMsb eChangesMsbNone = ChangesMsb::eChangesMsbNone; + static inline const ChangesMsb eDestinationFrameChanged = ChangesMsb::eDestinationFrameChanged; + static inline const ChangesMsb eCachedBufferChanged = ChangesMsb::eCachedBufferChanged; + static inline const ChangesMsb eBackgroundColorChanged = ChangesMsb::eBackgroundColorChanged; + static inline const ChangesMsb eMetadataChanged = ChangesMsb::eMetadataChanged; + static inline const ChangesMsb eColorSpaceAgnosticChanged = ChangesMsb::eColorSpaceAgnosticChanged; + static inline const ChangesMsb eFrameRateSelectionPriority = ChangesMsb::eFrameRateSelectionPriority; + static inline const ChangesMsb eFrameRateChanged = ChangesMsb::eFrameRateChanged; + static inline const ChangesMsb eBackgroundBlurRadiusChanged = ChangesMsb::eBackgroundBlurRadiusChanged; + static inline const ChangesMsb eProducerDisconnect = ChangesMsb::eProducerDisconnect; + static inline const ChangesMsb eFixedTransformHintChanged = ChangesMsb::eFixedTransformHintChanged; + static inline const ChangesMsb eFrameNumberChanged = ChangesMsb::eFrameNumberChanged; + static inline const ChangesMsb eBlurRegionsChanged = ChangesMsb::eBlurRegionsChanged; + static inline const ChangesMsb eAutoRefreshChanged = ChangesMsb::eAutoRefreshChanged; + static inline const ChangesMsb eStretchChanged = ChangesMsb::eStretchChanged; + static inline const ChangesMsb eTrustedOverlayChanged = ChangesMsb::eTrustedOverlayChanged; + static inline const ChangesMsb eDropInputModeChanged = ChangesMsb::eDropInputModeChanged; + static inline const Flags eFlagsNone = Flags::eFlagsNone; + static inline const Flags eLayerHidden = Flags::eLayerHidden; + static inline const Flags eLayerOpaque = Flags::eLayerOpaque; + static inline const Flags eLayerSkipScreenshot = Flags::eLayerSkipScreenshot; + static inline const Flags eLayerSecure = Flags::eLayerSecure; + static inline const Flags eEnableBackpressure = Flags::eEnableBackpressure; + static inline const Flags eLayerIsDisplayDecoration = Flags::eLayerIsDisplayDecoration; + static inline const DropInputMode NONE = DropInputMode::NONE; + static inline const DropInputMode ALL = DropInputMode::ALL; + static inline const DropInputMode OBSCURED = DropInputMode::OBSCURED; + + using FieldMetadata_LayerId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_LayerId kLayerId{}; + void set_layer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_What = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState>; + + static constexpr FieldMetadata_What kWhat{}; + void set_what(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_What::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_X = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_X kX{}; + void set_x(float value) { + static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Y = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_Y kY{}; + void set_y(float value) { + static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Z = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_Z kZ{}; + void set_z(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_W = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_W kW{}; + void set_w(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_W::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_H = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_H kH{}; + void set_h(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_H::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mask = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_Mask kMask{}; + void set_mask(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Matrix = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_Matrix22, + LayerState>; + + static constexpr FieldMetadata_Matrix kMatrix{}; + template T* set_matrix() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_CornerRadius = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_CornerRadius kCornerRadius{}; + void set_corner_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BackgroundBlurRadius = + ::protozero::proto_utils::FieldMetadata< + 13, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{}; + void set_background_blur_radius(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentId = + ::protozero::proto_utils::FieldMetadata< + 14, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_ParentId kParentId{}; + void set_parent_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RelativeParentId = + ::protozero::proto_utils::FieldMetadata< + 15, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_RelativeParentId kRelativeParentId{}; + void set_relative_parent_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RelativeParentId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Alpha = + ::protozero::proto_utils::FieldMetadata< + 16, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_Alpha kAlpha{}; + void set_alpha(float value) { + static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Color = + ::protozero::proto_utils::FieldMetadata< + 17, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_Color3, + LayerState>; + + static constexpr FieldMetadata_Color kColor{}; + template T* set_color() { + return BeginNestedMessage(17); + } + + + using FieldMetadata_TransparentRegion = + ::protozero::proto_utils::FieldMetadata< + 18, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerState>; + + static constexpr FieldMetadata_TransparentRegion kTransparentRegion{}; + template T* set_transparent_region() { + return BeginNestedMessage(18); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 19, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_Transform kTransform{}; + void set_transform(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Transform::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransformToDisplayInverse = + ::protozero::proto_utils::FieldMetadata< + 20, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_TransformToDisplayInverse kTransformToDisplayInverse{}; + void set_transform_to_display_inverse(bool value) { + static constexpr uint32_t field_id = FieldMetadata_TransformToDisplayInverse::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Crop = + ::protozero::proto_utils::FieldMetadata< + 21, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState>; + + static constexpr FieldMetadata_Crop kCrop{}; + template T* set_crop() { + return BeginNestedMessage(21); + } + + + using FieldMetadata_BufferData = + ::protozero::proto_utils::FieldMetadata< + 22, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_BufferData, + LayerState>; + + static constexpr FieldMetadata_BufferData kBufferData{}; + template T* set_buffer_data() { + return BeginNestedMessage(22); + } + + + using FieldMetadata_Api = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_Api kApi{}; + void set_api(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasSidebandStream = + ::protozero::proto_utils::FieldMetadata< + 24, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_HasSidebandStream kHasSidebandStream{}; + void set_has_sideband_stream(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasSidebandStream::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ColorTransform = + ::protozero::proto_utils::FieldMetadata< + 25, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ColorTransformProto, + LayerState>; + + static constexpr FieldMetadata_ColorTransform kColorTransform{}; + template T* set_color_transform() { + return BeginNestedMessage(25); + } + + + using FieldMetadata_BlurRegions = + ::protozero::proto_utils::FieldMetadata< + 26, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + BlurRegion, + LayerState>; + + static constexpr FieldMetadata_BlurRegions kBlurRegions{}; + template T* add_blur_regions() { + return BeginNestedMessage(26); + } + + + using FieldMetadata_WindowInfoHandle = + ::protozero::proto_utils::FieldMetadata< + 27, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState_WindowInfo, + LayerState>; + + static constexpr FieldMetadata_WindowInfoHandle kWindowInfoHandle{}; + template T* set_window_info_handle() { + return BeginNestedMessage(27); + } + + + using FieldMetadata_BgColorAlpha = + ::protozero::proto_utils::FieldMetadata< + 28, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_BgColorAlpha kBgColorAlpha{}; + void set_bg_color_alpha(float value) { + static constexpr uint32_t field_id = FieldMetadata_BgColorAlpha::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BgColorDataspace = + ::protozero::proto_utils::FieldMetadata< + 29, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_BgColorDataspace kBgColorDataspace{}; + void set_bg_color_dataspace(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_BgColorDataspace::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ColorSpaceAgnostic = + ::protozero::proto_utils::FieldMetadata< + 30, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_ColorSpaceAgnostic kColorSpaceAgnostic{}; + void set_color_space_agnostic(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ColorSpaceAgnostic::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ShadowRadius = + ::protozero::proto_utils::FieldMetadata< + 31, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_ShadowRadius kShadowRadius{}; + void set_shadow_radius(float value) { + static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameRateSelectionPriority = + ::protozero::proto_utils::FieldMetadata< + 32, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_FrameRateSelectionPriority kFrameRateSelectionPriority{}; + void set_frame_rate_selection_priority(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameRateSelectionPriority::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameRate = + ::protozero::proto_utils::FieldMetadata< + 33, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState>; + + static constexpr FieldMetadata_FrameRate kFrameRate{}; + void set_frame_rate(float value) { + static constexpr uint32_t field_id = FieldMetadata_FrameRate::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameRateCompatibility = + ::protozero::proto_utils::FieldMetadata< + 34, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_FrameRateCompatibility kFrameRateCompatibility{}; + void set_frame_rate_compatibility(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameRateCompatibility::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ChangeFrameRateStrategy = + ::protozero::proto_utils::FieldMetadata< + 35, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState>; + + static constexpr FieldMetadata_ChangeFrameRateStrategy kChangeFrameRateStrategy{}; + void set_change_frame_rate_strategy(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ChangeFrameRateStrategy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FixedTransformHint = + ::protozero::proto_utils::FieldMetadata< + 36, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState>; + + static constexpr FieldMetadata_FixedTransformHint kFixedTransformHint{}; + void set_fixed_transform_hint(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_FixedTransformHint::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 37, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AutoRefresh = + ::protozero::proto_utils::FieldMetadata< + 38, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_AutoRefresh kAutoRefresh{}; + void set_auto_refresh(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AutoRefresh::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsTrustedOverlay = + ::protozero::proto_utils::FieldMetadata< + 39, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState>; + + static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{}; + void set_is_trusted_overlay(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_BufferCrop = + ::protozero::proto_utils::FieldMetadata< + 40, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState>; + + static constexpr FieldMetadata_BufferCrop kBufferCrop{}; + template T* set_buffer_crop() { + return BeginNestedMessage(40); + } + + + using FieldMetadata_DestinationFrame = + ::protozero::proto_utils::FieldMetadata< + 41, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState>; + + static constexpr FieldMetadata_DestinationFrame kDestinationFrame{}; + template T* set_destination_frame() { + return BeginNestedMessage(41); + } + + + using FieldMetadata_DropInputMode = + ::protozero::proto_utils::FieldMetadata< + 42, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + LayerState_DropInputMode, + LayerState>; + + static constexpr FieldMetadata_DropInputMode kDropInputMode{}; + void set_drop_input_mode(LayerState_DropInputMode value) { + static constexpr uint32_t field_id = FieldMetadata_DropInputMode::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TrustedOverlay = + ::protozero::proto_utils::FieldMetadata< + 43, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + TrustedOverlay, + LayerState>; + + static constexpr FieldMetadata_TrustedOverlay kTrustedOverlay{}; + void set_trusted_overlay(TrustedOverlay value) { + static constexpr uint32_t field_id = FieldMetadata_TrustedOverlay::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } +}; + +class LayerState_WindowInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_WindowInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_WindowInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_WindowInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layout_params_flags() const { return at<1>().valid(); } + uint32_t layout_params_flags() const { return at<1>().as_uint32(); } + bool has_layout_params_type() const { return at<2>().valid(); } + int32_t layout_params_type() const { return at<2>().as_int32(); } + bool has_touchable_region() const { return at<3>().valid(); } + ::protozero::ConstBytes touchable_region() const { return at<3>().as_bytes(); } + bool has_surface_inset() const { return at<4>().valid(); } + int32_t surface_inset() const { return at<4>().as_int32(); } + bool has_focusable() const { return at<5>().valid(); } + bool focusable() const { return at<5>().as_bool(); } + bool has_has_wallpaper() const { return at<6>().valid(); } + bool has_wallpaper() const { return at<6>().as_bool(); } + bool has_global_scale_factor() const { return at<7>().valid(); } + float global_scale_factor() const { return at<7>().as_float(); } + bool has_crop_layer_id() const { return at<8>().valid(); } + uint32_t crop_layer_id() const { return at<8>().as_uint32(); } + bool has_replace_touchable_region_with_crop() const { return at<9>().valid(); } + bool replace_touchable_region_with_crop() const { return at<9>().as_bool(); } + bool has_touchable_region_crop() const { return at<10>().valid(); } + ::protozero::ConstBytes touchable_region_crop() const { return at<10>().as_bytes(); } + bool has_transform() const { return at<11>().valid(); } + ::protozero::ConstBytes transform() const { return at<11>().as_bytes(); } + bool has_input_config() const { return at<12>().valid(); } + uint32_t input_config() const { return at<12>().as_uint32(); } +}; + +class LayerState_WindowInfo : public ::protozero::Message { + public: + using Decoder = LayerState_WindowInfo_Decoder; + enum : int32_t { + kLayoutParamsFlagsFieldNumber = 1, + kLayoutParamsTypeFieldNumber = 2, + kTouchableRegionFieldNumber = 3, + kSurfaceInsetFieldNumber = 4, + kFocusableFieldNumber = 5, + kHasWallpaperFieldNumber = 6, + kGlobalScaleFactorFieldNumber = 7, + kCropLayerIdFieldNumber = 8, + kReplaceTouchableRegionWithCropFieldNumber = 9, + kTouchableRegionCropFieldNumber = 10, + kTransformFieldNumber = 11, + kInputConfigFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.WindowInfo"; } + + + using FieldMetadata_LayoutParamsFlags = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{}; + void set_layout_params_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayoutParamsType = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{}; + void set_layout_params_type(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchableRegion = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RegionProto, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_TouchableRegion kTouchableRegion{}; + template T* set_touchable_region() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_SurfaceInset = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_SurfaceInset kSurfaceInset{}; + void set_surface_inset(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Focusable = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_Focusable kFocusable{}; + void set_focusable(bool value) { + static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_HasWallpaper = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_HasWallpaper kHasWallpaper{}; + void set_has_wallpaper(bool value) { + static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GlobalScaleFactor = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{}; + void set_global_scale_factor(float value) { + static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CropLayerId = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_CropLayerId kCropLayerId{}; + void set_crop_layer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ReplaceTouchableRegionWithCrop = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{}; + void set_replace_touchable_region_with_crop(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TouchableRegionCrop = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + RectProto, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{}; + template T* set_touchable_region_crop() { + return BeginNestedMessage(10); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Transform, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(11); + } + + + using FieldMetadata_InputConfig = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_WindowInfo>; + + static constexpr FieldMetadata_InputConfig kInputConfig{}; + void set_input_config(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class LayerState_BufferData_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_BufferData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_BufferData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_BufferData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_buffer_id() const { return at<1>().valid(); } + uint64_t buffer_id() const { return at<1>().as_uint64(); } + bool has_width() const { return at<2>().valid(); } + uint32_t width() const { return at<2>().as_uint32(); } + bool has_height() const { return at<3>().valid(); } + uint32_t height() const { return at<3>().as_uint32(); } + bool has_frame_number() const { return at<4>().valid(); } + uint64_t frame_number() const { return at<4>().as_uint64(); } + bool has_flags() const { return at<5>().valid(); } + uint32_t flags() const { return at<5>().as_uint32(); } + bool has_cached_buffer_id() const { return at<6>().valid(); } + uint64_t cached_buffer_id() const { return at<6>().as_uint64(); } + bool has_pixel_format() const { return at<7>().valid(); } + int32_t pixel_format() const { return at<7>().as_int32(); } + bool has_usage() const { return at<8>().valid(); } + uint64_t usage() const { return at<8>().as_uint64(); } +}; + +class LayerState_BufferData : public ::protozero::Message { + public: + using Decoder = LayerState_BufferData_Decoder; + enum : int32_t { + kBufferIdFieldNumber = 1, + kWidthFieldNumber = 2, + kHeightFieldNumber = 3, + kFrameNumberFieldNumber = 4, + kFlagsFieldNumber = 5, + kCachedBufferIdFieldNumber = 6, + kPixelFormatFieldNumber = 7, + kUsageFieldNumber = 8, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.BufferData"; } + + + using BufferDataChange = ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange; + static inline const char* BufferDataChange_Name(BufferDataChange value) { + return ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange_Name(value); + } + + using PixelFormat = ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat; + static inline const char* PixelFormat_Name(PixelFormat value) { + return ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat_Name(value); + } + static inline const BufferDataChange BufferDataChangeNone = BufferDataChange::BufferDataChangeNone; + static inline const BufferDataChange fenceChanged = BufferDataChange::fenceChanged; + static inline const BufferDataChange frameNumberChanged = BufferDataChange::frameNumberChanged; + static inline const BufferDataChange cachedBufferChanged = BufferDataChange::cachedBufferChanged; + static inline const PixelFormat PIXEL_FORMAT_UNKNOWN = PixelFormat::PIXEL_FORMAT_UNKNOWN; + static inline const PixelFormat PIXEL_FORMAT_CUSTOM = PixelFormat::PIXEL_FORMAT_CUSTOM; + static inline const PixelFormat PIXEL_FORMAT_TRANSLUCENT = PixelFormat::PIXEL_FORMAT_TRANSLUCENT; + static inline const PixelFormat PIXEL_FORMAT_TRANSPARENT = PixelFormat::PIXEL_FORMAT_TRANSPARENT; + static inline const PixelFormat PIXEL_FORMAT_OPAQUE = PixelFormat::PIXEL_FORMAT_OPAQUE; + static inline const PixelFormat PIXEL_FORMAT_RGBA_8888 = PixelFormat::PIXEL_FORMAT_RGBA_8888; + static inline const PixelFormat PIXEL_FORMAT_RGBX_8888 = PixelFormat::PIXEL_FORMAT_RGBX_8888; + static inline const PixelFormat PIXEL_FORMAT_RGB_888 = PixelFormat::PIXEL_FORMAT_RGB_888; + static inline const PixelFormat PIXEL_FORMAT_RGB_565 = PixelFormat::PIXEL_FORMAT_RGB_565; + static inline const PixelFormat PIXEL_FORMAT_BGRA_8888 = PixelFormat::PIXEL_FORMAT_BGRA_8888; + static inline const PixelFormat PIXEL_FORMAT_RGBA_5551 = PixelFormat::PIXEL_FORMAT_RGBA_5551; + static inline const PixelFormat PIXEL_FORMAT_RGBA_4444 = PixelFormat::PIXEL_FORMAT_RGBA_4444; + static inline const PixelFormat PIXEL_FORMAT_RGBA_FP16 = PixelFormat::PIXEL_FORMAT_RGBA_FP16; + static inline const PixelFormat PIXEL_FORMAT_RGBA_1010102 = PixelFormat::PIXEL_FORMAT_RGBA_1010102; + static inline const PixelFormat PIXEL_FORMAT_R_8 = PixelFormat::PIXEL_FORMAT_R_8; + + using FieldMetadata_BufferId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_BufferId kBufferId{}; + void set_buffer_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Width = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Width kWidth{}; + void set_width(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Height = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Height kHeight{}; + void set_height(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_FrameNumber = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_FrameNumber kFrameNumber{}; + void set_frame_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CachedBufferId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_CachedBufferId kCachedBufferId{}; + void set_cached_buffer_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_CachedBufferId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PixelFormat = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kEnum, + LayerState_BufferData_PixelFormat, + LayerState_BufferData>; + + static constexpr FieldMetadata_PixelFormat kPixelFormat{}; + void set_pixel_format(LayerState_BufferData_PixelFormat value) { + static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kEnum> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Usage = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + LayerState_BufferData>; + + static constexpr FieldMetadata_Usage kUsage{}; + void set_usage(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class LayerState_Color3_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_Color3_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_Color3_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_Color3_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_r() const { return at<1>().valid(); } + float r() const { return at<1>().as_float(); } + bool has_g() const { return at<2>().valid(); } + float g() const { return at<2>().as_float(); } + bool has_b() const { return at<3>().valid(); } + float b() const { return at<3>().as_float(); } +}; + +class LayerState_Color3 : public ::protozero::Message { + public: + using Decoder = LayerState_Color3_Decoder; + enum : int32_t { + kRFieldNumber = 1, + kGFieldNumber = 2, + kBFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Color3"; } + + + using FieldMetadata_R = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Color3>; + + static constexpr FieldMetadata_R kR{}; + void set_r(float value) { + static constexpr uint32_t field_id = FieldMetadata_R::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_G = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Color3>; + + static constexpr FieldMetadata_G kG{}; + void set_g(float value) { + static constexpr uint32_t field_id = FieldMetadata_G::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_B = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Color3>; + + static constexpr FieldMetadata_B kB{}; + void set_b(float value) { + static constexpr uint32_t field_id = FieldMetadata_B::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class LayerState_Matrix22_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerState_Matrix22_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerState_Matrix22_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerState_Matrix22_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dsdx() const { return at<1>().valid(); } + float dsdx() const { return at<1>().as_float(); } + bool has_dtdx() const { return at<2>().valid(); } + float dtdx() const { return at<2>().as_float(); } + bool has_dtdy() const { return at<3>().valid(); } + float dtdy() const { return at<3>().as_float(); } + bool has_dsdy() const { return at<4>().valid(); } + float dsdy() const { return at<4>().as_float(); } +}; + +class LayerState_Matrix22 : public ::protozero::Message { + public: + using Decoder = LayerState_Matrix22_Decoder; + enum : int32_t { + kDsdxFieldNumber = 1, + kDtdxFieldNumber = 2, + kDtdyFieldNumber = 3, + kDsdyFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Matrix22"; } + + + using FieldMetadata_Dsdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dsdx kDsdx{}; + void set_dsdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dtdx kDtdx{}; + void set_dtdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dtdy kDtdy{}; + void set_dtdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dsdy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + LayerState_Matrix22>; + + static constexpr FieldMetadata_Dsdy kDsdy{}; + void set_dsdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class TransactionState_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransactionState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransactionState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransactionState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_pid() const { return at<1>().valid(); } + int32_t pid() const { return at<1>().as_int32(); } + bool has_uid() const { return at<2>().valid(); } + int32_t uid() const { return at<2>().as_int32(); } + bool has_vsync_id() const { return at<3>().valid(); } + int64_t vsync_id() const { return at<3>().as_int64(); } + bool has_input_event_id() const { return at<4>().valid(); } + int32_t input_event_id() const { return at<4>().as_int32(); } + bool has_post_time() const { return at<5>().valid(); } + int64_t post_time() const { return at<5>().as_int64(); } + bool has_transaction_id() const { return at<6>().valid(); } + uint64_t transaction_id() const { return at<6>().as_uint64(); } + bool has_layer_changes() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layer_changes() const { return GetRepeated<::protozero::ConstBytes>(7); } + bool has_display_changes() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> display_changes() const { return GetRepeated<::protozero::ConstBytes>(8); } + bool has_merged_transaction_ids() const { return at<9>().valid(); } + ::protozero::RepeatedFieldIterator merged_transaction_ids() const { return GetRepeated(9); } +}; + +class TransactionState : public ::protozero::Message { + public: + using Decoder = TransactionState_Decoder; + enum : int32_t { + kPidFieldNumber = 1, + kUidFieldNumber = 2, + kVsyncIdFieldNumber = 3, + kInputEventIdFieldNumber = 4, + kPostTimeFieldNumber = 5, + kTransactionIdFieldNumber = 6, + kLayerChangesFieldNumber = 7, + kDisplayChangesFieldNumber = 8, + kMergedTransactionIdsFieldNumber = 9, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransactionState"; } + + + using FieldMetadata_Pid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionState>; + + static constexpr FieldMetadata_Pid kPid{}; + void set_pid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Uid = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionState>; + + static constexpr FieldMetadata_Uid kUid{}; + void set_uid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionState>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InputEventId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionState>; + + static constexpr FieldMetadata_InputEventId kInputEventId{}; + void set_input_event_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_InputEventId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PostTime = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionState>; + + static constexpr FieldMetadata_PostTime kPostTime{}; + void set_post_time(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_PostTime::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransactionId = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TransactionState>; + + static constexpr FieldMetadata_TransactionId kTransactionId{}; + void set_transaction_id(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_TransactionId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerChanges = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerState, + TransactionState>; + + static constexpr FieldMetadata_LayerChanges kLayerChanges{}; + template T* add_layer_changes() { + return BeginNestedMessage(7); + } + + + using FieldMetadata_DisplayChanges = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayState, + TransactionState>; + + static constexpr FieldMetadata_DisplayChanges kDisplayChanges{}; + template T* add_display_changes() { + return BeginNestedMessage(8); + } + + + using FieldMetadata_MergedTransactionIds = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + TransactionState>; + + static constexpr FieldMetadata_MergedTransactionIds kMergedTransactionIds{}; + void add_merged_transaction_ids(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MergedTransactionIds::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class Transform_Decoder : public ::protozero::TypedProtoDecoder { + public: + Transform_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit Transform_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit Transform_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_dsdx() const { return at<1>().valid(); } + float dsdx() const { return at<1>().as_float(); } + bool has_dtdx() const { return at<2>().valid(); } + float dtdx() const { return at<2>().as_float(); } + bool has_dtdy() const { return at<3>().valid(); } + float dtdy() const { return at<3>().as_float(); } + bool has_dsdy() const { return at<4>().valid(); } + float dsdy() const { return at<4>().as_float(); } + bool has_tx() const { return at<5>().valid(); } + float tx() const { return at<5>().as_float(); } + bool has_ty() const { return at<6>().valid(); } + float ty() const { return at<6>().as_float(); } +}; + +class Transform : public ::protozero::Message { + public: + using Decoder = Transform_Decoder; + enum : int32_t { + kDsdxFieldNumber = 1, + kDtdxFieldNumber = 2, + kDtdyFieldNumber = 3, + kDsdyFieldNumber = 4, + kTxFieldNumber = 5, + kTyFieldNumber = 6, + }; + static constexpr const char* GetName() { return ".perfetto.protos.Transform"; } + + + using FieldMetadata_Dsdx = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dsdx kDsdx{}; + void set_dsdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdx = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dtdx kDtdx{}; + void set_dtdx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dtdy = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dtdy kDtdy{}; + void set_dtdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Dsdy = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Dsdy kDsdy{}; + void set_dsdy(float value) { + static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Tx = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Tx kTx{}; + void set_tx(float value) { + static constexpr uint32_t field_id = FieldMetadata_Tx::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Ty = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFloat, + float, + Transform>; + + static constexpr FieldMetadata_Ty kTy{}; + void set_ty(float value) { + static constexpr uint32_t field_id = FieldMetadata_Ty::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFloat> + ::Append(*this, field_id, value); + } +}; + +class LayerCreationArgs_Decoder : public ::protozero::TypedProtoDecoder { + public: + LayerCreationArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit LayerCreationArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit LayerCreationArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layer_id() const { return at<1>().valid(); } + uint32_t layer_id() const { return at<1>().as_uint32(); } + bool has_name() const { return at<2>().valid(); } + ::protozero::ConstChars name() const { return at<2>().as_string(); } + bool has_flags() const { return at<3>().valid(); } + uint32_t flags() const { return at<3>().as_uint32(); } + bool has_parent_id() const { return at<4>().valid(); } + uint32_t parent_id() const { return at<4>().as_uint32(); } + bool has_mirror_from_id() const { return at<5>().valid(); } + uint32_t mirror_from_id() const { return at<5>().as_uint32(); } + bool has_add_to_root() const { return at<6>().valid(); } + bool add_to_root() const { return at<6>().as_bool(); } + bool has_layer_stack_to_mirror() const { return at<7>().valid(); } + uint32_t layer_stack_to_mirror() const { return at<7>().as_uint32(); } +}; + +class LayerCreationArgs : public ::protozero::Message { + public: + using Decoder = LayerCreationArgs_Decoder; + enum : int32_t { + kLayerIdFieldNumber = 1, + kNameFieldNumber = 2, + kFlagsFieldNumber = 3, + kParentIdFieldNumber = 4, + kMirrorFromIdFieldNumber = 5, + kAddToRootFieldNumber = 6, + kLayerStackToMirrorFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.LayerCreationArgs"; } + + + using FieldMetadata_LayerId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_LayerId kLayerId{}; + void set_layer_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Name = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + LayerCreationArgs>; + + static constexpr FieldMetadata_Name kName{}; + void set_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_Name::kFieldId, data, size); + } + void set_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + } + void set_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Flags = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_Flags kFlags{}; + void set_flags(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_ParentId = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_ParentId kParentId{}; + void set_parent_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_MirrorFromId = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_MirrorFromId kMirrorFromId{}; + void set_mirror_from_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_MirrorFromId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AddToRoot = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + LayerCreationArgs>; + + static constexpr FieldMetadata_AddToRoot kAddToRoot{}; + void set_add_to_root(bool value) { + static constexpr uint32_t field_id = FieldMetadata_AddToRoot::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LayerStackToMirror = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + LayerCreationArgs>; + + static constexpr FieldMetadata_LayerStackToMirror kLayerStackToMirror{}; + void set_layer_stack_to_mirror(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStackToMirror::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + +class DisplayInfo_Decoder : public ::protozero::TypedProtoDecoder { + public: + DisplayInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DisplayInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DisplayInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_layer_stack() const { return at<1>().valid(); } + uint32_t layer_stack() const { return at<1>().as_uint32(); } + bool has_display_id() const { return at<2>().valid(); } + int32_t display_id() const { return at<2>().as_int32(); } + bool has_logical_width() const { return at<3>().valid(); } + int32_t logical_width() const { return at<3>().as_int32(); } + bool has_logical_height() const { return at<4>().valid(); } + int32_t logical_height() const { return at<4>().as_int32(); } + bool has_transform_inverse() const { return at<5>().valid(); } + ::protozero::ConstBytes transform_inverse() const { return at<5>().as_bytes(); } + bool has_transform() const { return at<6>().valid(); } + ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); } + bool has_receives_input() const { return at<7>().valid(); } + bool receives_input() const { return at<7>().as_bool(); } + bool has_is_secure() const { return at<8>().valid(); } + bool is_secure() const { return at<8>().as_bool(); } + bool has_is_primary() const { return at<9>().valid(); } + bool is_primary() const { return at<9>().as_bool(); } + bool has_is_virtual() const { return at<10>().valid(); } + bool is_virtual() const { return at<10>().as_bool(); } + bool has_rotation_flags() const { return at<11>().valid(); } + int32_t rotation_flags() const { return at<11>().as_int32(); } + bool has_transform_hint() const { return at<12>().valid(); } + int32_t transform_hint() const { return at<12>().as_int32(); } +}; + +class DisplayInfo : public ::protozero::Message { + public: + using Decoder = DisplayInfo_Decoder; + enum : int32_t { + kLayerStackFieldNumber = 1, + kDisplayIdFieldNumber = 2, + kLogicalWidthFieldNumber = 3, + kLogicalHeightFieldNumber = 4, + kTransformInverseFieldNumber = 5, + kTransformFieldNumber = 6, + kReceivesInputFieldNumber = 7, + kIsSecureFieldNumber = 8, + kIsPrimaryFieldNumber = 9, + kIsVirtualFieldNumber = 10, + kRotationFlagsFieldNumber = 11, + kTransformHintFieldNumber = 12, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DisplayInfo"; } + + + using FieldMetadata_LayerStack = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + DisplayInfo>; + + static constexpr FieldMetadata_LayerStack kLayerStack{}; + void set_layer_stack(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplayId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_DisplayId kDisplayId{}; + void set_display_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogicalWidth = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_LogicalWidth kLogicalWidth{}; + void set_logical_width(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LogicalWidth::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_LogicalHeight = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_LogicalHeight kLogicalHeight{}; + void set_logical_height(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_LogicalHeight::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransformInverse = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Transform, + DisplayInfo>; + + static constexpr FieldMetadata_TransformInverse kTransformInverse{}; + template T* set_transform_inverse() { + return BeginNestedMessage(5); + } + + + using FieldMetadata_Transform = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + Transform, + DisplayInfo>; + + static constexpr FieldMetadata_Transform kTransform{}; + template T* set_transform() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_ReceivesInput = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_ReceivesInput kReceivesInput{}; + void set_receives_input(bool value) { + static constexpr uint32_t field_id = FieldMetadata_ReceivesInput::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsSecure = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_IsSecure kIsSecure{}; + void set_is_secure(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsSecure::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsPrimary = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_IsPrimary kIsPrimary{}; + void set_is_primary(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsPrimary::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_IsVirtual = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + DisplayInfo>; + + static constexpr FieldMetadata_IsVirtual kIsVirtual{}; + void set_is_virtual(bool value) { + static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_RotationFlags = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_RotationFlags kRotationFlags{}; + void set_rotation_flags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RotationFlags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TransformHint = + ::protozero::proto_utils::FieldMetadata< + 12, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DisplayInfo>; + + static constexpr FieldMetadata_TransformHint kTransformHint{}; + void set_transform_hint(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TransformHint::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class TransactionTraceEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransactionTraceEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransactionTraceEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransactionTraceEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_elapsed_realtime_nanos() const { return at<1>().valid(); } + int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); } + bool has_vsync_id() const { return at<2>().valid(); } + int64_t vsync_id() const { return at<2>().as_int64(); } + bool has_transactions() const { return at<3>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> transactions() const { return GetRepeated<::protozero::ConstBytes>(3); } + bool has_added_layers() const { return at<4>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_layers() const { return GetRepeated<::protozero::ConstBytes>(4); } + bool has_destroyed_layers() const { return at<5>().valid(); } + ::protozero::RepeatedFieldIterator destroyed_layers() const { return GetRepeated(5); } + bool has_added_displays() const { return at<6>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_displays() const { return GetRepeated<::protozero::ConstBytes>(6); } + bool has_removed_displays() const { return at<7>().valid(); } + ::protozero::RepeatedFieldIterator removed_displays() const { return GetRepeated(7); } + bool has_destroyed_layer_handles() const { return at<8>().valid(); } + ::protozero::RepeatedFieldIterator destroyed_layer_handles() const { return GetRepeated(8); } + bool has_displays_changed() const { return at<9>().valid(); } + bool displays_changed() const { return at<9>().as_bool(); } + bool has_displays() const { return at<10>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(10); } +}; + +class TransactionTraceEntry : public ::protozero::Message { + public: + using Decoder = TransactionTraceEntry_Decoder; + enum : int32_t { + kElapsedRealtimeNanosFieldNumber = 1, + kVsyncIdFieldNumber = 2, + kTransactionsFieldNumber = 3, + kAddedLayersFieldNumber = 4, + kDestroyedLayersFieldNumber = 5, + kAddedDisplaysFieldNumber = 6, + kRemovedDisplaysFieldNumber = 7, + kDestroyedLayerHandlesFieldNumber = 8, + kDisplaysChangedFieldNumber = 9, + kDisplaysFieldNumber = 10, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceEntry"; } + + + using FieldMetadata_ElapsedRealtimeNanos = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{}; + void set_elapsed_realtime_nanos(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_VsyncId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt64, + int64_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_VsyncId kVsyncId{}; + void set_vsync_id(int64_t value) { + static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Transactions = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransactionState, + TransactionTraceEntry>; + + static constexpr FieldMetadata_Transactions kTransactions{}; + template T* add_transactions() { + return BeginNestedMessage(3); + } + + + using FieldMetadata_AddedLayers = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + LayerCreationArgs, + TransactionTraceEntry>; + + static constexpr FieldMetadata_AddedLayers kAddedLayers{}; + template T* add_added_layers() { + return BeginNestedMessage(4); + } + + + using FieldMetadata_DestroyedLayers = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_DestroyedLayers kDestroyedLayers{}; + void add_destroyed_layers(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DestroyedLayers::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_AddedDisplays = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayState, + TransactionTraceEntry>; + + static constexpr FieldMetadata_AddedDisplays kAddedDisplays{}; + template T* add_added_displays() { + return BeginNestedMessage(6); + } + + + using FieldMetadata_RemovedDisplays = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_RemovedDisplays kRemovedDisplays{}; + void add_removed_displays(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_RemovedDisplays::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DestroyedLayerHandles = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TransactionTraceEntry>; + + static constexpr FieldMetadata_DestroyedLayerHandles kDestroyedLayerHandles{}; + void add_destroyed_layer_handles(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_DestroyedLayerHandles::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_DisplaysChanged = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kBool, + bool, + TransactionTraceEntry>; + + static constexpr FieldMetadata_DisplaysChanged kDisplaysChanged{}; + void set_displays_changed(bool value) { + static constexpr uint32_t field_id = FieldMetadata_DisplaysChanged::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kBool> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Displays = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DisplayInfo, + TransactionTraceEntry>; + + static constexpr FieldMetadata_Displays kDisplays{}; + template T* add_displays() { + return BeginNestedMessage(10); + } + +}; + +class TransactionTraceFile_Decoder : public ::protozero::TypedProtoDecoder { + public: + TransactionTraceFile_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit TransactionTraceFile_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit TransactionTraceFile_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_magic_number() const { return at<1>().valid(); } + uint64_t magic_number() const { return at<1>().as_uint64(); } + bool has_entry() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); } + bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); } + uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); } + bool has_version() const { return at<4>().valid(); } + uint32_t version() const { return at<4>().as_uint32(); } +}; + +class TransactionTraceFile : public ::protozero::Message { + public: + using Decoder = TransactionTraceFile_Decoder; + enum : int32_t { + kMagicNumberFieldNumber = 1, + kEntryFieldNumber = 2, + kRealToElapsedTimeOffsetNanosFieldNumber = 3, + kVersionFieldNumber = 4, + }; + static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceFile"; } + + + using MagicNumber = ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber; + static inline const char* MagicNumber_Name(MagicNumber value) { + return ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber_Name(value); + } + static inline const MagicNumber INVALID = MagicNumber::INVALID; + static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L; + static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H; + + using FieldMetadata_MagicNumber = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TransactionTraceFile>; + + static constexpr FieldMetadata_MagicNumber kMagicNumber{}; + void set_magic_number(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Entry = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + TransactionTraceEntry, + TransactionTraceFile>; + + static constexpr FieldMetadata_Entry kEntry{}; + template T* add_entry() { + return BeginNestedMessage(2); + } + + + using FieldMetadata_RealToElapsedTimeOffsetNanos = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed64, + uint64_t, + TransactionTraceFile>; + + static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{}; + void set_real_to_elapsed_time_offset_nanos(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Version = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + TransactionTraceFile>; + + static constexpr FieldMetadata_Version kVersion{}; + void set_version(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -53503,1205 +62020,6 @@ class AndroidGameInterventionList_GameModeInfo : public ::protozero::Message { } }; -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/android_input_event.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_INPUT_EVENT_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_ANDROID_INPUT_EVENT_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class AndroidKeyEvent; -class AndroidMotionEvent; -class AndroidMotionEvent_Pointer; -class AndroidMotionEvent_Pointer_AxisValue; -class AndroidWindowInputDispatchEvent; -class AndroidWindowInputDispatchEvent_DispatchedPointer; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -class AndroidInputEvent_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidInputEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidInputEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidInputEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_dispatcher_motion_event() const { return at<1>().valid(); } - ::protozero::ConstBytes dispatcher_motion_event() const { return at<1>().as_bytes(); } - bool has_dispatcher_motion_event_redacted() const { return at<2>().valid(); } - ::protozero::ConstBytes dispatcher_motion_event_redacted() const { return at<2>().as_bytes(); } - bool has_dispatcher_key_event() const { return at<3>().valid(); } - ::protozero::ConstBytes dispatcher_key_event() const { return at<3>().as_bytes(); } - bool has_dispatcher_key_event_redacted() const { return at<4>().valid(); } - ::protozero::ConstBytes dispatcher_key_event_redacted() const { return at<4>().as_bytes(); } - bool has_dispatcher_window_dispatch_event() const { return at<5>().valid(); } - ::protozero::ConstBytes dispatcher_window_dispatch_event() const { return at<5>().as_bytes(); } - bool has_dispatcher_window_dispatch_event_redacted() const { return at<6>().valid(); } - ::protozero::ConstBytes dispatcher_window_dispatch_event_redacted() const { return at<6>().as_bytes(); } -}; - -class AndroidInputEvent : public ::protozero::Message { - public: - using Decoder = AndroidInputEvent_Decoder; - enum : int32_t { - kDispatcherMotionEventFieldNumber = 1, - kDispatcherMotionEventRedactedFieldNumber = 2, - kDispatcherKeyEventFieldNumber = 3, - kDispatcherKeyEventRedactedFieldNumber = 4, - kDispatcherWindowDispatchEventFieldNumber = 5, - kDispatcherWindowDispatchEventRedactedFieldNumber = 6, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidInputEvent"; } - - - using FieldMetadata_DispatcherMotionEvent = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidMotionEvent, - AndroidInputEvent>; - - static constexpr FieldMetadata_DispatcherMotionEvent kDispatcherMotionEvent{}; - template T* set_dispatcher_motion_event() { - return BeginNestedMessage(1); - } - - - using FieldMetadata_DispatcherMotionEventRedacted = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidMotionEvent, - AndroidInputEvent>; - - static constexpr FieldMetadata_DispatcherMotionEventRedacted kDispatcherMotionEventRedacted{}; - template T* set_dispatcher_motion_event_redacted() { - return BeginNestedMessage(2); - } - - - using FieldMetadata_DispatcherKeyEvent = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidKeyEvent, - AndroidInputEvent>; - - static constexpr FieldMetadata_DispatcherKeyEvent kDispatcherKeyEvent{}; - template T* set_dispatcher_key_event() { - return BeginNestedMessage(3); - } - - - using FieldMetadata_DispatcherKeyEventRedacted = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidKeyEvent, - AndroidInputEvent>; - - static constexpr FieldMetadata_DispatcherKeyEventRedacted kDispatcherKeyEventRedacted{}; - template T* set_dispatcher_key_event_redacted() { - return BeginNestedMessage(4); - } - - - using FieldMetadata_DispatcherWindowDispatchEvent = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidWindowInputDispatchEvent, - AndroidInputEvent>; - - static constexpr FieldMetadata_DispatcherWindowDispatchEvent kDispatcherWindowDispatchEvent{}; - template T* set_dispatcher_window_dispatch_event() { - return BeginNestedMessage(5); - } - - - using FieldMetadata_DispatcherWindowDispatchEventRedacted = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidWindowInputDispatchEvent, - AndroidInputEvent>; - - static constexpr FieldMetadata_DispatcherWindowDispatchEventRedacted kDispatcherWindowDispatchEventRedacted{}; - template T* set_dispatcher_window_dispatch_event_redacted() { - return BeginNestedMessage(6); - } - -}; - -class AndroidWindowInputDispatchEvent_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidWindowInputDispatchEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidWindowInputDispatchEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidWindowInputDispatchEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_event_id() const { return at<1>().valid(); } - uint32_t event_id() const { return at<1>().as_uint32(); } - bool has_vsync_id() const { return at<2>().valid(); } - int64_t vsync_id() const { return at<2>().as_int64(); } - bool has_window_id() const { return at<3>().valid(); } - int32_t window_id() const { return at<3>().as_int32(); } - bool has_dispatched_pointer() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> dispatched_pointer() const { return GetRepeated<::protozero::ConstBytes>(4); } - bool has_resolved_flags() const { return at<5>().valid(); } - uint32_t resolved_flags() const { return at<5>().as_uint32(); } -}; - -class AndroidWindowInputDispatchEvent : public ::protozero::Message { - public: - using Decoder = AndroidWindowInputDispatchEvent_Decoder; - enum : int32_t { - kEventIdFieldNumber = 1, - kVsyncIdFieldNumber = 2, - kWindowIdFieldNumber = 3, - kDispatchedPointerFieldNumber = 4, - kResolvedFlagsFieldNumber = 5, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidWindowInputDispatchEvent"; } - - using DispatchedPointer = ::perfetto::protos::pbzero::AndroidWindowInputDispatchEvent_DispatchedPointer; - - using FieldMetadata_EventId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed32, - uint32_t, - AndroidWindowInputDispatchEvent>; - - static constexpr FieldMetadata_EventId kEventId{}; - void set_event_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_VsyncId = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidWindowInputDispatchEvent>; - - static constexpr FieldMetadata_VsyncId kVsyncId{}; - void set_vsync_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_WindowId = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidWindowInputDispatchEvent>; - - static constexpr FieldMetadata_WindowId kWindowId{}; - void set_window_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_WindowId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DispatchedPointer = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidWindowInputDispatchEvent_DispatchedPointer, - AndroidWindowInputDispatchEvent>; - - static constexpr FieldMetadata_DispatchedPointer kDispatchedPointer{}; - template T* add_dispatched_pointer() { - return BeginNestedMessage(4); - } - - - using FieldMetadata_ResolvedFlags = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidWindowInputDispatchEvent>; - - static constexpr FieldMetadata_ResolvedFlags kResolvedFlags{}; - void set_resolved_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ResolvedFlags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_pointer_id() const { return at<1>().valid(); } - int32_t pointer_id() const { return at<1>().as_int32(); } - bool has_x_in_display() const { return at<2>().valid(); } - float x_in_display() const { return at<2>().as_float(); } - bool has_y_in_display() const { return at<3>().valid(); } - float y_in_display() const { return at<3>().as_float(); } - bool has_axis_value_in_window() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> axis_value_in_window() const { return GetRepeated<::protozero::ConstBytes>(4); } -}; - -class AndroidWindowInputDispatchEvent_DispatchedPointer : public ::protozero::Message { - public: - using Decoder = AndroidWindowInputDispatchEvent_DispatchedPointer_Decoder; - enum : int32_t { - kPointerIdFieldNumber = 1, - kXInDisplayFieldNumber = 2, - kYInDisplayFieldNumber = 3, - kAxisValueInWindowFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidWindowInputDispatchEvent.DispatchedPointer"; } - - - using FieldMetadata_PointerId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidWindowInputDispatchEvent_DispatchedPointer>; - - static constexpr FieldMetadata_PointerId kPointerId{}; - void set_pointer_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_PointerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_XInDisplay = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidWindowInputDispatchEvent_DispatchedPointer>; - - static constexpr FieldMetadata_XInDisplay kXInDisplay{}; - void set_x_in_display(float value) { - static constexpr uint32_t field_id = FieldMetadata_XInDisplay::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_YInDisplay = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidWindowInputDispatchEvent_DispatchedPointer>; - - static constexpr FieldMetadata_YInDisplay kYInDisplay{}; - void set_y_in_display(float value) { - static constexpr uint32_t field_id = FieldMetadata_YInDisplay::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_AxisValueInWindow = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidMotionEvent_Pointer_AxisValue, - AndroidWindowInputDispatchEvent_DispatchedPointer>; - - static constexpr FieldMetadata_AxisValueInWindow kAxisValueInWindow{}; - template T* add_axis_value_in_window() { - return BeginNestedMessage(4); - } - -}; - -class AndroidKeyEvent_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidKeyEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidKeyEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidKeyEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_event_id() const { return at<1>().valid(); } - uint32_t event_id() const { return at<1>().as_uint32(); } - bool has_event_time_nanos() const { return at<2>().valid(); } - int64_t event_time_nanos() const { return at<2>().as_int64(); } - bool has_down_time_nanos() const { return at<3>().valid(); } - int64_t down_time_nanos() const { return at<3>().as_int64(); } - bool has_source() const { return at<4>().valid(); } - uint32_t source() const { return at<4>().as_uint32(); } - bool has_action() const { return at<5>().valid(); } - int32_t action() const { return at<5>().as_int32(); } - bool has_device_id() const { return at<6>().valid(); } - int32_t device_id() const { return at<6>().as_int32(); } - bool has_display_id() const { return at<7>().valid(); } - int32_t display_id() const { return at<7>().as_sint32(); } - bool has_key_code() const { return at<8>().valid(); } - int32_t key_code() const { return at<8>().as_int32(); } - bool has_scan_code() const { return at<9>().valid(); } - uint32_t scan_code() const { return at<9>().as_uint32(); } - bool has_meta_state() const { return at<10>().valid(); } - uint32_t meta_state() const { return at<10>().as_uint32(); } - bool has_repeat_count() const { return at<11>().valid(); } - int32_t repeat_count() const { return at<11>().as_int32(); } - bool has_flags() const { return at<12>().valid(); } - uint32_t flags() const { return at<12>().as_uint32(); } - bool has_policy_flags() const { return at<13>().valid(); } - uint32_t policy_flags() const { return at<13>().as_uint32(); } -}; - -class AndroidKeyEvent : public ::protozero::Message { - public: - using Decoder = AndroidKeyEvent_Decoder; - enum : int32_t { - kEventIdFieldNumber = 1, - kEventTimeNanosFieldNumber = 2, - kDownTimeNanosFieldNumber = 3, - kSourceFieldNumber = 4, - kActionFieldNumber = 5, - kDeviceIdFieldNumber = 6, - kDisplayIdFieldNumber = 7, - kKeyCodeFieldNumber = 8, - kScanCodeFieldNumber = 9, - kMetaStateFieldNumber = 10, - kRepeatCountFieldNumber = 11, - kFlagsFieldNumber = 12, - kPolicyFlagsFieldNumber = 13, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidKeyEvent"; } - - - using FieldMetadata_EventId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed32, - uint32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_EventId kEventId{}; - void set_event_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_EventTimeNanos = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_EventTimeNanos kEventTimeNanos{}; - void set_event_time_nanos(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_EventTimeNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DownTimeNanos = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_DownTimeNanos kDownTimeNanos{}; - void set_down_time_nanos(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_DownTimeNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Source = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_Source kSource{}; - void set_source(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Action = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_Action kAction{}; - void set_action(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DeviceId = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_DeviceId kDeviceId{}; - void set_device_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DeviceId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisplayId = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kSint32, - int32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_DisplayId kDisplayId{}; - void set_display_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kSint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_KeyCode = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_KeyCode kKeyCode{}; - void set_key_code(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_KeyCode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ScanCode = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_ScanCode kScanCode{}; - void set_scan_code(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ScanCode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MetaState = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_MetaState kMetaState{}; - void set_meta_state(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MetaState::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_RepeatCount = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_RepeatCount kRepeatCount{}; - void set_repeat_count(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_RepeatCount::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PolicyFlags = - ::protozero::proto_utils::FieldMetadata< - 13, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidKeyEvent>; - - static constexpr FieldMetadata_PolicyFlags kPolicyFlags{}; - void set_policy_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_PolicyFlags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class AndroidMotionEvent_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidMotionEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidMotionEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidMotionEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_event_id() const { return at<1>().valid(); } - uint32_t event_id() const { return at<1>().as_uint32(); } - bool has_event_time_nanos() const { return at<2>().valid(); } - int64_t event_time_nanos() const { return at<2>().as_int64(); } - bool has_source() const { return at<3>().valid(); } - uint32_t source() const { return at<3>().as_uint32(); } - bool has_action() const { return at<4>().valid(); } - int32_t action() const { return at<4>().as_int32(); } - bool has_device_id() const { return at<5>().valid(); } - int32_t device_id() const { return at<5>().as_int32(); } - bool has_display_id() const { return at<6>().valid(); } - int32_t display_id() const { return at<6>().as_sint32(); } - bool has_classification() const { return at<7>().valid(); } - int32_t classification() const { return at<7>().as_int32(); } - bool has_flags() const { return at<8>().valid(); } - uint32_t flags() const { return at<8>().as_uint32(); } - bool has_pointer() const { return at<9>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> pointer() const { return GetRepeated<::protozero::ConstBytes>(9); } - bool has_original_event_id() const { return at<16>().valid(); } - ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed32, uint32_t> original_event_id(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed32, uint32_t>(16, parse_error_ptr); } - bool has_down_time_nanos() const { return at<17>().valid(); } - int64_t down_time_nanos() const { return at<17>().as_int64(); } - bool has_cursor_position_x() const { return at<18>().valid(); } - float cursor_position_x() const { return at<18>().as_float(); } - bool has_cursor_position_y() const { return at<19>().valid(); } - float cursor_position_y() const { return at<19>().as_float(); } - bool has_action_button() const { return at<20>().valid(); } - int32_t action_button() const { return at<20>().as_int32(); } - bool has_button_state() const { return at<21>().valid(); } - uint32_t button_state() const { return at<21>().as_uint32(); } - bool has_meta_state() const { return at<22>().valid(); } - uint32_t meta_state() const { return at<22>().as_uint32(); } - bool has_policy_flags() const { return at<23>().valid(); } - uint32_t policy_flags() const { return at<23>().as_uint32(); } - bool has_precision_x() const { return at<24>().valid(); } - float precision_x() const { return at<24>().as_float(); } - bool has_precision_y() const { return at<25>().valid(); } - float precision_y() const { return at<25>().as_float(); } -}; - -class AndroidMotionEvent : public ::protozero::Message { - public: - using Decoder = AndroidMotionEvent_Decoder; - enum : int32_t { - kEventIdFieldNumber = 1, - kEventTimeNanosFieldNumber = 2, - kSourceFieldNumber = 3, - kActionFieldNumber = 4, - kDeviceIdFieldNumber = 5, - kDisplayIdFieldNumber = 6, - kClassificationFieldNumber = 7, - kFlagsFieldNumber = 8, - kPointerFieldNumber = 9, - kOriginalEventIdFieldNumber = 16, - kDownTimeNanosFieldNumber = 17, - kCursorPositionXFieldNumber = 18, - kCursorPositionYFieldNumber = 19, - kActionButtonFieldNumber = 20, - kButtonStateFieldNumber = 21, - kMetaStateFieldNumber = 22, - kPolicyFlagsFieldNumber = 23, - kPrecisionXFieldNumber = 24, - kPrecisionYFieldNumber = 25, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidMotionEvent"; } - - using Pointer = ::perfetto::protos::pbzero::AndroidMotionEvent_Pointer; - - using FieldMetadata_EventId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_EventId kEventId{}; - void set_event_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_EventId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_EventTimeNanos = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_EventTimeNanos kEventTimeNanos{}; - void set_event_time_nanos(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_EventTimeNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Source = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_Source kSource{}; - void set_source(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Source::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Action = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_Action kAction{}; - void set_action(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Action::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DeviceId = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_DeviceId kDeviceId{}; - void set_device_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DeviceId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisplayId = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kSint32, - int32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_DisplayId kDisplayId{}; - void set_display_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kSint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Classification = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_Classification kClassification{}; - void set_classification(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Classification::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Pointer = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidMotionEvent_Pointer, - AndroidMotionEvent>; - - static constexpr FieldMetadata_Pointer kPointer{}; - template T* add_pointer() { - return BeginNestedMessage(9); - } - - - using FieldMetadata_OriginalEventId = - ::protozero::proto_utils::FieldMetadata< - 16, - ::protozero::proto_utils::RepetitionType::kRepeatedPacked, - ::protozero::proto_utils::ProtoSchemaType::kFixed32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_OriginalEventId kOriginalEventId{}; - void set_original_event_id(const ::protozero::PackedFixedSizeInt& packed_buffer) { - AppendBytes(FieldMetadata_OriginalEventId::kFieldId, packed_buffer.data(), - packed_buffer.size()); - } - - using FieldMetadata_DownTimeNanos = - ::protozero::proto_utils::FieldMetadata< - 17, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_DownTimeNanos kDownTimeNanos{}; - void set_down_time_nanos(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_DownTimeNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CursorPositionX = - ::protozero::proto_utils::FieldMetadata< - 18, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidMotionEvent>; - - static constexpr FieldMetadata_CursorPositionX kCursorPositionX{}; - void set_cursor_position_x(float value) { - static constexpr uint32_t field_id = FieldMetadata_CursorPositionX::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CursorPositionY = - ::protozero::proto_utils::FieldMetadata< - 19, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidMotionEvent>; - - static constexpr FieldMetadata_CursorPositionY kCursorPositionY{}; - void set_cursor_position_y(float value) { - static constexpr uint32_t field_id = FieldMetadata_CursorPositionY::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ActionButton = - ::protozero::proto_utils::FieldMetadata< - 20, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_ActionButton kActionButton{}; - void set_action_button(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ActionButton::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ButtonState = - ::protozero::proto_utils::FieldMetadata< - 21, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_ButtonState kButtonState{}; - void set_button_state(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ButtonState::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MetaState = - ::protozero::proto_utils::FieldMetadata< - 22, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_MetaState kMetaState{}; - void set_meta_state(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MetaState::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PolicyFlags = - ::protozero::proto_utils::FieldMetadata< - 23, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - AndroidMotionEvent>; - - static constexpr FieldMetadata_PolicyFlags kPolicyFlags{}; - void set_policy_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_PolicyFlags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PrecisionX = - ::protozero::proto_utils::FieldMetadata< - 24, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidMotionEvent>; - - static constexpr FieldMetadata_PrecisionX kPrecisionX{}; - void set_precision_x(float value) { - static constexpr uint32_t field_id = FieldMetadata_PrecisionX::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PrecisionY = - ::protozero::proto_utils::FieldMetadata< - 25, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidMotionEvent>; - - static constexpr FieldMetadata_PrecisionY kPrecisionY{}; - void set_precision_y(float value) { - static constexpr uint32_t field_id = FieldMetadata_PrecisionY::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class AndroidMotionEvent_Pointer_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidMotionEvent_Pointer_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidMotionEvent_Pointer_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidMotionEvent_Pointer_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_axis_value() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> axis_value() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_pointer_id() const { return at<2>().valid(); } - int32_t pointer_id() const { return at<2>().as_int32(); } - bool has_tool_type() const { return at<3>().valid(); } - int32_t tool_type() const { return at<3>().as_int32(); } -}; - -class AndroidMotionEvent_Pointer : public ::protozero::Message { - public: - using Decoder = AndroidMotionEvent_Pointer_Decoder; - enum : int32_t { - kAxisValueFieldNumber = 1, - kPointerIdFieldNumber = 2, - kToolTypeFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidMotionEvent.Pointer"; } - - using AxisValue = ::perfetto::protos::pbzero::AndroidMotionEvent_Pointer_AxisValue; - - using FieldMetadata_AxisValue = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - AndroidMotionEvent_Pointer_AxisValue, - AndroidMotionEvent_Pointer>; - - static constexpr FieldMetadata_AxisValue kAxisValue{}; - template T* add_axis_value() { - return BeginNestedMessage(1); - } - - - using FieldMetadata_PointerId = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent_Pointer>; - - static constexpr FieldMetadata_PointerId kPointerId{}; - void set_pointer_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_PointerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ToolType = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent_Pointer>; - - static constexpr FieldMetadata_ToolType kToolType{}; - void set_tool_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ToolType::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -class AndroidMotionEvent_Pointer_AxisValue_Decoder : public ::protozero::TypedProtoDecoder { - public: - AndroidMotionEvent_Pointer_AxisValue_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit AndroidMotionEvent_Pointer_AxisValue_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit AndroidMotionEvent_Pointer_AxisValue_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_axis() const { return at<1>().valid(); } - int32_t axis() const { return at<1>().as_int32(); } - bool has_value() const { return at<2>().valid(); } - float value() const { return at<2>().as_float(); } -}; - -class AndroidMotionEvent_Pointer_AxisValue : public ::protozero::Message { - public: - using Decoder = AndroidMotionEvent_Pointer_AxisValue_Decoder; - enum : int32_t { - kAxisFieldNumber = 1, - kValueFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.AndroidMotionEvent.Pointer.AxisValue"; } - - - using FieldMetadata_Axis = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - AndroidMotionEvent_Pointer_AxisValue>; - - static constexpr FieldMetadata_Axis kAxis{}; - void set_axis(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Axis::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Value = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - AndroidMotionEvent_Pointer_AxisValue>; - - static constexpr FieldMetadata_Value kValue{}; - void set_value(float value) { - static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - } // Namespace. } // Namespace. } // Namespace. @@ -58575,11 +65893,11 @@ class PackagesList_PackageInfo : public ::protozero::Message { } // Namespace. } // Namespace. #endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/protolog.pbzero.h +// gen_amalgamated begin header: gen/protos/perfetto/trace/android/pixel_modem_events.pbzero.h // Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PROTOLOG_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PROTOLOG_PROTO_H_ +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PIXEL_MODEM_EVENTS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_PIXEL_MODEM_EVENTS_PROTO_H_ #include #include @@ -58590,7630 +65908,116 @@ class PackagesList_PackageInfo : public ::protozero::Message { // gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" // gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" -namespace perfetto { -namespace protos { -namespace pbzero { -class ProtoLogViewerConfig_Group; -class ProtoLogViewerConfig_MessageData; -enum ProtoLogLevel : int32_t; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. namespace perfetto { namespace protos { namespace pbzero { -class ProtoLogViewerConfig_Decoder : public ::protozero::TypedProtoDecoder { +class PixelModemTokenDatabase_Decoder : public ::protozero::TypedProtoDecoder { public: - ProtoLogViewerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ProtoLogViewerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ProtoLogViewerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_messages() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> messages() const { return GetRepeated<::protozero::ConstBytes>(1); } - bool has_groups() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> groups() const { return GetRepeated<::protozero::ConstBytes>(2); } + PixelModemTokenDatabase_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PixelModemTokenDatabase_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PixelModemTokenDatabase_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_database() const { return at<1>().valid(); } + ::protozero::ConstBytes database() const { return at<1>().as_bytes(); } }; -class ProtoLogViewerConfig : public ::protozero::Message { +class PixelModemTokenDatabase : public ::protozero::Message { public: - using Decoder = ProtoLogViewerConfig_Decoder; + using Decoder = PixelModemTokenDatabase_Decoder; enum : int32_t { - kMessagesFieldNumber = 1, - kGroupsFieldNumber = 2, + kDatabaseFieldNumber = 1, }; - static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig"; } - - using MessageData = ::perfetto::protos::pbzero::ProtoLogViewerConfig_MessageData; - using Group = ::perfetto::protos::pbzero::ProtoLogViewerConfig_Group; - - using FieldMetadata_Messages = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ProtoLogViewerConfig_MessageData, - ProtoLogViewerConfig>; - - static constexpr FieldMetadata_Messages kMessages{}; - template T* add_messages() { - return BeginNestedMessage(1); - } + static constexpr const char* GetName() { return ".perfetto.protos.PixelModemTokenDatabase"; } - using FieldMetadata_Groups = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ProtoLogViewerConfig_Group, - ProtoLogViewerConfig>; - - static constexpr FieldMetadata_Groups kGroups{}; - template T* add_groups() { - return BeginNestedMessage(2); - } - -}; - -class ProtoLogViewerConfig_Group_Decoder : public ::protozero::TypedProtoDecoder { - public: - ProtoLogViewerConfig_Group_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ProtoLogViewerConfig_Group_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ProtoLogViewerConfig_Group_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - uint32_t id() const { return at<1>().as_uint32(); } - bool has_name() const { return at<2>().valid(); } - ::protozero::ConstChars name() const { return at<2>().as_string(); } - bool has_tag() const { return at<3>().valid(); } - ::protozero::ConstChars tag() const { return at<3>().as_string(); } -}; - -class ProtoLogViewerConfig_Group : public ::protozero::Message { - public: - using Decoder = ProtoLogViewerConfig_Group_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kNameFieldNumber = 2, - kTagFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.Group"; } - - - using FieldMetadata_Id = + using FieldMetadata_Database = ::protozero::proto_utils::FieldMetadata< 1, ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ProtoLogViewerConfig_Group>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, + ::protozero::proto_utils::ProtoSchemaType::kBytes, std::string, - ProtoLogViewerConfig_Group>; + PixelModemTokenDatabase>; - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); + static constexpr FieldMetadata_Database kDatabase{}; + void set_database(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Database::kFieldId, data, size); } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); + void set_database(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Database::kFieldId, bytes.data, bytes.size); } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; + void set_database(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Database::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> + ::protozero::proto_utils::ProtoSchemaType::kBytes> ::Append(*this, field_id, value); } +}; - using FieldMetadata_Tag = +class PixelModemEvents_Decoder : public ::protozero::TypedProtoDecoder { + public: + PixelModemEvents_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit PixelModemEvents_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit PixelModemEvents_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_events() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> events() const { return GetRepeated<::protozero::ConstBytes>(1); } + bool has_event_time_nanos() const { return at<2>().valid(); } + ::protozero::RepeatedFieldIterator event_time_nanos() const { return GetRepeated(2); } +}; + +class PixelModemEvents : public ::protozero::Message { + public: + using Decoder = PixelModemEvents_Decoder; + enum : int32_t { + kEventsFieldNumber = 1, + kEventTimeNanosFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.PixelModemEvents"; } + + + using FieldMetadata_Events = ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kBytes, std::string, - ProtoLogViewerConfig_Group>; + PixelModemEvents>; - static constexpr FieldMetadata_Tag kTag{}; - void set_tag(const char* data, size_t size) { - AppendBytes(FieldMetadata_Tag::kFieldId, data, size); + static constexpr FieldMetadata_Events kEvents{}; + void add_events(const uint8_t* data, size_t size) { + AppendBytes(FieldMetadata_Events::kFieldId, data, size); } - void set_tag(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Tag::kFieldId, chars.data, chars.size); + void add_events(::protozero::ConstBytes bytes) { + AppendBytes(FieldMetadata_Events::kFieldId, bytes.data, bytes.size); } - void set_tag(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Tag::kFieldId; + void add_events(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Events::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } -}; - -class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoDecoder { - public: - ProtoLogViewerConfig_MessageData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ProtoLogViewerConfig_MessageData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ProtoLogViewerConfig_MessageData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_message_id() const { return at<1>().valid(); } - uint64_t message_id() const { return at<1>().as_uint64(); } - bool has_message() const { return at<2>().valid(); } - ::protozero::ConstChars message() const { return at<2>().as_string(); } - bool has_level() const { return at<3>().valid(); } - int32_t level() const { return at<3>().as_int32(); } - bool has_group_id() const { return at<4>().valid(); } - uint32_t group_id() const { return at<4>().as_uint32(); } -}; - -class ProtoLogViewerConfig_MessageData : public ::protozero::Message { - public: - using Decoder = ProtoLogViewerConfig_MessageData_Decoder; - enum : int32_t { - kMessageIdFieldNumber = 1, - kMessageFieldNumber = 2, - kLevelFieldNumber = 3, - kGroupIdFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.MessageData"; } - - - using FieldMetadata_MessageId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed64, - uint64_t, - ProtoLogViewerConfig_MessageData>; - - static constexpr FieldMetadata_MessageId kMessageId{}; - void set_message_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed64> + ::protozero::proto_utils::ProtoSchemaType::kBytes> ::Append(*this, field_id, value); } - using FieldMetadata_Message = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - ProtoLogViewerConfig_MessageData>; - - static constexpr FieldMetadata_Message kMessage{}; - void set_message(const char* data, size_t size) { - AppendBytes(FieldMetadata_Message::kFieldId, data, size); - } - void set_message(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Message::kFieldId, chars.data, chars.size); - } - void set_message(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Message::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Level = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - ProtoLogLevel, - ProtoLogViewerConfig_MessageData>; - - static constexpr FieldMetadata_Level kLevel{}; - void set_level(ProtoLogLevel value) { - static constexpr uint32_t field_id = FieldMetadata_Level::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_GroupId = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ProtoLogViewerConfig_MessageData>; - - static constexpr FieldMetadata_GroupId kGroupId{}; - void set_group_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_GroupId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class ProtoLogMessage_Decoder : public ::protozero::TypedProtoDecoder { - public: - ProtoLogMessage_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ProtoLogMessage_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ProtoLogMessage_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_message_id() const { return at<1>().valid(); } - uint64_t message_id() const { return at<1>().as_uint64(); } - bool has_str_param_iids() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator str_param_iids() const { return GetRepeated(2); } - bool has_sint64_params() const { return at<3>().valid(); } - ::protozero::RepeatedFieldIterator sint64_params() const { return GetRepeated(3); } - bool has_double_params() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator double_params() const { return GetRepeated(4); } - bool has_boolean_params() const { return at<5>().valid(); } - ::protozero::RepeatedFieldIterator boolean_params() const { return GetRepeated(5); } - bool has_stacktrace_iid() const { return at<6>().valid(); } - uint32_t stacktrace_iid() const { return at<6>().as_uint32(); } -}; - -class ProtoLogMessage : public ::protozero::Message { - public: - using Decoder = ProtoLogMessage_Decoder; - enum : int32_t { - kMessageIdFieldNumber = 1, - kStrParamIidsFieldNumber = 2, - kSint64ParamsFieldNumber = 3, - kDoubleParamsFieldNumber = 4, - kBooleanParamsFieldNumber = 5, - kStacktraceIidFieldNumber = 6, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogMessage"; } - - - using FieldMetadata_MessageId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed64, - uint64_t, - ProtoLogMessage>; - - static constexpr FieldMetadata_MessageId kMessageId{}; - void set_message_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MessageId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StrParamIids = + using FieldMetadata_EventTimeNanos = ::protozero::proto_utils::FieldMetadata< 2, ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ProtoLogMessage>; - - static constexpr FieldMetadata_StrParamIids kStrParamIids{}; - void add_str_param_iids(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_StrParamIids::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Sint64Params = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kSint64, - int64_t, - ProtoLogMessage>; - - static constexpr FieldMetadata_Sint64Params kSint64Params{}; - void add_sint64_params(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Sint64Params::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kSint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DoubleParams = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kDouble, - double, - ProtoLogMessage>; - - static constexpr FieldMetadata_DoubleParams kDoubleParams{}; - void add_double_params(double value) { - static constexpr uint32_t field_id = FieldMetadata_DoubleParams::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kDouble> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BooleanParams = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ProtoLogMessage>; - - static constexpr FieldMetadata_BooleanParams kBooleanParams{}; - void add_boolean_params(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_BooleanParams::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StacktraceIid = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ProtoLogMessage>; - - static constexpr FieldMetadata_StacktraceIid kStacktraceIid{}; - void set_stacktrace_iid(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_StacktraceIid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/shell_transition.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SHELL_TRANSITION_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SHELL_TRANSITION_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class ShellHandlerMapping; -class ShellTransition_Target; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -class ShellHandlerMapping_Decoder : public ::protozero::TypedProtoDecoder { - public: - ShellHandlerMapping_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ShellHandlerMapping_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ShellHandlerMapping_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - int32_t id() const { return at<1>().as_int32(); } - bool has_name() const { return at<2>().valid(); } - ::protozero::ConstChars name() const { return at<2>().as_string(); } -}; - -class ShellHandlerMapping : public ::protozero::Message { - public: - using Decoder = ShellHandlerMapping_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kNameFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMapping"; } - - - using FieldMetadata_Id = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellHandlerMapping>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - ShellHandlerMapping>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } -}; - -class ShellHandlerMappings_Decoder : public ::protozero::TypedProtoDecoder { - public: - ShellHandlerMappings_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ShellHandlerMappings_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ShellHandlerMappings_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_mapping() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> mapping() const { return GetRepeated<::protozero::ConstBytes>(1); } -}; - -class ShellHandlerMappings : public ::protozero::Message { - public: - using Decoder = ShellHandlerMappings_Decoder; - enum : int32_t { - kMappingFieldNumber = 1, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ShellHandlerMappings"; } - - - using FieldMetadata_Mapping = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ShellHandlerMapping, - ShellHandlerMappings>; - - static constexpr FieldMetadata_Mapping kMapping{}; - template T* add_mapping() { - return BeginNestedMessage(1); - } - -}; - -class ShellTransition_Decoder : public ::protozero::TypedProtoDecoder { - public: - ShellTransition_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ShellTransition_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ShellTransition_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - int32_t id() const { return at<1>().as_int32(); } - bool has_create_time_ns() const { return at<2>().valid(); } - int64_t create_time_ns() const { return at<2>().as_int64(); } - bool has_send_time_ns() const { return at<3>().valid(); } - int64_t send_time_ns() const { return at<3>().as_int64(); } - bool has_dispatch_time_ns() const { return at<4>().valid(); } - int64_t dispatch_time_ns() const { return at<4>().as_int64(); } - bool has_merge_time_ns() const { return at<5>().valid(); } - int64_t merge_time_ns() const { return at<5>().as_int64(); } - bool has_merge_request_time_ns() const { return at<6>().valid(); } - int64_t merge_request_time_ns() const { return at<6>().as_int64(); } - bool has_shell_abort_time_ns() const { return at<7>().valid(); } - int64_t shell_abort_time_ns() const { return at<7>().as_int64(); } - bool has_wm_abort_time_ns() const { return at<8>().valid(); } - int64_t wm_abort_time_ns() const { return at<8>().as_int64(); } - bool has_finish_time_ns() const { return at<9>().valid(); } - int64_t finish_time_ns() const { return at<9>().as_int64(); } - bool has_start_transaction_id() const { return at<10>().valid(); } - uint64_t start_transaction_id() const { return at<10>().as_uint64(); } - bool has_finish_transaction_id() const { return at<11>().valid(); } - uint64_t finish_transaction_id() const { return at<11>().as_uint64(); } - bool has_handler() const { return at<12>().valid(); } - int32_t handler() const { return at<12>().as_int32(); } - bool has_type() const { return at<13>().valid(); } - int32_t type() const { return at<13>().as_int32(); } - bool has_targets() const { return at<14>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> targets() const { return GetRepeated<::protozero::ConstBytes>(14); } - bool has_merge_target() const { return at<15>().valid(); } - int32_t merge_target() const { return at<15>().as_int32(); } - bool has_flags() const { return at<16>().valid(); } - int32_t flags() const { return at<16>().as_int32(); } - bool has_starting_window_remove_time_ns() const { return at<17>().valid(); } - int64_t starting_window_remove_time_ns() const { return at<17>().as_int64(); } -}; - -class ShellTransition : public ::protozero::Message { - public: - using Decoder = ShellTransition_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kCreateTimeNsFieldNumber = 2, - kSendTimeNsFieldNumber = 3, - kDispatchTimeNsFieldNumber = 4, - kMergeTimeNsFieldNumber = 5, - kMergeRequestTimeNsFieldNumber = 6, - kShellAbortTimeNsFieldNumber = 7, - kWmAbortTimeNsFieldNumber = 8, - kFinishTimeNsFieldNumber = 9, - kStartTransactionIdFieldNumber = 10, - kFinishTransactionIdFieldNumber = 11, - kHandlerFieldNumber = 12, - kTypeFieldNumber = 13, - kTargetsFieldNumber = 14, - kMergeTargetFieldNumber = 15, - kFlagsFieldNumber = 16, - kStartingWindowRemoveTimeNsFieldNumber = 17, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition"; } - - using Target = ::perfetto::protos::pbzero::ShellTransition_Target; - - using FieldMetadata_Id = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CreateTimeNs = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_CreateTimeNs kCreateTimeNs{}; - void set_create_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_CreateTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_SendTimeNs = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_SendTimeNs kSendTimeNs{}; - void set_send_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_SendTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DispatchTimeNs = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_DispatchTimeNs kDispatchTimeNs{}; - void set_dispatch_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_DispatchTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MergeTimeNs = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_MergeTimeNs kMergeTimeNs{}; - void set_merge_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MergeTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MergeRequestTimeNs = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_MergeRequestTimeNs kMergeRequestTimeNs{}; - void set_merge_request_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MergeRequestTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ShellAbortTimeNs = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_ShellAbortTimeNs kShellAbortTimeNs{}; - void set_shell_abort_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_ShellAbortTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_WmAbortTimeNs = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_WmAbortTimeNs kWmAbortTimeNs{}; - void set_wm_abort_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_WmAbortTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FinishTimeNs = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_FinishTimeNs kFinishTimeNs{}; - void set_finish_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_FinishTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StartTransactionId = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, ::protozero::proto_utils::ProtoSchemaType::kUint64, uint64_t, - ShellTransition>; + PixelModemEvents>; - static constexpr FieldMetadata_StartTransactionId kStartTransactionId{}; - void set_start_transaction_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_StartTransactionId::kFieldId; + static constexpr FieldMetadata_EventTimeNanos kEventTimeNanos{}; + void add_event_time_nanos(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_EventTimeNanos::kFieldId; // Call the appropriate protozero::Message::Append(field_id, ...) // method based on the type of the field. ::protozero::internal::FieldWriter< ::protozero::proto_utils::ProtoSchemaType::kUint64> ::Append(*this, field_id, value); } - - using FieldMetadata_FinishTransactionId = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - ShellTransition>; - - static constexpr FieldMetadata_FinishTransactionId kFinishTransactionId{}; - void set_finish_transaction_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_FinishTransactionId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Handler = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition>; - - static constexpr FieldMetadata_Handler kHandler{}; - void set_handler(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Handler::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Type = - ::protozero::proto_utils::FieldMetadata< - 13, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition>; - - static constexpr FieldMetadata_Type kType{}; - void set_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Targets = - ::protozero::proto_utils::FieldMetadata< - 14, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ShellTransition_Target, - ShellTransition>; - - static constexpr FieldMetadata_Targets kTargets{}; - template T* add_targets() { - return BeginNestedMessage(14); - } - - - using FieldMetadata_MergeTarget = - ::protozero::proto_utils::FieldMetadata< - 15, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition>; - - static constexpr FieldMetadata_MergeTarget kMergeTarget{}; - void set_merge_target(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MergeTarget::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 16, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_StartingWindowRemoveTimeNs = - ::protozero::proto_utils::FieldMetadata< - 17, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - ShellTransition>; - - static constexpr FieldMetadata_StartingWindowRemoveTimeNs kStartingWindowRemoveTimeNs{}; - void set_starting_window_remove_time_ns(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_StartingWindowRemoveTimeNs::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } -}; - -class ShellTransition_Target_Decoder : public ::protozero::TypedProtoDecoder { - public: - ShellTransition_Target_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ShellTransition_Target_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ShellTransition_Target_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_mode() const { return at<1>().valid(); } - int32_t mode() const { return at<1>().as_int32(); } - bool has_layer_id() const { return at<2>().valid(); } - int32_t layer_id() const { return at<2>().as_int32(); } - bool has_window_id() const { return at<3>().valid(); } - int32_t window_id() const { return at<3>().as_int32(); } - bool has_flags() const { return at<4>().valid(); } - int32_t flags() const { return at<4>().as_int32(); } -}; - -class ShellTransition_Target : public ::protozero::Message { - public: - using Decoder = ShellTransition_Target_Decoder; - enum : int32_t { - kModeFieldNumber = 1, - kLayerIdFieldNumber = 2, - kWindowIdFieldNumber = 3, - kFlagsFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ShellTransition.Target"; } - - - using FieldMetadata_Mode = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition_Target>; - - static constexpr FieldMetadata_Mode kMode{}; - void set_mode(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Mode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerId = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition_Target>; - - static constexpr FieldMetadata_LayerId kLayerId{}; - void set_layer_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_WindowId = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition_Target>; - - static constexpr FieldMetadata_WindowId kWindowId{}; - void set_window_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_WindowId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ShellTransition_Target>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_common.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_COMMON_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_COMMON_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class RectProto; -class RegionProto; -class TransformProto; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -class ColorTransformProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - ColorTransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ColorTransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ColorTransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_val() const { return at<1>().valid(); } - ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kFixed32, float> val(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kFixed32, float>(1, parse_error_ptr); } -}; - -class ColorTransformProto : public ::protozero::Message { - public: - using Decoder = ColorTransformProto_Decoder; - enum : int32_t { - kValFieldNumber = 1, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ColorTransformProto"; } - - - using FieldMetadata_Val = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedPacked, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - ColorTransformProto>; - - static constexpr FieldMetadata_Val kVal{}; - void set_val(const ::protozero::PackedFixedSizeInt& packed_buffer) { - AppendBytes(FieldMetadata_Val::kFieldId, packed_buffer.data(), - packed_buffer.size()); - } -}; - -class BlurRegion_Decoder : public ::protozero::TypedProtoDecoder { - public: - BlurRegion_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit BlurRegion_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit BlurRegion_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_blur_radius() const { return at<1>().valid(); } - uint32_t blur_radius() const { return at<1>().as_uint32(); } - bool has_corner_radius_tl() const { return at<2>().valid(); } - uint32_t corner_radius_tl() const { return at<2>().as_uint32(); } - bool has_corner_radius_tr() const { return at<3>().valid(); } - uint32_t corner_radius_tr() const { return at<3>().as_uint32(); } - bool has_corner_radius_bl() const { return at<4>().valid(); } - uint32_t corner_radius_bl() const { return at<4>().as_uint32(); } - bool has_corner_radius_br() const { return at<5>().valid(); } - float corner_radius_br() const { return at<5>().as_float(); } - bool has_alpha() const { return at<6>().valid(); } - float alpha() const { return at<6>().as_float(); } - bool has_left() const { return at<7>().valid(); } - int32_t left() const { return at<7>().as_int32(); } - bool has_top() const { return at<8>().valid(); } - int32_t top() const { return at<8>().as_int32(); } - bool has_right() const { return at<9>().valid(); } - int32_t right() const { return at<9>().as_int32(); } - bool has_bottom() const { return at<10>().valid(); } - int32_t bottom() const { return at<10>().as_int32(); } -}; - -class BlurRegion : public ::protozero::Message { - public: - using Decoder = BlurRegion_Decoder; - enum : int32_t { - kBlurRadiusFieldNumber = 1, - kCornerRadiusTlFieldNumber = 2, - kCornerRadiusTrFieldNumber = 3, - kCornerRadiusBlFieldNumber = 4, - kCornerRadiusBrFieldNumber = 5, - kAlphaFieldNumber = 6, - kLeftFieldNumber = 7, - kTopFieldNumber = 8, - kRightFieldNumber = 9, - kBottomFieldNumber = 10, - }; - static constexpr const char* GetName() { return ".perfetto.protos.BlurRegion"; } - - - using FieldMetadata_BlurRadius = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - BlurRegion>; - - static constexpr FieldMetadata_BlurRadius kBlurRadius{}; - void set_blur_radius(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_BlurRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CornerRadiusTl = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - BlurRegion>; - - static constexpr FieldMetadata_CornerRadiusTl kCornerRadiusTl{}; - void set_corner_radius_tl(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTl::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CornerRadiusTr = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - BlurRegion>; - - static constexpr FieldMetadata_CornerRadiusTr kCornerRadiusTr{}; - void set_corner_radius_tr(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CornerRadiusTr::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CornerRadiusBl = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - BlurRegion>; - - static constexpr FieldMetadata_CornerRadiusBl kCornerRadiusBl{}; - void set_corner_radius_bl(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBl::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CornerRadiusBr = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - BlurRegion>; - - static constexpr FieldMetadata_CornerRadiusBr kCornerRadiusBr{}; - void set_corner_radius_br(float value) { - static constexpr uint32_t field_id = FieldMetadata_CornerRadiusBr::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Alpha = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - BlurRegion>; - - static constexpr FieldMetadata_Alpha kAlpha{}; - void set_alpha(float value) { - static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Left = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - BlurRegion>; - - static constexpr FieldMetadata_Left kLeft{}; - void set_left(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Top = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - BlurRegion>; - - static constexpr FieldMetadata_Top kTop{}; - void set_top(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Right = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - BlurRegion>; - - static constexpr FieldMetadata_Right kRight{}; - void set_right(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Bottom = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - BlurRegion>; - - static constexpr FieldMetadata_Bottom kBottom{}; - void set_bottom(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -class InputWindowInfoProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - InputWindowInfoProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit InputWindowInfoProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit InputWindowInfoProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_layout_params_flags() const { return at<1>().valid(); } - uint32_t layout_params_flags() const { return at<1>().as_uint32(); } - bool has_layout_params_type() const { return at<2>().valid(); } - int32_t layout_params_type() const { return at<2>().as_int32(); } - bool has_frame() const { return at<3>().valid(); } - ::protozero::ConstBytes frame() const { return at<3>().as_bytes(); } - bool has_touchable_region() const { return at<4>().valid(); } - ::protozero::ConstBytes touchable_region() const { return at<4>().as_bytes(); } - bool has_surface_inset() const { return at<5>().valid(); } - int32_t surface_inset() const { return at<5>().as_int32(); } - bool has_visible() const { return at<6>().valid(); } - bool visible() const { return at<6>().as_bool(); } - bool has_can_receive_keys() const { return at<7>().valid(); } - bool can_receive_keys() const { return at<7>().as_bool(); } - bool has_focusable() const { return at<8>().valid(); } - bool focusable() const { return at<8>().as_bool(); } - bool has_has_wallpaper() const { return at<9>().valid(); } - bool has_wallpaper() const { return at<9>().as_bool(); } - bool has_global_scale_factor() const { return at<10>().valid(); } - float global_scale_factor() const { return at<10>().as_float(); } - bool has_window_x_scale() const { return at<11>().valid(); } - float window_x_scale() const { return at<11>().as_float(); } - bool has_window_y_scale() const { return at<12>().valid(); } - float window_y_scale() const { return at<12>().as_float(); } - bool has_crop_layer_id() const { return at<13>().valid(); } - int32_t crop_layer_id() const { return at<13>().as_int32(); } - bool has_replace_touchable_region_with_crop() const { return at<14>().valid(); } - bool replace_touchable_region_with_crop() const { return at<14>().as_bool(); } - bool has_touchable_region_crop() const { return at<15>().valid(); } - ::protozero::ConstBytes touchable_region_crop() const { return at<15>().as_bytes(); } - bool has_transform() const { return at<16>().valid(); } - ::protozero::ConstBytes transform() const { return at<16>().as_bytes(); } - bool has_input_config() const { return at<17>().valid(); } - uint32_t input_config() const { return at<17>().as_uint32(); } -}; - -class InputWindowInfoProto : public ::protozero::Message { - public: - using Decoder = InputWindowInfoProto_Decoder; - enum : int32_t { - kLayoutParamsFlagsFieldNumber = 1, - kLayoutParamsTypeFieldNumber = 2, - kFrameFieldNumber = 3, - kTouchableRegionFieldNumber = 4, - kSurfaceInsetFieldNumber = 5, - kVisibleFieldNumber = 6, - kCanReceiveKeysFieldNumber = 7, - kFocusableFieldNumber = 8, - kHasWallpaperFieldNumber = 9, - kGlobalScaleFactorFieldNumber = 10, - kWindowXScaleFieldNumber = 11, - kWindowYScaleFieldNumber = 12, - kCropLayerIdFieldNumber = 13, - kReplaceTouchableRegionWithCropFieldNumber = 14, - kTouchableRegionCropFieldNumber = 15, - kTransformFieldNumber = 16, - kInputConfigFieldNumber = 17, - }; - static constexpr const char* GetName() { return ".perfetto.protos.InputWindowInfoProto"; } - - - using FieldMetadata_LayoutParamsFlags = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - InputWindowInfoProto>; - - static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{}; - void set_layout_params_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayoutParamsType = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - InputWindowInfoProto>; - - static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{}; - void set_layout_params_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Frame = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - InputWindowInfoProto>; - - static constexpr FieldMetadata_Frame kFrame{}; - template T* set_frame() { - return BeginNestedMessage(3); - } - - - using FieldMetadata_TouchableRegion = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RegionProto, - InputWindowInfoProto>; - - static constexpr FieldMetadata_TouchableRegion kTouchableRegion{}; - template T* set_touchable_region() { - return BeginNestedMessage(4); - } - - - using FieldMetadata_SurfaceInset = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - InputWindowInfoProto>; - - static constexpr FieldMetadata_SurfaceInset kSurfaceInset{}; - void set_surface_inset(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Visible = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - InputWindowInfoProto>; - - static constexpr FieldMetadata_Visible kVisible{}; - void set_visible(bool value) { - static constexpr uint32_t field_id = FieldMetadata_Visible::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CanReceiveKeys = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - InputWindowInfoProto>; - - static constexpr FieldMetadata_CanReceiveKeys kCanReceiveKeys{}; - void set_can_receive_keys(bool value) { - static constexpr uint32_t field_id = FieldMetadata_CanReceiveKeys::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Focusable = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - InputWindowInfoProto>; - - static constexpr FieldMetadata_Focusable kFocusable{}; - void set_focusable(bool value) { - static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_HasWallpaper = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - InputWindowInfoProto>; - - static constexpr FieldMetadata_HasWallpaper kHasWallpaper{}; - void set_has_wallpaper(bool value) { - static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_GlobalScaleFactor = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - InputWindowInfoProto>; - - static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{}; - void set_global_scale_factor(float value) { - static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_WindowXScale = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - InputWindowInfoProto>; - - static constexpr FieldMetadata_WindowXScale kWindowXScale{}; - void set_window_x_scale(float value) { - static constexpr uint32_t field_id = FieldMetadata_WindowXScale::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_WindowYScale = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - InputWindowInfoProto>; - - static constexpr FieldMetadata_WindowYScale kWindowYScale{}; - void set_window_y_scale(float value) { - static constexpr uint32_t field_id = FieldMetadata_WindowYScale::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CropLayerId = - ::protozero::proto_utils::FieldMetadata< - 13, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - InputWindowInfoProto>; - - static constexpr FieldMetadata_CropLayerId kCropLayerId{}; - void set_crop_layer_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ReplaceTouchableRegionWithCrop = - ::protozero::proto_utils::FieldMetadata< - 14, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - InputWindowInfoProto>; - - static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{}; - void set_replace_touchable_region_with_crop(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TouchableRegionCrop = - ::protozero::proto_utils::FieldMetadata< - 15, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - InputWindowInfoProto>; - - static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{}; - template T* set_touchable_region_crop() { - return BeginNestedMessage(15); - } - - - using FieldMetadata_Transform = - ::protozero::proto_utils::FieldMetadata< - 16, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransformProto, - InputWindowInfoProto>; - - static constexpr FieldMetadata_Transform kTransform{}; - template T* set_transform() { - return BeginNestedMessage(16); - } - - - using FieldMetadata_InputConfig = - ::protozero::proto_utils::FieldMetadata< - 17, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - InputWindowInfoProto>; - - static constexpr FieldMetadata_InputConfig kInputConfig{}; - void set_input_config(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class ColorProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - ColorProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ColorProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ColorProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_r() const { return at<1>().valid(); } - float r() const { return at<1>().as_float(); } - bool has_g() const { return at<2>().valid(); } - float g() const { return at<2>().as_float(); } - bool has_b() const { return at<3>().valid(); } - float b() const { return at<3>().as_float(); } - bool has_a() const { return at<4>().valid(); } - float a() const { return at<4>().as_float(); } -}; - -class ColorProto : public ::protozero::Message { - public: - using Decoder = ColorProto_Decoder; - enum : int32_t { - kRFieldNumber = 1, - kGFieldNumber = 2, - kBFieldNumber = 3, - kAFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ColorProto"; } - - - using FieldMetadata_R = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - ColorProto>; - - static constexpr FieldMetadata_R kR{}; - void set_r(float value) { - static constexpr uint32_t field_id = FieldMetadata_R::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_G = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - ColorProto>; - - static constexpr FieldMetadata_G kG{}; - void set_g(float value) { - static constexpr uint32_t field_id = FieldMetadata_G::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_B = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - ColorProto>; - - static constexpr FieldMetadata_B kB{}; - void set_b(float value) { - static constexpr uint32_t field_id = FieldMetadata_B::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_A = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - ColorProto>; - - static constexpr FieldMetadata_A kA{}; - void set_a(float value) { - static constexpr uint32_t field_id = FieldMetadata_A::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class TransformProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - TransformProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TransformProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TransformProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_dsdx() const { return at<1>().valid(); } - float dsdx() const { return at<1>().as_float(); } - bool has_dtdx() const { return at<2>().valid(); } - float dtdx() const { return at<2>().as_float(); } - bool has_dsdy() const { return at<3>().valid(); } - float dsdy() const { return at<3>().as_float(); } - bool has_dtdy() const { return at<4>().valid(); } - float dtdy() const { return at<4>().as_float(); } - bool has_type() const { return at<5>().valid(); } - int32_t type() const { return at<5>().as_int32(); } -}; - -class TransformProto : public ::protozero::Message { - public: - using Decoder = TransformProto_Decoder; - enum : int32_t { - kDsdxFieldNumber = 1, - kDtdxFieldNumber = 2, - kDsdyFieldNumber = 3, - kDtdyFieldNumber = 4, - kTypeFieldNumber = 5, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TransformProto"; } - - - using FieldMetadata_Dsdx = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - TransformProto>; - - static constexpr FieldMetadata_Dsdx kDsdx{}; - void set_dsdx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dtdx = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - TransformProto>; - - static constexpr FieldMetadata_Dtdx kDtdx{}; - void set_dtdx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dsdy = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - TransformProto>; - - static constexpr FieldMetadata_Dsdy kDsdy{}; - void set_dsdy(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dtdy = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - TransformProto>; - - static constexpr FieldMetadata_Dtdy kDtdy{}; - void set_dtdy(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Type = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TransformProto>; - - static constexpr FieldMetadata_Type kType{}; - void set_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -class SizeProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - SizeProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit SizeProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit SizeProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_w() const { return at<1>().valid(); } - int32_t w() const { return at<1>().as_int32(); } - bool has_h() const { return at<2>().valid(); } - int32_t h() const { return at<2>().as_int32(); } -}; - -class SizeProto : public ::protozero::Message { - public: - using Decoder = SizeProto_Decoder; - enum : int32_t { - kWFieldNumber = 1, - kHFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.SizeProto"; } - - - using FieldMetadata_W = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - SizeProto>; - - static constexpr FieldMetadata_W kW{}; - void set_w(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_W::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_H = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - SizeProto>; - - static constexpr FieldMetadata_H kH{}; - void set_h(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_H::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -class RectProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - RectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit RectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit RectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_left() const { return at<1>().valid(); } - int32_t left() const { return at<1>().as_int32(); } - bool has_top() const { return at<2>().valid(); } - int32_t top() const { return at<2>().as_int32(); } - bool has_right() const { return at<3>().valid(); } - int32_t right() const { return at<3>().as_int32(); } - bool has_bottom() const { return at<4>().valid(); } - int32_t bottom() const { return at<4>().as_int32(); } -}; - -class RectProto : public ::protozero::Message { - public: - using Decoder = RectProto_Decoder; - enum : int32_t { - kLeftFieldNumber = 1, - kTopFieldNumber = 2, - kRightFieldNumber = 3, - kBottomFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.RectProto"; } - - - using FieldMetadata_Left = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - RectProto>; - - static constexpr FieldMetadata_Left kLeft{}; - void set_left(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Top = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - RectProto>; - - static constexpr FieldMetadata_Top kTop{}; - void set_top(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Right = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - RectProto>; - - static constexpr FieldMetadata_Right kRight{}; - void set_right(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Bottom = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - RectProto>; - - static constexpr FieldMetadata_Bottom kBottom{}; - void set_bottom(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -class RegionProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - RegionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit RegionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit RegionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_rect() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> rect() const { return GetRepeated<::protozero::ConstBytes>(2); } -}; - -class RegionProto : public ::protozero::Message { - public: - using Decoder = RegionProto_Decoder; - enum : int32_t { - kRectFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.RegionProto"; } - - - using FieldMetadata_Rect = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - RegionProto>; - - static constexpr FieldMetadata_Rect kRect{}; - template T* add_rect() { - return BeginNestedMessage(2); - } - -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_layers.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_LAYERS_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_LAYERS_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class ActiveBufferProto; -class BarrierLayerProto; -class BlurRegion; -class ColorProto; -class ColorTransformProto; -class DisplayProto; -class FloatRectProto; -class InputWindowInfoProto; -class LayerProto; -class LayerProto_MetadataEntry; -class LayersProto; -class LayersSnapshotProto; -class PositionProto; -class RectProto; -class RegionProto; -class SizeProto; -class TransformProto; -enum HwcCompositionType : int32_t; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -enum HwcCompositionType : int32_t { - HWC_TYPE_UNSPECIFIED = 0, - HWC_TYPE_CLIENT = 1, - HWC_TYPE_DEVICE = 2, - HWC_TYPE_SOLID_COLOR = 3, - HWC_TYPE_CURSOR = 4, - HWC_TYPE_SIDEBAND = 5, - HWC_TYPE_DISPLAY_DECORATION = 6, -}; - -constexpr HwcCompositionType HwcCompositionType_MIN = HwcCompositionType::HWC_TYPE_UNSPECIFIED; -constexpr HwcCompositionType HwcCompositionType_MAX = HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* HwcCompositionType_Name(::perfetto::protos::pbzero::HwcCompositionType value) { - switch (value) { - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_UNSPECIFIED: - return "HWC_TYPE_UNSPECIFIED"; - - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CLIENT: - return "HWC_TYPE_CLIENT"; - - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DEVICE: - return "HWC_TYPE_DEVICE"; - - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SOLID_COLOR: - return "HWC_TYPE_SOLID_COLOR"; - - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_CURSOR: - return "HWC_TYPE_CURSOR"; - - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_SIDEBAND: - return "HWC_TYPE_SIDEBAND"; - - case ::perfetto::protos::pbzero::HwcCompositionType::HWC_TYPE_DISPLAY_DECORATION: - return "HWC_TYPE_DISPLAY_DECORATION"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayersTraceFileProto { -enum MagicNumber : int32_t { - INVALID = 0, - MAGIC_NUMBER_L = 1414682956, - MAGIC_NUMBER_H = 1162035538, -}; -} // namespace perfetto_pbzero_enum_LayersTraceFileProto -using LayersTraceFileProto_MagicNumber = perfetto_pbzero_enum_LayersTraceFileProto::MagicNumber; - - -constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MIN = LayersTraceFileProto_MagicNumber::INVALID; -constexpr LayersTraceFileProto_MagicNumber LayersTraceFileProto_MagicNumber_MAX = LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayersTraceFileProto_MagicNumber_Name(::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber value) { - switch (value) { - case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::INVALID: - return "INVALID"; - - case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_L: - return "MAGIC_NUMBER_L"; - - case ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber::MAGIC_NUMBER_H: - return "MAGIC_NUMBER_H"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -class BarrierLayerProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - BarrierLayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit BarrierLayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit BarrierLayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - int32_t id() const { return at<1>().as_int32(); } - bool has_frame_number() const { return at<2>().valid(); } - uint64_t frame_number() const { return at<2>().as_uint64(); } -}; - -class BarrierLayerProto : public ::protozero::Message { - public: - using Decoder = BarrierLayerProto_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kFrameNumberFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.BarrierLayerProto"; } - - - using FieldMetadata_Id = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - BarrierLayerProto>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FrameNumber = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - BarrierLayerProto>; - - static constexpr FieldMetadata_FrameNumber kFrameNumber{}; - void set_frame_number(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } -}; - -class ActiveBufferProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - ActiveBufferProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit ActiveBufferProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit ActiveBufferProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_width() const { return at<1>().valid(); } - uint32_t width() const { return at<1>().as_uint32(); } - bool has_height() const { return at<2>().valid(); } - uint32_t height() const { return at<2>().as_uint32(); } - bool has_stride() const { return at<3>().valid(); } - uint32_t stride() const { return at<3>().as_uint32(); } - bool has_format() const { return at<4>().valid(); } - int32_t format() const { return at<4>().as_int32(); } - bool has_usage() const { return at<5>().valid(); } - uint64_t usage() const { return at<5>().as_uint64(); } -}; - -class ActiveBufferProto : public ::protozero::Message { - public: - using Decoder = ActiveBufferProto_Decoder; - enum : int32_t { - kWidthFieldNumber = 1, - kHeightFieldNumber = 2, - kStrideFieldNumber = 3, - kFormatFieldNumber = 4, - kUsageFieldNumber = 5, - }; - static constexpr const char* GetName() { return ".perfetto.protos.ActiveBufferProto"; } - - - using FieldMetadata_Width = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ActiveBufferProto>; - - static constexpr FieldMetadata_Width kWidth{}; - void set_width(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Height = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ActiveBufferProto>; - - static constexpr FieldMetadata_Height kHeight{}; - void set_height(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Stride = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - ActiveBufferProto>; - - static constexpr FieldMetadata_Stride kStride{}; - void set_stride(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Stride::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Format = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - ActiveBufferProto>; - - static constexpr FieldMetadata_Format kFormat{}; - void set_format(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Format::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Usage = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - ActiveBufferProto>; - - static constexpr FieldMetadata_Usage kUsage{}; - void set_usage(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } -}; - -class FloatRectProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - FloatRectProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit FloatRectProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit FloatRectProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_left() const { return at<1>().valid(); } - float left() const { return at<1>().as_float(); } - bool has_top() const { return at<2>().valid(); } - float top() const { return at<2>().as_float(); } - bool has_right() const { return at<3>().valid(); } - float right() const { return at<3>().as_float(); } - bool has_bottom() const { return at<4>().valid(); } - float bottom() const { return at<4>().as_float(); } -}; - -class FloatRectProto : public ::protozero::Message { - public: - using Decoder = FloatRectProto_Decoder; - enum : int32_t { - kLeftFieldNumber = 1, - kTopFieldNumber = 2, - kRightFieldNumber = 3, - kBottomFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.FloatRectProto"; } - - - using FieldMetadata_Left = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FloatRectProto>; - - static constexpr FieldMetadata_Left kLeft{}; - void set_left(float value) { - static constexpr uint32_t field_id = FieldMetadata_Left::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Top = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FloatRectProto>; - - static constexpr FieldMetadata_Top kTop{}; - void set_top(float value) { - static constexpr uint32_t field_id = FieldMetadata_Top::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Right = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FloatRectProto>; - - static constexpr FieldMetadata_Right kRight{}; - void set_right(float value) { - static constexpr uint32_t field_id = FieldMetadata_Right::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Bottom = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - FloatRectProto>; - - static constexpr FieldMetadata_Bottom kBottom{}; - void set_bottom(float value) { - static constexpr uint32_t field_id = FieldMetadata_Bottom::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class PositionProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - PositionProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit PositionProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit PositionProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_x() const { return at<1>().valid(); } - float x() const { return at<1>().as_float(); } - bool has_y() const { return at<2>().valid(); } - float y() const { return at<2>().as_float(); } -}; - -class PositionProto : public ::protozero::Message { - public: - using Decoder = PositionProto_Decoder; - enum : int32_t { - kXFieldNumber = 1, - kYFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.PositionProto"; } - - - using FieldMetadata_X = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - PositionProto>; - - static constexpr FieldMetadata_X kX{}; - void set_x(float value) { - static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Y = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - PositionProto>; - - static constexpr FieldMetadata_Y kY{}; - void set_y(float value) { - static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class LayerProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - int32_t id() const { return at<1>().as_int32(); } - bool has_name() const { return at<2>().valid(); } - ::protozero::ConstChars name() const { return at<2>().as_string(); } - bool has_children() const { return at<3>().valid(); } - ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> children(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(3, parse_error_ptr); } - bool has_relatives() const { return at<4>().valid(); } - ::protozero::PackedRepeatedFieldIterator<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t> relatives(bool* parse_error_ptr) const { return GetPackedRepeated<::protozero::proto_utils::ProtoWireType::kVarInt, int32_t>(4, parse_error_ptr); } - bool has_type() const { return at<5>().valid(); } - ::protozero::ConstChars type() const { return at<5>().as_string(); } - bool has_transparent_region() const { return at<6>().valid(); } - ::protozero::ConstBytes transparent_region() const { return at<6>().as_bytes(); } - bool has_visible_region() const { return at<7>().valid(); } - ::protozero::ConstBytes visible_region() const { return at<7>().as_bytes(); } - bool has_damage_region() const { return at<8>().valid(); } - ::protozero::ConstBytes damage_region() const { return at<8>().as_bytes(); } - bool has_layer_stack() const { return at<9>().valid(); } - uint32_t layer_stack() const { return at<9>().as_uint32(); } - bool has_z() const { return at<10>().valid(); } - int32_t z() const { return at<10>().as_int32(); } - bool has_position() const { return at<11>().valid(); } - ::protozero::ConstBytes position() const { return at<11>().as_bytes(); } - bool has_requested_position() const { return at<12>().valid(); } - ::protozero::ConstBytes requested_position() const { return at<12>().as_bytes(); } - bool has_size() const { return at<13>().valid(); } - ::protozero::ConstBytes size() const { return at<13>().as_bytes(); } - bool has_crop() const { return at<14>().valid(); } - ::protozero::ConstBytes crop() const { return at<14>().as_bytes(); } - bool has_final_crop() const { return at<15>().valid(); } - ::protozero::ConstBytes final_crop() const { return at<15>().as_bytes(); } - bool has_is_opaque() const { return at<16>().valid(); } - bool is_opaque() const { return at<16>().as_bool(); } - bool has_invalidate() const { return at<17>().valid(); } - bool invalidate() const { return at<17>().as_bool(); } - bool has_dataspace() const { return at<18>().valid(); } - ::protozero::ConstChars dataspace() const { return at<18>().as_string(); } - bool has_pixel_format() const { return at<19>().valid(); } - ::protozero::ConstChars pixel_format() const { return at<19>().as_string(); } - bool has_color() const { return at<20>().valid(); } - ::protozero::ConstBytes color() const { return at<20>().as_bytes(); } - bool has_requested_color() const { return at<21>().valid(); } - ::protozero::ConstBytes requested_color() const { return at<21>().as_bytes(); } - bool has_flags() const { return at<22>().valid(); } - uint32_t flags() const { return at<22>().as_uint32(); } - bool has_transform() const { return at<23>().valid(); } - ::protozero::ConstBytes transform() const { return at<23>().as_bytes(); } - bool has_requested_transform() const { return at<24>().valid(); } - ::protozero::ConstBytes requested_transform() const { return at<24>().as_bytes(); } - bool has_parent() const { return at<25>().valid(); } - int32_t parent() const { return at<25>().as_int32(); } - bool has_z_order_relative_of() const { return at<26>().valid(); } - int32_t z_order_relative_of() const { return at<26>().as_int32(); } - bool has_active_buffer() const { return at<27>().valid(); } - ::protozero::ConstBytes active_buffer() const { return at<27>().as_bytes(); } - bool has_queued_frames() const { return at<28>().valid(); } - int32_t queued_frames() const { return at<28>().as_int32(); } - bool has_refresh_pending() const { return at<29>().valid(); } - bool refresh_pending() const { return at<29>().as_bool(); } - bool has_hwc_frame() const { return at<30>().valid(); } - ::protozero::ConstBytes hwc_frame() const { return at<30>().as_bytes(); } - bool has_hwc_crop() const { return at<31>().valid(); } - ::protozero::ConstBytes hwc_crop() const { return at<31>().as_bytes(); } - bool has_hwc_transform() const { return at<32>().valid(); } - int32_t hwc_transform() const { return at<32>().as_int32(); } - bool has_window_type() const { return at<33>().valid(); } - int32_t window_type() const { return at<33>().as_int32(); } - bool has_app_id() const { return at<34>().valid(); } - int32_t app_id() const { return at<34>().as_int32(); } - bool has_hwc_composition_type() const { return at<35>().valid(); } - int32_t hwc_composition_type() const { return at<35>().as_int32(); } - bool has_is_protected() const { return at<36>().valid(); } - bool is_protected() const { return at<36>().as_bool(); } - bool has_curr_frame() const { return at<37>().valid(); } - uint64_t curr_frame() const { return at<37>().as_uint64(); } - bool has_barrier_layer() const { return at<38>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> barrier_layer() const { return GetRepeated<::protozero::ConstBytes>(38); } - bool has_buffer_transform() const { return at<39>().valid(); } - ::protozero::ConstBytes buffer_transform() const { return at<39>().as_bytes(); } - bool has_effective_scaling_mode() const { return at<40>().valid(); } - int32_t effective_scaling_mode() const { return at<40>().as_int32(); } - bool has_corner_radius() const { return at<41>().valid(); } - float corner_radius() const { return at<41>().as_float(); } - bool has_metadata() const { return at<42>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> metadata() const { return GetRepeated<::protozero::ConstBytes>(42); } - bool has_effective_transform() const { return at<43>().valid(); } - ::protozero::ConstBytes effective_transform() const { return at<43>().as_bytes(); } - bool has_source_bounds() const { return at<44>().valid(); } - ::protozero::ConstBytes source_bounds() const { return at<44>().as_bytes(); } - bool has_bounds() const { return at<45>().valid(); } - ::protozero::ConstBytes bounds() const { return at<45>().as_bytes(); } - bool has_screen_bounds() const { return at<46>().valid(); } - ::protozero::ConstBytes screen_bounds() const { return at<46>().as_bytes(); } - bool has_input_window_info() const { return at<47>().valid(); } - ::protozero::ConstBytes input_window_info() const { return at<47>().as_bytes(); } - bool has_corner_radius_crop() const { return at<48>().valid(); } - ::protozero::ConstBytes corner_radius_crop() const { return at<48>().as_bytes(); } - bool has_shadow_radius() const { return at<49>().valid(); } - float shadow_radius() const { return at<49>().as_float(); } - bool has_color_transform() const { return at<50>().valid(); } - ::protozero::ConstBytes color_transform() const { return at<50>().as_bytes(); } - bool has_is_relative_of() const { return at<51>().valid(); } - bool is_relative_of() const { return at<51>().as_bool(); } - bool has_background_blur_radius() const { return at<52>().valid(); } - int32_t background_blur_radius() const { return at<52>().as_int32(); } - bool has_owner_uid() const { return at<53>().valid(); } - uint32_t owner_uid() const { return at<53>().as_uint32(); } - bool has_blur_regions() const { return at<54>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(54); } - bool has_is_trusted_overlay() const { return at<55>().valid(); } - bool is_trusted_overlay() const { return at<55>().as_bool(); } - bool has_requested_corner_radius() const { return at<56>().valid(); } - float requested_corner_radius() const { return at<56>().as_float(); } - bool has_destination_frame() const { return at<57>().valid(); } - ::protozero::ConstBytes destination_frame() const { return at<57>().as_bytes(); } - bool has_original_id() const { return at<58>().valid(); } - uint32_t original_id() const { return at<58>().as_uint32(); } -}; - -class LayerProto : public ::protozero::Message { - public: - using Decoder = LayerProto_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kNameFieldNumber = 2, - kChildrenFieldNumber = 3, - kRelativesFieldNumber = 4, - kTypeFieldNumber = 5, - kTransparentRegionFieldNumber = 6, - kVisibleRegionFieldNumber = 7, - kDamageRegionFieldNumber = 8, - kLayerStackFieldNumber = 9, - kZFieldNumber = 10, - kPositionFieldNumber = 11, - kRequestedPositionFieldNumber = 12, - kSizeFieldNumber = 13, - kCropFieldNumber = 14, - kFinalCropFieldNumber = 15, - kIsOpaqueFieldNumber = 16, - kInvalidateFieldNumber = 17, - kDataspaceFieldNumber = 18, - kPixelFormatFieldNumber = 19, - kColorFieldNumber = 20, - kRequestedColorFieldNumber = 21, - kFlagsFieldNumber = 22, - kTransformFieldNumber = 23, - kRequestedTransformFieldNumber = 24, - kParentFieldNumber = 25, - kZOrderRelativeOfFieldNumber = 26, - kActiveBufferFieldNumber = 27, - kQueuedFramesFieldNumber = 28, - kRefreshPendingFieldNumber = 29, - kHwcFrameFieldNumber = 30, - kHwcCropFieldNumber = 31, - kHwcTransformFieldNumber = 32, - kWindowTypeFieldNumber = 33, - kAppIdFieldNumber = 34, - kHwcCompositionTypeFieldNumber = 35, - kIsProtectedFieldNumber = 36, - kCurrFrameFieldNumber = 37, - kBarrierLayerFieldNumber = 38, - kBufferTransformFieldNumber = 39, - kEffectiveScalingModeFieldNumber = 40, - kCornerRadiusFieldNumber = 41, - kMetadataFieldNumber = 42, - kEffectiveTransformFieldNumber = 43, - kSourceBoundsFieldNumber = 44, - kBoundsFieldNumber = 45, - kScreenBoundsFieldNumber = 46, - kInputWindowInfoFieldNumber = 47, - kCornerRadiusCropFieldNumber = 48, - kShadowRadiusFieldNumber = 49, - kColorTransformFieldNumber = 50, - kIsRelativeOfFieldNumber = 51, - kBackgroundBlurRadiusFieldNumber = 52, - kOwnerUidFieldNumber = 53, - kBlurRegionsFieldNumber = 54, - kIsTrustedOverlayFieldNumber = 55, - kRequestedCornerRadiusFieldNumber = 56, - kDestinationFrameFieldNumber = 57, - kOriginalIdFieldNumber = 58, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerProto"; } - - using MetadataEntry = ::perfetto::protos::pbzero::LayerProto_MetadataEntry; - - using FieldMetadata_Id = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayerProto>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Children = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kRepeatedPacked, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_Children kChildren{}; - void set_children(const ::protozero::PackedVarInt& packed_buffer) { - AppendBytes(FieldMetadata_Children::kFieldId, packed_buffer.data(), - packed_buffer.size()); - } - - using FieldMetadata_Relatives = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedPacked, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_Relatives kRelatives{}; - void set_relatives(const ::protozero::PackedVarInt& packed_buffer) { - AppendBytes(FieldMetadata_Relatives::kFieldId, packed_buffer.data(), - packed_buffer.size()); - } - - using FieldMetadata_Type = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayerProto>; - - static constexpr FieldMetadata_Type kType{}; - void set_type(const char* data, size_t size) { - AppendBytes(FieldMetadata_Type::kFieldId, data, size); - } - void set_type(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Type::kFieldId, chars.data, chars.size); - } - void set_type(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Type::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TransparentRegion = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RegionProto, - LayerProto>; - - static constexpr FieldMetadata_TransparentRegion kTransparentRegion{}; - template T* set_transparent_region() { - return BeginNestedMessage(6); - } - - - using FieldMetadata_VisibleRegion = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RegionProto, - LayerProto>; - - static constexpr FieldMetadata_VisibleRegion kVisibleRegion{}; - template T* set_visible_region() { - return BeginNestedMessage(7); - } - - - using FieldMetadata_DamageRegion = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RegionProto, - LayerProto>; - - static constexpr FieldMetadata_DamageRegion kDamageRegion{}; - template T* set_damage_region() { - return BeginNestedMessage(8); - } - - - using FieldMetadata_LayerStack = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerProto>; - - static constexpr FieldMetadata_LayerStack kLayerStack{}; - void set_layer_stack(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Z = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_Z kZ{}; - void set_z(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Position = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - PositionProto, - LayerProto>; - - static constexpr FieldMetadata_Position kPosition{}; - template T* set_position() { - return BeginNestedMessage(11); - } - - - using FieldMetadata_RequestedPosition = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - PositionProto, - LayerProto>; - - static constexpr FieldMetadata_RequestedPosition kRequestedPosition{}; - template T* set_requested_position() { - return BeginNestedMessage(12); - } - - - using FieldMetadata_Size = - ::protozero::proto_utils::FieldMetadata< - 13, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - SizeProto, - LayerProto>; - - static constexpr FieldMetadata_Size kSize{}; - template T* set_size() { - return BeginNestedMessage(13); - } - - - using FieldMetadata_Crop = - ::protozero::proto_utils::FieldMetadata< - 14, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerProto>; - - static constexpr FieldMetadata_Crop kCrop{}; - template T* set_crop() { - return BeginNestedMessage(14); - } - - - using FieldMetadata_FinalCrop = - ::protozero::proto_utils::FieldMetadata< - 15, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerProto>; - - static constexpr FieldMetadata_FinalCrop kFinalCrop{}; - template T* set_final_crop() { - return BeginNestedMessage(15); - } - - - using FieldMetadata_IsOpaque = - ::protozero::proto_utils::FieldMetadata< - 16, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerProto>; - - static constexpr FieldMetadata_IsOpaque kIsOpaque{}; - void set_is_opaque(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsOpaque::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Invalidate = - ::protozero::proto_utils::FieldMetadata< - 17, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerProto>; - - static constexpr FieldMetadata_Invalidate kInvalidate{}; - void set_invalidate(bool value) { - static constexpr uint32_t field_id = FieldMetadata_Invalidate::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dataspace = - ::protozero::proto_utils::FieldMetadata< - 18, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayerProto>; - - static constexpr FieldMetadata_Dataspace kDataspace{}; - void set_dataspace(const char* data, size_t size) { - AppendBytes(FieldMetadata_Dataspace::kFieldId, data, size); - } - void set_dataspace(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Dataspace::kFieldId, chars.data, chars.size); - } - void set_dataspace(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Dataspace::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PixelFormat = - ::protozero::proto_utils::FieldMetadata< - 19, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayerProto>; - - static constexpr FieldMetadata_PixelFormat kPixelFormat{}; - void set_pixel_format(const char* data, size_t size) { - AppendBytes(FieldMetadata_PixelFormat::kFieldId, data, size); - } - void set_pixel_format(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_PixelFormat::kFieldId, chars.data, chars.size); - } - void set_pixel_format(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Color = - ::protozero::proto_utils::FieldMetadata< - 20, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ColorProto, - LayerProto>; - - static constexpr FieldMetadata_Color kColor{}; - template T* set_color() { - return BeginNestedMessage(20); - } - - - using FieldMetadata_RequestedColor = - ::protozero::proto_utils::FieldMetadata< - 21, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ColorProto, - LayerProto>; - - static constexpr FieldMetadata_RequestedColor kRequestedColor{}; - template T* set_requested_color() { - return BeginNestedMessage(21); - } - - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 22, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerProto>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Transform = - ::protozero::proto_utils::FieldMetadata< - 23, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransformProto, - LayerProto>; - - static constexpr FieldMetadata_Transform kTransform{}; - template T* set_transform() { - return BeginNestedMessage(23); - } - - - using FieldMetadata_RequestedTransform = - ::protozero::proto_utils::FieldMetadata< - 24, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransformProto, - LayerProto>; - - static constexpr FieldMetadata_RequestedTransform kRequestedTransform{}; - template T* set_requested_transform() { - return BeginNestedMessage(24); - } - - - using FieldMetadata_Parent = - ::protozero::proto_utils::FieldMetadata< - 25, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_Parent kParent{}; - void set_parent(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ZOrderRelativeOf = - ::protozero::proto_utils::FieldMetadata< - 26, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_ZOrderRelativeOf kZOrderRelativeOf{}; - void set_z_order_relative_of(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ZOrderRelativeOf::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ActiveBuffer = - ::protozero::proto_utils::FieldMetadata< - 27, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ActiveBufferProto, - LayerProto>; - - static constexpr FieldMetadata_ActiveBuffer kActiveBuffer{}; - template T* set_active_buffer() { - return BeginNestedMessage(27); - } - - - using FieldMetadata_QueuedFrames = - ::protozero::proto_utils::FieldMetadata< - 28, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_QueuedFrames kQueuedFrames{}; - void set_queued_frames(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_QueuedFrames::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_RefreshPending = - ::protozero::proto_utils::FieldMetadata< - 29, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerProto>; - - static constexpr FieldMetadata_RefreshPending kRefreshPending{}; - void set_refresh_pending(bool value) { - static constexpr uint32_t field_id = FieldMetadata_RefreshPending::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_HwcFrame = - ::protozero::proto_utils::FieldMetadata< - 30, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerProto>; - - static constexpr FieldMetadata_HwcFrame kHwcFrame{}; - template T* set_hwc_frame() { - return BeginNestedMessage(30); - } - - - using FieldMetadata_HwcCrop = - ::protozero::proto_utils::FieldMetadata< - 31, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FloatRectProto, - LayerProto>; - - static constexpr FieldMetadata_HwcCrop kHwcCrop{}; - template T* set_hwc_crop() { - return BeginNestedMessage(31); - } - - - using FieldMetadata_HwcTransform = - ::protozero::proto_utils::FieldMetadata< - 32, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_HwcTransform kHwcTransform{}; - void set_hwc_transform(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_HwcTransform::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_WindowType = - ::protozero::proto_utils::FieldMetadata< - 33, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_WindowType kWindowType{}; - void set_window_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_WindowType::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_AppId = - ::protozero::proto_utils::FieldMetadata< - 34, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_AppId kAppId{}; - void set_app_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_AppId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_HwcCompositionType = - ::protozero::proto_utils::FieldMetadata< - 35, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - HwcCompositionType, - LayerProto>; - - static constexpr FieldMetadata_HwcCompositionType kHwcCompositionType{}; - void set_hwc_composition_type(HwcCompositionType value) { - static constexpr uint32_t field_id = FieldMetadata_HwcCompositionType::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_IsProtected = - ::protozero::proto_utils::FieldMetadata< - 36, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerProto>; - - static constexpr FieldMetadata_IsProtected kIsProtected{}; - void set_is_protected(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsProtected::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CurrFrame = - ::protozero::proto_utils::FieldMetadata< - 37, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerProto>; - - static constexpr FieldMetadata_CurrFrame kCurrFrame{}; - void set_curr_frame(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_CurrFrame::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BarrierLayer = - ::protozero::proto_utils::FieldMetadata< - 38, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - BarrierLayerProto, - LayerProto>; - - static constexpr FieldMetadata_BarrierLayer kBarrierLayer{}; - template T* add_barrier_layer() { - return BeginNestedMessage(38); - } - - - using FieldMetadata_BufferTransform = - ::protozero::proto_utils::FieldMetadata< - 39, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransformProto, - LayerProto>; - - static constexpr FieldMetadata_BufferTransform kBufferTransform{}; - template T* set_buffer_transform() { - return BeginNestedMessage(39); - } - - - using FieldMetadata_EffectiveScalingMode = - ::protozero::proto_utils::FieldMetadata< - 40, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_EffectiveScalingMode kEffectiveScalingMode{}; - void set_effective_scaling_mode(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_EffectiveScalingMode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CornerRadius = - ::protozero::proto_utils::FieldMetadata< - 41, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerProto>; - - static constexpr FieldMetadata_CornerRadius kCornerRadius{}; - void set_corner_radius(float value) { - static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Metadata = - ::protozero::proto_utils::FieldMetadata< - 42, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerProto_MetadataEntry, - LayerProto>; - - static constexpr FieldMetadata_Metadata kMetadata{}; - template T* add_metadata() { - return BeginNestedMessage(42); - } - - - using FieldMetadata_EffectiveTransform = - ::protozero::proto_utils::FieldMetadata< - 43, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransformProto, - LayerProto>; - - static constexpr FieldMetadata_EffectiveTransform kEffectiveTransform{}; - template T* set_effective_transform() { - return BeginNestedMessage(43); - } - - - using FieldMetadata_SourceBounds = - ::protozero::proto_utils::FieldMetadata< - 44, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FloatRectProto, - LayerProto>; - - static constexpr FieldMetadata_SourceBounds kSourceBounds{}; - template T* set_source_bounds() { - return BeginNestedMessage(44); - } - - - using FieldMetadata_Bounds = - ::protozero::proto_utils::FieldMetadata< - 45, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FloatRectProto, - LayerProto>; - - static constexpr FieldMetadata_Bounds kBounds{}; - template T* set_bounds() { - return BeginNestedMessage(45); - } - - - using FieldMetadata_ScreenBounds = - ::protozero::proto_utils::FieldMetadata< - 46, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FloatRectProto, - LayerProto>; - - static constexpr FieldMetadata_ScreenBounds kScreenBounds{}; - template T* set_screen_bounds() { - return BeginNestedMessage(46); - } - - - using FieldMetadata_InputWindowInfo = - ::protozero::proto_utils::FieldMetadata< - 47, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - InputWindowInfoProto, - LayerProto>; - - static constexpr FieldMetadata_InputWindowInfo kInputWindowInfo{}; - template T* set_input_window_info() { - return BeginNestedMessage(47); - } - - - using FieldMetadata_CornerRadiusCrop = - ::protozero::proto_utils::FieldMetadata< - 48, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - FloatRectProto, - LayerProto>; - - static constexpr FieldMetadata_CornerRadiusCrop kCornerRadiusCrop{}; - template T* set_corner_radius_crop() { - return BeginNestedMessage(48); - } - - - using FieldMetadata_ShadowRadius = - ::protozero::proto_utils::FieldMetadata< - 49, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerProto>; - - static constexpr FieldMetadata_ShadowRadius kShadowRadius{}; - void set_shadow_radius(float value) { - static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ColorTransform = - ::protozero::proto_utils::FieldMetadata< - 50, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ColorTransformProto, - LayerProto>; - - static constexpr FieldMetadata_ColorTransform kColorTransform{}; - template T* set_color_transform() { - return BeginNestedMessage(50); - } - - - using FieldMetadata_IsRelativeOf = - ::protozero::proto_utils::FieldMetadata< - 51, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerProto>; - - static constexpr FieldMetadata_IsRelativeOf kIsRelativeOf{}; - void set_is_relative_of(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsRelativeOf::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BackgroundBlurRadius = - ::protozero::proto_utils::FieldMetadata< - 52, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto>; - - static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{}; - void set_background_blur_radius(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_OwnerUid = - ::protozero::proto_utils::FieldMetadata< - 53, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerProto>; - - static constexpr FieldMetadata_OwnerUid kOwnerUid{}; - void set_owner_uid(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_OwnerUid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BlurRegions = - ::protozero::proto_utils::FieldMetadata< - 54, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - BlurRegion, - LayerProto>; - - static constexpr FieldMetadata_BlurRegions kBlurRegions{}; - template T* add_blur_regions() { - return BeginNestedMessage(54); - } - - - using FieldMetadata_IsTrustedOverlay = - ::protozero::proto_utils::FieldMetadata< - 55, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerProto>; - - static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{}; - void set_is_trusted_overlay(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_RequestedCornerRadius = - ::protozero::proto_utils::FieldMetadata< - 56, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerProto>; - - static constexpr FieldMetadata_RequestedCornerRadius kRequestedCornerRadius{}; - void set_requested_corner_radius(float value) { - static constexpr uint32_t field_id = FieldMetadata_RequestedCornerRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DestinationFrame = - ::protozero::proto_utils::FieldMetadata< - 57, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerProto>; - - static constexpr FieldMetadata_DestinationFrame kDestinationFrame{}; - template T* set_destination_frame() { - return BeginNestedMessage(57); - } - - - using FieldMetadata_OriginalId = - ::protozero::proto_utils::FieldMetadata< - 58, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerProto>; - - static constexpr FieldMetadata_OriginalId kOriginalId{}; - void set_original_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_OriginalId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class LayerProto_MetadataEntry_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerProto_MetadataEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerProto_MetadataEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerProto_MetadataEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_key() const { return at<1>().valid(); } - int32_t key() const { return at<1>().as_int32(); } - bool has_value() const { return at<2>().valid(); } - ::protozero::ConstChars value() const { return at<2>().as_string(); } -}; - -class LayerProto_MetadataEntry : public ::protozero::Message { - public: - using Decoder = LayerProto_MetadataEntry_Decoder; - enum : int32_t { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerProto.MetadataEntry"; } - - - using FieldMetadata_Key = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerProto_MetadataEntry>; - - static constexpr FieldMetadata_Key kKey{}; - void set_key(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Value = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayerProto_MetadataEntry>; - - static constexpr FieldMetadata_Value kValue{}; - void set_value(const char* data, size_t size) { - AppendBytes(FieldMetadata_Value::kFieldId, data, size); - } - void set_value(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); - } - void set_value(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } -}; - -class DisplayProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - DisplayProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit DisplayProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit DisplayProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - uint64_t id() const { return at<1>().as_uint64(); } - bool has_name() const { return at<2>().valid(); } - ::protozero::ConstChars name() const { return at<2>().as_string(); } - bool has_layer_stack() const { return at<3>().valid(); } - uint32_t layer_stack() const { return at<3>().as_uint32(); } - bool has_size() const { return at<4>().valid(); } - ::protozero::ConstBytes size() const { return at<4>().as_bytes(); } - bool has_layer_stack_space_rect() const { return at<5>().valid(); } - ::protozero::ConstBytes layer_stack_space_rect() const { return at<5>().as_bytes(); } - bool has_transform() const { return at<6>().valid(); } - ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); } - bool has_is_virtual() const { return at<7>().valid(); } - bool is_virtual() const { return at<7>().as_bool(); } - bool has_dpi_x() const { return at<8>().valid(); } - double dpi_x() const { return at<8>().as_double(); } - bool has_dpi_y() const { return at<9>().valid(); } - double dpi_y() const { return at<9>().as_double(); } -}; - -class DisplayProto : public ::protozero::Message { - public: - using Decoder = DisplayProto_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kNameFieldNumber = 2, - kLayerStackFieldNumber = 3, - kSizeFieldNumber = 4, - kLayerStackSpaceRectFieldNumber = 5, - kTransformFieldNumber = 6, - kIsVirtualFieldNumber = 7, - kDpiXFieldNumber = 8, - kDpiYFieldNumber = 9, - }; - static constexpr const char* GetName() { return ".perfetto.protos.DisplayProto"; } - - - using FieldMetadata_Id = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - DisplayProto>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - DisplayProto>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerStack = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayProto>; - - static constexpr FieldMetadata_LayerStack kLayerStack{}; - void set_layer_stack(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Size = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - SizeProto, - DisplayProto>; - - static constexpr FieldMetadata_Size kSize{}; - template T* set_size() { - return BeginNestedMessage(4); - } - - - using FieldMetadata_LayerStackSpaceRect = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - DisplayProto>; - - static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{}; - template T* set_layer_stack_space_rect() { - return BeginNestedMessage(5); - } - - - using FieldMetadata_Transform = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransformProto, - DisplayProto>; - - static constexpr FieldMetadata_Transform kTransform{}; - template T* set_transform() { - return BeginNestedMessage(6); - } - - - using FieldMetadata_IsVirtual = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - DisplayProto>; - - static constexpr FieldMetadata_IsVirtual kIsVirtual{}; - void set_is_virtual(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DpiX = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kDouble, - double, - DisplayProto>; - - static constexpr FieldMetadata_DpiX kDpiX{}; - void set_dpi_x(double value) { - static constexpr uint32_t field_id = FieldMetadata_DpiX::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kDouble> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DpiY = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kDouble, - double, - DisplayProto>; - - static constexpr FieldMetadata_DpiY kDpiY{}; - void set_dpi_y(double value) { - static constexpr uint32_t field_id = FieldMetadata_DpiY::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kDouble> - ::Append(*this, field_id, value); - } -}; - -class LayersProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayersProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayersProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayersProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_layers() const { return at<1>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layers() const { return GetRepeated<::protozero::ConstBytes>(1); } -}; - -class LayersProto : public ::protozero::Message { - public: - using Decoder = LayersProto_Decoder; - enum : int32_t { - kLayersFieldNumber = 1, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayersProto"; } - - - using FieldMetadata_Layers = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerProto, - LayersProto>; - - static constexpr FieldMetadata_Layers kLayers{}; - template T* add_layers() { - return BeginNestedMessage(1); - } - -}; - -class LayersSnapshotProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayersSnapshotProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayersSnapshotProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayersSnapshotProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_elapsed_realtime_nanos() const { return at<1>().valid(); } - int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); } - bool has_where() const { return at<2>().valid(); } - ::protozero::ConstChars where() const { return at<2>().as_string(); } - bool has_layers() const { return at<3>().valid(); } - ::protozero::ConstBytes layers() const { return at<3>().as_bytes(); } - bool has_hwc_blob() const { return at<4>().valid(); } - ::protozero::ConstChars hwc_blob() const { return at<4>().as_string(); } - bool has_excludes_composition_state() const { return at<5>().valid(); } - bool excludes_composition_state() const { return at<5>().as_bool(); } - bool has_missed_entries() const { return at<6>().valid(); } - uint32_t missed_entries() const { return at<6>().as_uint32(); } - bool has_displays() const { return at<7>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(7); } - bool has_vsync_id() const { return at<8>().valid(); } - int64_t vsync_id() const { return at<8>().as_int64(); } -}; - -class LayersSnapshotProto : public ::protozero::Message { - public: - using Decoder = LayersSnapshotProto_Decoder; - enum : int32_t { - kElapsedRealtimeNanosFieldNumber = 1, - kWhereFieldNumber = 2, - kLayersFieldNumber = 3, - kHwcBlobFieldNumber = 4, - kExcludesCompositionStateFieldNumber = 5, - kMissedEntriesFieldNumber = 6, - kDisplaysFieldNumber = 7, - kVsyncIdFieldNumber = 8, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayersSnapshotProto"; } - - - using FieldMetadata_ElapsedRealtimeNanos = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kSfixed64, - int64_t, - LayersSnapshotProto>; - - static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{}; - void set_elapsed_realtime_nanos(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kSfixed64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Where = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayersSnapshotProto>; - - static constexpr FieldMetadata_Where kWhere{}; - void set_where(const char* data, size_t size) { - AppendBytes(FieldMetadata_Where::kFieldId, data, size); - } - void set_where(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Where::kFieldId, chars.data, chars.size); - } - void set_where(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Where::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Layers = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayersProto, - LayersSnapshotProto>; - - static constexpr FieldMetadata_Layers kLayers{}; - template T* set_layers() { - return BeginNestedMessage(3); - } - - - using FieldMetadata_HwcBlob = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayersSnapshotProto>; - - static constexpr FieldMetadata_HwcBlob kHwcBlob{}; - void set_hwc_blob(const char* data, size_t size) { - AppendBytes(FieldMetadata_HwcBlob::kFieldId, data, size); - } - void set_hwc_blob(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_HwcBlob::kFieldId, chars.data, chars.size); - } - void set_hwc_blob(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_HwcBlob::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ExcludesCompositionState = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayersSnapshotProto>; - - static constexpr FieldMetadata_ExcludesCompositionState kExcludesCompositionState{}; - void set_excludes_composition_state(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ExcludesCompositionState::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MissedEntries = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayersSnapshotProto>; - - static constexpr FieldMetadata_MissedEntries kMissedEntries{}; - void set_missed_entries(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MissedEntries::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Displays = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - DisplayProto, - LayersSnapshotProto>; - - static constexpr FieldMetadata_Displays kDisplays{}; - template T* add_displays() { - return BeginNestedMessage(7); - } - - - using FieldMetadata_VsyncId = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - LayersSnapshotProto>; - - static constexpr FieldMetadata_VsyncId kVsyncId{}; - void set_vsync_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } -}; - -class LayersTraceFileProto_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayersTraceFileProto_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayersTraceFileProto_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayersTraceFileProto_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_magic_number() const { return at<1>().valid(); } - uint64_t magic_number() const { return at<1>().as_uint64(); } - bool has_entry() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); } - bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); } - uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); } -}; - -class LayersTraceFileProto : public ::protozero::Message { - public: - using Decoder = LayersTraceFileProto_Decoder; - enum : int32_t { - kMagicNumberFieldNumber = 1, - kEntryFieldNumber = 2, - kRealToElapsedTimeOffsetNanosFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayersTraceFileProto"; } - - - using MagicNumber = ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber; - static inline const char* MagicNumber_Name(MagicNumber value) { - return ::perfetto::protos::pbzero::LayersTraceFileProto_MagicNumber_Name(value); - } - static inline const MagicNumber INVALID = MagicNumber::INVALID; - static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L; - static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H; - - using FieldMetadata_MagicNumber = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed64, - uint64_t, - LayersTraceFileProto>; - - static constexpr FieldMetadata_MagicNumber kMagicNumber{}; - void set_magic_number(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Entry = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayersSnapshotProto, - LayersTraceFileProto>; - - static constexpr FieldMetadata_Entry kEntry{}; - template T* add_entry() { - return BeginNestedMessage(2); - } - - - using FieldMetadata_RealToElapsedTimeOffsetNanos = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed64, - uint64_t, - LayersTraceFileProto>; - - static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{}; - void set_real_to_elapsed_time_offset_nanos(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed64> - ::Append(*this, field_id, value); - } -}; - -} // Namespace. -} // Namespace. -} // Namespace. -#endif // Include guard. -// gen_amalgamated begin header: gen/protos/perfetto/trace/android/surfaceflinger_transactions.pbzero.h -// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. - -#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_TRANSACTIONS_PROTO_H_ -#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_ANDROID_SURFACEFLINGER_TRANSACTIONS_PROTO_H_ - -#include -#include - -// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" -// gen_amalgamated expanded: #include "perfetto/protozero/message.h" -// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" -// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" - -namespace perfetto { -namespace protos { -namespace pbzero { -class BlurRegion; -class ColorTransformProto; -class DisplayInfo; -class DisplayState; -class LayerCreationArgs; -class LayerState; -class LayerState_BufferData; -class LayerState_Color3; -class LayerState_Matrix22; -class LayerState_WindowInfo; -class RectProto; -class RegionProto; -class TransactionState; -class TransactionTraceEntry; -class Transform; -namespace perfetto_pbzero_enum_LayerState_BufferData { -enum PixelFormat : int32_t; -} // namespace perfetto_pbzero_enum_LayerState_BufferData -using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat; -namespace perfetto_pbzero_enum_LayerState { -enum DropInputMode : int32_t; -} // namespace perfetto_pbzero_enum_LayerState -using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode; -} // Namespace pbzero. -} // Namespace protos. -} // Namespace perfetto. - -namespace perfetto { -namespace protos { -namespace pbzero { - -namespace perfetto_pbzero_enum_DisplayState { -enum Changes : int32_t { - eChangesNone = 0, - eSurfaceChanged = 1, - eLayerStackChanged = 2, - eDisplayProjectionChanged = 4, - eDisplaySizeChanged = 8, - eFlagsChanged = 16, -}; -} // namespace perfetto_pbzero_enum_DisplayState -using DisplayState_Changes = perfetto_pbzero_enum_DisplayState::Changes; - - -constexpr DisplayState_Changes DisplayState_Changes_MIN = DisplayState_Changes::eChangesNone; -constexpr DisplayState_Changes DisplayState_Changes_MAX = DisplayState_Changes::eFlagsChanged; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* DisplayState_Changes_Name(::perfetto::protos::pbzero::DisplayState_Changes value) { - switch (value) { - case ::perfetto::protos::pbzero::DisplayState_Changes::eChangesNone: - return "eChangesNone"; - - case ::perfetto::protos::pbzero::DisplayState_Changes::eSurfaceChanged: - return "eSurfaceChanged"; - - case ::perfetto::protos::pbzero::DisplayState_Changes::eLayerStackChanged: - return "eLayerStackChanged"; - - case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplayProjectionChanged: - return "eDisplayProjectionChanged"; - - case ::perfetto::protos::pbzero::DisplayState_Changes::eDisplaySizeChanged: - return "eDisplaySizeChanged"; - - case ::perfetto::protos::pbzero::DisplayState_Changes::eFlagsChanged: - return "eFlagsChanged"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayerState { -enum ChangesLsb : int32_t { - eChangesLsbNone = 0, - ePositionChanged = 1, - eLayerChanged = 2, - eAlphaChanged = 8, - eMatrixChanged = 16, - eTransparentRegionChanged = 32, - eFlagsChanged = 64, - eLayerStackChanged = 128, - eReleaseBufferListenerChanged = 1024, - eShadowRadiusChanged = 2048, - eBufferCropChanged = 8192, - eRelativeLayerChanged = 16384, - eReparent = 32768, - eColorChanged = 65536, - eBufferTransformChanged = 262144, - eTransformToDisplayInverseChanged = 524288, - eCropChanged = 1048576, - eBufferChanged = 2097152, - eAcquireFenceChanged = 4194304, - eDataspaceChanged = 8388608, - eHdrMetadataChanged = 16777216, - eSurfaceDamageRegionChanged = 33554432, - eApiChanged = 67108864, - eSidebandStreamChanged = 134217728, - eColorTransformChanged = 268435456, - eHasListenerCallbacksChanged = 536870912, - eInputInfoChanged = 1073741824, - eCornerRadiusChanged = -2147483648, -}; -} // namespace perfetto_pbzero_enum_LayerState -using LayerState_ChangesLsb = perfetto_pbzero_enum_LayerState::ChangesLsb; - - -constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MIN = LayerState_ChangesLsb::eCornerRadiusChanged; -constexpr LayerState_ChangesLsb LayerState_ChangesLsb_MAX = LayerState_ChangesLsb::eInputInfoChanged; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayerState_ChangesLsb_Name(::perfetto::protos::pbzero::LayerState_ChangesLsb value) { - switch (value) { - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eChangesLsbNone: - return "eChangesLsbNone"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::ePositionChanged: - return "ePositionChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerChanged: - return "eLayerChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAlphaChanged: - return "eAlphaChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eMatrixChanged: - return "eMatrixChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransparentRegionChanged: - return "eTransparentRegionChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eFlagsChanged: - return "eFlagsChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eLayerStackChanged: - return "eLayerStackChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReleaseBufferListenerChanged: - return "eReleaseBufferListenerChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eShadowRadiusChanged: - return "eShadowRadiusChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferCropChanged: - return "eBufferCropChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eRelativeLayerChanged: - return "eRelativeLayerChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eReparent: - return "eReparent"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorChanged: - return "eColorChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferTransformChanged: - return "eBufferTransformChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eTransformToDisplayInverseChanged: - return "eTransformToDisplayInverseChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCropChanged: - return "eCropChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eBufferChanged: - return "eBufferChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eAcquireFenceChanged: - return "eAcquireFenceChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eDataspaceChanged: - return "eDataspaceChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHdrMetadataChanged: - return "eHdrMetadataChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSurfaceDamageRegionChanged: - return "eSurfaceDamageRegionChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eApiChanged: - return "eApiChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eSidebandStreamChanged: - return "eSidebandStreamChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eColorTransformChanged: - return "eColorTransformChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eHasListenerCallbacksChanged: - return "eHasListenerCallbacksChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eInputInfoChanged: - return "eInputInfoChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesLsb::eCornerRadiusChanged: - return "eCornerRadiusChanged"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayerState { -enum ChangesMsb : int32_t { - eChangesMsbNone = 0, - eDestinationFrameChanged = 1, - eCachedBufferChanged = 2, - eBackgroundColorChanged = 4, - eMetadataChanged = 8, - eColorSpaceAgnosticChanged = 16, - eFrameRateSelectionPriority = 32, - eFrameRateChanged = 64, - eBackgroundBlurRadiusChanged = 128, - eProducerDisconnect = 256, - eFixedTransformHintChanged = 512, - eFrameNumberChanged = 1024, - eBlurRegionsChanged = 2048, - eAutoRefreshChanged = 4096, - eStretchChanged = 8192, - eTrustedOverlayChanged = 16384, - eDropInputModeChanged = 32768, -}; -} // namespace perfetto_pbzero_enum_LayerState -using LayerState_ChangesMsb = perfetto_pbzero_enum_LayerState::ChangesMsb; - - -constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MIN = LayerState_ChangesMsb::eChangesMsbNone; -constexpr LayerState_ChangesMsb LayerState_ChangesMsb_MAX = LayerState_ChangesMsb::eDropInputModeChanged; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayerState_ChangesMsb_Name(::perfetto::protos::pbzero::LayerState_ChangesMsb value) { - switch (value) { - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eChangesMsbNone: - return "eChangesMsbNone"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDestinationFrameChanged: - return "eDestinationFrameChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eCachedBufferChanged: - return "eCachedBufferChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundColorChanged: - return "eBackgroundColorChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eMetadataChanged: - return "eMetadataChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eColorSpaceAgnosticChanged: - return "eColorSpaceAgnosticChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateSelectionPriority: - return "eFrameRateSelectionPriority"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameRateChanged: - return "eFrameRateChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBackgroundBlurRadiusChanged: - return "eBackgroundBlurRadiusChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eProducerDisconnect: - return "eProducerDisconnect"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFixedTransformHintChanged: - return "eFixedTransformHintChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eFrameNumberChanged: - return "eFrameNumberChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eBlurRegionsChanged: - return "eBlurRegionsChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eAutoRefreshChanged: - return "eAutoRefreshChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eStretchChanged: - return "eStretchChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eTrustedOverlayChanged: - return "eTrustedOverlayChanged"; - - case ::perfetto::protos::pbzero::LayerState_ChangesMsb::eDropInputModeChanged: - return "eDropInputModeChanged"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayerState { -enum Flags : int32_t { - eFlagsNone = 0, - eLayerHidden = 1, - eLayerOpaque = 2, - eLayerSkipScreenshot = 64, - eLayerSecure = 128, - eEnableBackpressure = 256, - eLayerIsDisplayDecoration = 512, -}; -} // namespace perfetto_pbzero_enum_LayerState -using LayerState_Flags = perfetto_pbzero_enum_LayerState::Flags; - - -constexpr LayerState_Flags LayerState_Flags_MIN = LayerState_Flags::eFlagsNone; -constexpr LayerState_Flags LayerState_Flags_MAX = LayerState_Flags::eLayerIsDisplayDecoration; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayerState_Flags_Name(::perfetto::protos::pbzero::LayerState_Flags value) { - switch (value) { - case ::perfetto::protos::pbzero::LayerState_Flags::eFlagsNone: - return "eFlagsNone"; - - case ::perfetto::protos::pbzero::LayerState_Flags::eLayerHidden: - return "eLayerHidden"; - - case ::perfetto::protos::pbzero::LayerState_Flags::eLayerOpaque: - return "eLayerOpaque"; - - case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSkipScreenshot: - return "eLayerSkipScreenshot"; - - case ::perfetto::protos::pbzero::LayerState_Flags::eLayerSecure: - return "eLayerSecure"; - - case ::perfetto::protos::pbzero::LayerState_Flags::eEnableBackpressure: - return "eEnableBackpressure"; - - case ::perfetto::protos::pbzero::LayerState_Flags::eLayerIsDisplayDecoration: - return "eLayerIsDisplayDecoration"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayerState { -enum DropInputMode : int32_t { - NONE = 0, - ALL = 1, - OBSCURED = 2, -}; -} // namespace perfetto_pbzero_enum_LayerState -using LayerState_DropInputMode = perfetto_pbzero_enum_LayerState::DropInputMode; - - -constexpr LayerState_DropInputMode LayerState_DropInputMode_MIN = LayerState_DropInputMode::NONE; -constexpr LayerState_DropInputMode LayerState_DropInputMode_MAX = LayerState_DropInputMode::OBSCURED; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayerState_DropInputMode_Name(::perfetto::protos::pbzero::LayerState_DropInputMode value) { - switch (value) { - case ::perfetto::protos::pbzero::LayerState_DropInputMode::NONE: - return "NONE"; - - case ::perfetto::protos::pbzero::LayerState_DropInputMode::ALL: - return "ALL"; - - case ::perfetto::protos::pbzero::LayerState_DropInputMode::OBSCURED: - return "OBSCURED"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayerState_BufferData { -enum BufferDataChange : int32_t { - BufferDataChangeNone = 0, - fenceChanged = 1, - frameNumberChanged = 2, - cachedBufferChanged = 4, -}; -} // namespace perfetto_pbzero_enum_LayerState_BufferData -using LayerState_BufferData_BufferDataChange = perfetto_pbzero_enum_LayerState_BufferData::BufferDataChange; - - -constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MIN = LayerState_BufferData_BufferDataChange::BufferDataChangeNone; -constexpr LayerState_BufferData_BufferDataChange LayerState_BufferData_BufferDataChange_MAX = LayerState_BufferData_BufferDataChange::cachedBufferChanged; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayerState_BufferData_BufferDataChange_Name(::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange value) { - switch (value) { - case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::BufferDataChangeNone: - return "BufferDataChangeNone"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::fenceChanged: - return "fenceChanged"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::frameNumberChanged: - return "frameNumberChanged"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange::cachedBufferChanged: - return "cachedBufferChanged"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_LayerState_BufferData { -enum PixelFormat : int32_t { - PIXEL_FORMAT_UNKNOWN = 0, - PIXEL_FORMAT_CUSTOM = -4, - PIXEL_FORMAT_TRANSLUCENT = -3, - PIXEL_FORMAT_TRANSPARENT = -2, - PIXEL_FORMAT_OPAQUE = -1, - PIXEL_FORMAT_RGBA_8888 = 1, - PIXEL_FORMAT_RGBX_8888 = 2, - PIXEL_FORMAT_RGB_888 = 3, - PIXEL_FORMAT_RGB_565 = 4, - PIXEL_FORMAT_BGRA_8888 = 5, - PIXEL_FORMAT_RGBA_5551 = 6, - PIXEL_FORMAT_RGBA_4444 = 7, - PIXEL_FORMAT_RGBA_FP16 = 22, - PIXEL_FORMAT_RGBA_1010102 = 43, - PIXEL_FORMAT_R_8 = 56, -}; -} // namespace perfetto_pbzero_enum_LayerState_BufferData -using LayerState_BufferData_PixelFormat = perfetto_pbzero_enum_LayerState_BufferData::PixelFormat; - - -constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MIN = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM; -constexpr LayerState_BufferData_PixelFormat LayerState_BufferData_PixelFormat_MAX = LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* LayerState_BufferData_PixelFormat_Name(::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat value) { - switch (value) { - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_UNKNOWN: - return "PIXEL_FORMAT_UNKNOWN"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_CUSTOM: - return "PIXEL_FORMAT_CUSTOM"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSLUCENT: - return "PIXEL_FORMAT_TRANSLUCENT"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_TRANSPARENT: - return "PIXEL_FORMAT_TRANSPARENT"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_OPAQUE: - return "PIXEL_FORMAT_OPAQUE"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_8888: - return "PIXEL_FORMAT_RGBA_8888"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBX_8888: - return "PIXEL_FORMAT_RGBX_8888"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_888: - return "PIXEL_FORMAT_RGB_888"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGB_565: - return "PIXEL_FORMAT_RGB_565"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_BGRA_8888: - return "PIXEL_FORMAT_BGRA_8888"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_5551: - return "PIXEL_FORMAT_RGBA_5551"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_4444: - return "PIXEL_FORMAT_RGBA_4444"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_FP16: - return "PIXEL_FORMAT_RGBA_FP16"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_RGBA_1010102: - return "PIXEL_FORMAT_RGBA_1010102"; - - case ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat::PIXEL_FORMAT_R_8: - return "PIXEL_FORMAT_R_8"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -namespace perfetto_pbzero_enum_TransactionTraceFile { -enum MagicNumber : int32_t { - INVALID = 0, - MAGIC_NUMBER_L = 1415073364, - MAGIC_NUMBER_H = 1162035538, -}; -} // namespace perfetto_pbzero_enum_TransactionTraceFile -using TransactionTraceFile_MagicNumber = perfetto_pbzero_enum_TransactionTraceFile::MagicNumber; - - -constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MIN = TransactionTraceFile_MagicNumber::INVALID; -constexpr TransactionTraceFile_MagicNumber TransactionTraceFile_MagicNumber_MAX = TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L; - - -PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE -const char* TransactionTraceFile_MagicNumber_Name(::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber value) { - switch (value) { - case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::INVALID: - return "INVALID"; - - case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_L: - return "MAGIC_NUMBER_L"; - - case ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber::MAGIC_NUMBER_H: - return "MAGIC_NUMBER_H"; - } - return "PBZERO_UNKNOWN_ENUM_VALUE"; -} - -class DisplayState_Decoder : public ::protozero::TypedProtoDecoder { - public: - DisplayState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit DisplayState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit DisplayState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_id() const { return at<1>().valid(); } - int32_t id() const { return at<1>().as_int32(); } - bool has_what() const { return at<2>().valid(); } - uint32_t what() const { return at<2>().as_uint32(); } - bool has_flags() const { return at<3>().valid(); } - uint32_t flags() const { return at<3>().as_uint32(); } - bool has_layer_stack() const { return at<4>().valid(); } - uint32_t layer_stack() const { return at<4>().as_uint32(); } - bool has_orientation() const { return at<5>().valid(); } - uint32_t orientation() const { return at<5>().as_uint32(); } - bool has_layer_stack_space_rect() const { return at<6>().valid(); } - ::protozero::ConstBytes layer_stack_space_rect() const { return at<6>().as_bytes(); } - bool has_oriented_display_space_rect() const { return at<7>().valid(); } - ::protozero::ConstBytes oriented_display_space_rect() const { return at<7>().as_bytes(); } - bool has_width() const { return at<8>().valid(); } - uint32_t width() const { return at<8>().as_uint32(); } - bool has_height() const { return at<9>().valid(); } - uint32_t height() const { return at<9>().as_uint32(); } -}; - -class DisplayState : public ::protozero::Message { - public: - using Decoder = DisplayState_Decoder; - enum : int32_t { - kIdFieldNumber = 1, - kWhatFieldNumber = 2, - kFlagsFieldNumber = 3, - kLayerStackFieldNumber = 4, - kOrientationFieldNumber = 5, - kLayerStackSpaceRectFieldNumber = 6, - kOrientedDisplaySpaceRectFieldNumber = 7, - kWidthFieldNumber = 8, - kHeightFieldNumber = 9, - }; - static constexpr const char* GetName() { return ".perfetto.protos.DisplayState"; } - - - using Changes = ::perfetto::protos::pbzero::DisplayState_Changes; - static inline const char* Changes_Name(Changes value) { - return ::perfetto::protos::pbzero::DisplayState_Changes_Name(value); - } - static inline const Changes eChangesNone = Changes::eChangesNone; - static inline const Changes eSurfaceChanged = Changes::eSurfaceChanged; - static inline const Changes eLayerStackChanged = Changes::eLayerStackChanged; - static inline const Changes eDisplayProjectionChanged = Changes::eDisplayProjectionChanged; - static inline const Changes eDisplaySizeChanged = Changes::eDisplaySizeChanged; - static inline const Changes eFlagsChanged = Changes::eFlagsChanged; - - using FieldMetadata_Id = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - DisplayState>; - - static constexpr FieldMetadata_Id kId{}; - void set_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Id::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_What = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayState>; - - static constexpr FieldMetadata_What kWhat{}; - void set_what(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_What::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayState>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerStack = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayState>; - - static constexpr FieldMetadata_LayerStack kLayerStack{}; - void set_layer_stack(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Orientation = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayState>; - - static constexpr FieldMetadata_Orientation kOrientation{}; - void set_orientation(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Orientation::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerStackSpaceRect = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - DisplayState>; - - static constexpr FieldMetadata_LayerStackSpaceRect kLayerStackSpaceRect{}; - template T* set_layer_stack_space_rect() { - return BeginNestedMessage(6); - } - - - using FieldMetadata_OrientedDisplaySpaceRect = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - DisplayState>; - - static constexpr FieldMetadata_OrientedDisplaySpaceRect kOrientedDisplaySpaceRect{}; - template T* set_oriented_display_space_rect() { - return BeginNestedMessage(7); - } - - - using FieldMetadata_Width = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayState>; - - static constexpr FieldMetadata_Width kWidth{}; - void set_width(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Height = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayState>; - - static constexpr FieldMetadata_Height kHeight{}; - void set_height(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class LayerState_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_layer_id() const { return at<1>().valid(); } - uint32_t layer_id() const { return at<1>().as_uint32(); } - bool has_what() const { return at<2>().valid(); } - uint64_t what() const { return at<2>().as_uint64(); } - bool has_x() const { return at<3>().valid(); } - float x() const { return at<3>().as_float(); } - bool has_y() const { return at<4>().valid(); } - float y() const { return at<4>().as_float(); } - bool has_z() const { return at<5>().valid(); } - int32_t z() const { return at<5>().as_int32(); } - bool has_w() const { return at<6>().valid(); } - uint32_t w() const { return at<6>().as_uint32(); } - bool has_h() const { return at<7>().valid(); } - uint32_t h() const { return at<7>().as_uint32(); } - bool has_layer_stack() const { return at<8>().valid(); } - uint32_t layer_stack() const { return at<8>().as_uint32(); } - bool has_flags() const { return at<9>().valid(); } - uint32_t flags() const { return at<9>().as_uint32(); } - bool has_mask() const { return at<10>().valid(); } - uint32_t mask() const { return at<10>().as_uint32(); } - bool has_matrix() const { return at<11>().valid(); } - ::protozero::ConstBytes matrix() const { return at<11>().as_bytes(); } - bool has_corner_radius() const { return at<12>().valid(); } - float corner_radius() const { return at<12>().as_float(); } - bool has_background_blur_radius() const { return at<13>().valid(); } - uint32_t background_blur_radius() const { return at<13>().as_uint32(); } - bool has_parent_id() const { return at<14>().valid(); } - uint32_t parent_id() const { return at<14>().as_uint32(); } - bool has_relative_parent_id() const { return at<15>().valid(); } - uint32_t relative_parent_id() const { return at<15>().as_uint32(); } - bool has_alpha() const { return at<16>().valid(); } - float alpha() const { return at<16>().as_float(); } - bool has_color() const { return at<17>().valid(); } - ::protozero::ConstBytes color() const { return at<17>().as_bytes(); } - bool has_transparent_region() const { return at<18>().valid(); } - ::protozero::ConstBytes transparent_region() const { return at<18>().as_bytes(); } - bool has_transform() const { return at<19>().valid(); } - uint32_t transform() const { return at<19>().as_uint32(); } - bool has_transform_to_display_inverse() const { return at<20>().valid(); } - bool transform_to_display_inverse() const { return at<20>().as_bool(); } - bool has_crop() const { return at<21>().valid(); } - ::protozero::ConstBytes crop() const { return at<21>().as_bytes(); } - bool has_buffer_data() const { return at<22>().valid(); } - ::protozero::ConstBytes buffer_data() const { return at<22>().as_bytes(); } - bool has_api() const { return at<23>().valid(); } - int32_t api() const { return at<23>().as_int32(); } - bool has_has_sideband_stream() const { return at<24>().valid(); } - bool has_sideband_stream() const { return at<24>().as_bool(); } - bool has_color_transform() const { return at<25>().valid(); } - ::protozero::ConstBytes color_transform() const { return at<25>().as_bytes(); } - bool has_blur_regions() const { return at<26>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> blur_regions() const { return GetRepeated<::protozero::ConstBytes>(26); } - bool has_window_info_handle() const { return at<27>().valid(); } - ::protozero::ConstBytes window_info_handle() const { return at<27>().as_bytes(); } - bool has_bg_color_alpha() const { return at<28>().valid(); } - float bg_color_alpha() const { return at<28>().as_float(); } - bool has_bg_color_dataspace() const { return at<29>().valid(); } - int32_t bg_color_dataspace() const { return at<29>().as_int32(); } - bool has_color_space_agnostic() const { return at<30>().valid(); } - bool color_space_agnostic() const { return at<30>().as_bool(); } - bool has_shadow_radius() const { return at<31>().valid(); } - float shadow_radius() const { return at<31>().as_float(); } - bool has_frame_rate_selection_priority() const { return at<32>().valid(); } - int32_t frame_rate_selection_priority() const { return at<32>().as_int32(); } - bool has_frame_rate() const { return at<33>().valid(); } - float frame_rate() const { return at<33>().as_float(); } - bool has_frame_rate_compatibility() const { return at<34>().valid(); } - int32_t frame_rate_compatibility() const { return at<34>().as_int32(); } - bool has_change_frame_rate_strategy() const { return at<35>().valid(); } - int32_t change_frame_rate_strategy() const { return at<35>().as_int32(); } - bool has_fixed_transform_hint() const { return at<36>().valid(); } - uint32_t fixed_transform_hint() const { return at<36>().as_uint32(); } - bool has_frame_number() const { return at<37>().valid(); } - uint64_t frame_number() const { return at<37>().as_uint64(); } - bool has_auto_refresh() const { return at<38>().valid(); } - bool auto_refresh() const { return at<38>().as_bool(); } - bool has_is_trusted_overlay() const { return at<39>().valid(); } - bool is_trusted_overlay() const { return at<39>().as_bool(); } - bool has_buffer_crop() const { return at<40>().valid(); } - ::protozero::ConstBytes buffer_crop() const { return at<40>().as_bytes(); } - bool has_destination_frame() const { return at<41>().valid(); } - ::protozero::ConstBytes destination_frame() const { return at<41>().as_bytes(); } - bool has_drop_input_mode() const { return at<42>().valid(); } - int32_t drop_input_mode() const { return at<42>().as_int32(); } -}; - -class LayerState : public ::protozero::Message { - public: - using Decoder = LayerState_Decoder; - enum : int32_t { - kLayerIdFieldNumber = 1, - kWhatFieldNumber = 2, - kXFieldNumber = 3, - kYFieldNumber = 4, - kZFieldNumber = 5, - kWFieldNumber = 6, - kHFieldNumber = 7, - kLayerStackFieldNumber = 8, - kFlagsFieldNumber = 9, - kMaskFieldNumber = 10, - kMatrixFieldNumber = 11, - kCornerRadiusFieldNumber = 12, - kBackgroundBlurRadiusFieldNumber = 13, - kParentIdFieldNumber = 14, - kRelativeParentIdFieldNumber = 15, - kAlphaFieldNumber = 16, - kColorFieldNumber = 17, - kTransparentRegionFieldNumber = 18, - kTransformFieldNumber = 19, - kTransformToDisplayInverseFieldNumber = 20, - kCropFieldNumber = 21, - kBufferDataFieldNumber = 22, - kApiFieldNumber = 23, - kHasSidebandStreamFieldNumber = 24, - kColorTransformFieldNumber = 25, - kBlurRegionsFieldNumber = 26, - kWindowInfoHandleFieldNumber = 27, - kBgColorAlphaFieldNumber = 28, - kBgColorDataspaceFieldNumber = 29, - kColorSpaceAgnosticFieldNumber = 30, - kShadowRadiusFieldNumber = 31, - kFrameRateSelectionPriorityFieldNumber = 32, - kFrameRateFieldNumber = 33, - kFrameRateCompatibilityFieldNumber = 34, - kChangeFrameRateStrategyFieldNumber = 35, - kFixedTransformHintFieldNumber = 36, - kFrameNumberFieldNumber = 37, - kAutoRefreshFieldNumber = 38, - kIsTrustedOverlayFieldNumber = 39, - kBufferCropFieldNumber = 40, - kDestinationFrameFieldNumber = 41, - kDropInputModeFieldNumber = 42, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerState"; } - - using Matrix22 = ::perfetto::protos::pbzero::LayerState_Matrix22; - using Color3 = ::perfetto::protos::pbzero::LayerState_Color3; - using BufferData = ::perfetto::protos::pbzero::LayerState_BufferData; - using WindowInfo = ::perfetto::protos::pbzero::LayerState_WindowInfo; - - using ChangesLsb = ::perfetto::protos::pbzero::LayerState_ChangesLsb; - static inline const char* ChangesLsb_Name(ChangesLsb value) { - return ::perfetto::protos::pbzero::LayerState_ChangesLsb_Name(value); - } - - using ChangesMsb = ::perfetto::protos::pbzero::LayerState_ChangesMsb; - static inline const char* ChangesMsb_Name(ChangesMsb value) { - return ::perfetto::protos::pbzero::LayerState_ChangesMsb_Name(value); - } - - using Flags = ::perfetto::protos::pbzero::LayerState_Flags; - static inline const char* Flags_Name(Flags value) { - return ::perfetto::protos::pbzero::LayerState_Flags_Name(value); - } - - using DropInputMode = ::perfetto::protos::pbzero::LayerState_DropInputMode; - static inline const char* DropInputMode_Name(DropInputMode value) { - return ::perfetto::protos::pbzero::LayerState_DropInputMode_Name(value); - } - static inline const ChangesLsb eChangesLsbNone = ChangesLsb::eChangesLsbNone; - static inline const ChangesLsb ePositionChanged = ChangesLsb::ePositionChanged; - static inline const ChangesLsb eLayerChanged = ChangesLsb::eLayerChanged; - static inline const ChangesLsb eAlphaChanged = ChangesLsb::eAlphaChanged; - static inline const ChangesLsb eMatrixChanged = ChangesLsb::eMatrixChanged; - static inline const ChangesLsb eTransparentRegionChanged = ChangesLsb::eTransparentRegionChanged; - static inline const ChangesLsb eFlagsChanged = ChangesLsb::eFlagsChanged; - static inline const ChangesLsb eLayerStackChanged = ChangesLsb::eLayerStackChanged; - static inline const ChangesLsb eReleaseBufferListenerChanged = ChangesLsb::eReleaseBufferListenerChanged; - static inline const ChangesLsb eShadowRadiusChanged = ChangesLsb::eShadowRadiusChanged; - static inline const ChangesLsb eBufferCropChanged = ChangesLsb::eBufferCropChanged; - static inline const ChangesLsb eRelativeLayerChanged = ChangesLsb::eRelativeLayerChanged; - static inline const ChangesLsb eReparent = ChangesLsb::eReparent; - static inline const ChangesLsb eColorChanged = ChangesLsb::eColorChanged; - static inline const ChangesLsb eBufferTransformChanged = ChangesLsb::eBufferTransformChanged; - static inline const ChangesLsb eTransformToDisplayInverseChanged = ChangesLsb::eTransformToDisplayInverseChanged; - static inline const ChangesLsb eCropChanged = ChangesLsb::eCropChanged; - static inline const ChangesLsb eBufferChanged = ChangesLsb::eBufferChanged; - static inline const ChangesLsb eAcquireFenceChanged = ChangesLsb::eAcquireFenceChanged; - static inline const ChangesLsb eDataspaceChanged = ChangesLsb::eDataspaceChanged; - static inline const ChangesLsb eHdrMetadataChanged = ChangesLsb::eHdrMetadataChanged; - static inline const ChangesLsb eSurfaceDamageRegionChanged = ChangesLsb::eSurfaceDamageRegionChanged; - static inline const ChangesLsb eApiChanged = ChangesLsb::eApiChanged; - static inline const ChangesLsb eSidebandStreamChanged = ChangesLsb::eSidebandStreamChanged; - static inline const ChangesLsb eColorTransformChanged = ChangesLsb::eColorTransformChanged; - static inline const ChangesLsb eHasListenerCallbacksChanged = ChangesLsb::eHasListenerCallbacksChanged; - static inline const ChangesLsb eInputInfoChanged = ChangesLsb::eInputInfoChanged; - static inline const ChangesLsb eCornerRadiusChanged = ChangesLsb::eCornerRadiusChanged; - static inline const ChangesMsb eChangesMsbNone = ChangesMsb::eChangesMsbNone; - static inline const ChangesMsb eDestinationFrameChanged = ChangesMsb::eDestinationFrameChanged; - static inline const ChangesMsb eCachedBufferChanged = ChangesMsb::eCachedBufferChanged; - static inline const ChangesMsb eBackgroundColorChanged = ChangesMsb::eBackgroundColorChanged; - static inline const ChangesMsb eMetadataChanged = ChangesMsb::eMetadataChanged; - static inline const ChangesMsb eColorSpaceAgnosticChanged = ChangesMsb::eColorSpaceAgnosticChanged; - static inline const ChangesMsb eFrameRateSelectionPriority = ChangesMsb::eFrameRateSelectionPriority; - static inline const ChangesMsb eFrameRateChanged = ChangesMsb::eFrameRateChanged; - static inline const ChangesMsb eBackgroundBlurRadiusChanged = ChangesMsb::eBackgroundBlurRadiusChanged; - static inline const ChangesMsb eProducerDisconnect = ChangesMsb::eProducerDisconnect; - static inline const ChangesMsb eFixedTransformHintChanged = ChangesMsb::eFixedTransformHintChanged; - static inline const ChangesMsb eFrameNumberChanged = ChangesMsb::eFrameNumberChanged; - static inline const ChangesMsb eBlurRegionsChanged = ChangesMsb::eBlurRegionsChanged; - static inline const ChangesMsb eAutoRefreshChanged = ChangesMsb::eAutoRefreshChanged; - static inline const ChangesMsb eStretchChanged = ChangesMsb::eStretchChanged; - static inline const ChangesMsb eTrustedOverlayChanged = ChangesMsb::eTrustedOverlayChanged; - static inline const ChangesMsb eDropInputModeChanged = ChangesMsb::eDropInputModeChanged; - static inline const Flags eFlagsNone = Flags::eFlagsNone; - static inline const Flags eLayerHidden = Flags::eLayerHidden; - static inline const Flags eLayerOpaque = Flags::eLayerOpaque; - static inline const Flags eLayerSkipScreenshot = Flags::eLayerSkipScreenshot; - static inline const Flags eLayerSecure = Flags::eLayerSecure; - static inline const Flags eEnableBackpressure = Flags::eEnableBackpressure; - static inline const Flags eLayerIsDisplayDecoration = Flags::eLayerIsDisplayDecoration; - static inline const DropInputMode NONE = DropInputMode::NONE; - static inline const DropInputMode ALL = DropInputMode::ALL; - static inline const DropInputMode OBSCURED = DropInputMode::OBSCURED; - - using FieldMetadata_LayerId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_LayerId kLayerId{}; - void set_layer_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_What = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerState>; - - static constexpr FieldMetadata_What kWhat{}; - void set_what(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_What::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_X = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_X kX{}; - void set_x(float value) { - static constexpr uint32_t field_id = FieldMetadata_X::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Y = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_Y kY{}; - void set_y(float value) { - static constexpr uint32_t field_id = FieldMetadata_Y::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Z = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState>; - - static constexpr FieldMetadata_Z kZ{}; - void set_z(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Z::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_W = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_W kW{}; - void set_w(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_W::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_H = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_H kH{}; - void set_h(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_H::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerStack = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_LayerStack kLayerStack{}; - void set_layer_stack(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Mask = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_Mask kMask{}; - void set_mask(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Mask::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Matrix = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerState_Matrix22, - LayerState>; - - static constexpr FieldMetadata_Matrix kMatrix{}; - template T* set_matrix() { - return BeginNestedMessage(11); - } - - - using FieldMetadata_CornerRadius = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_CornerRadius kCornerRadius{}; - void set_corner_radius(float value) { - static constexpr uint32_t field_id = FieldMetadata_CornerRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BackgroundBlurRadius = - ::protozero::proto_utils::FieldMetadata< - 13, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_BackgroundBlurRadius kBackgroundBlurRadius{}; - void set_background_blur_radius(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_BackgroundBlurRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ParentId = - ::protozero::proto_utils::FieldMetadata< - 14, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_ParentId kParentId{}; - void set_parent_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_RelativeParentId = - ::protozero::proto_utils::FieldMetadata< - 15, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_RelativeParentId kRelativeParentId{}; - void set_relative_parent_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_RelativeParentId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Alpha = - ::protozero::proto_utils::FieldMetadata< - 16, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_Alpha kAlpha{}; - void set_alpha(float value) { - static constexpr uint32_t field_id = FieldMetadata_Alpha::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Color = - ::protozero::proto_utils::FieldMetadata< - 17, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerState_Color3, - LayerState>; - - static constexpr FieldMetadata_Color kColor{}; - template T* set_color() { - return BeginNestedMessage(17); - } - - - using FieldMetadata_TransparentRegion = - ::protozero::proto_utils::FieldMetadata< - 18, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RegionProto, - LayerState>; - - static constexpr FieldMetadata_TransparentRegion kTransparentRegion{}; - template T* set_transparent_region() { - return BeginNestedMessage(18); - } - - - using FieldMetadata_Transform = - ::protozero::proto_utils::FieldMetadata< - 19, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_Transform kTransform{}; - void set_transform(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Transform::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TransformToDisplayInverse = - ::protozero::proto_utils::FieldMetadata< - 20, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState>; - - static constexpr FieldMetadata_TransformToDisplayInverse kTransformToDisplayInverse{}; - void set_transform_to_display_inverse(bool value) { - static constexpr uint32_t field_id = FieldMetadata_TransformToDisplayInverse::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Crop = - ::protozero::proto_utils::FieldMetadata< - 21, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerState>; - - static constexpr FieldMetadata_Crop kCrop{}; - template T* set_crop() { - return BeginNestedMessage(21); - } - - - using FieldMetadata_BufferData = - ::protozero::proto_utils::FieldMetadata< - 22, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerState_BufferData, - LayerState>; - - static constexpr FieldMetadata_BufferData kBufferData{}; - template T* set_buffer_data() { - return BeginNestedMessage(22); - } - - - using FieldMetadata_Api = - ::protozero::proto_utils::FieldMetadata< - 23, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState>; - - static constexpr FieldMetadata_Api kApi{}; - void set_api(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Api::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_HasSidebandStream = - ::protozero::proto_utils::FieldMetadata< - 24, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState>; - - static constexpr FieldMetadata_HasSidebandStream kHasSidebandStream{}; - void set_has_sideband_stream(bool value) { - static constexpr uint32_t field_id = FieldMetadata_HasSidebandStream::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ColorTransform = - ::protozero::proto_utils::FieldMetadata< - 25, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - ColorTransformProto, - LayerState>; - - static constexpr FieldMetadata_ColorTransform kColorTransform{}; - template T* set_color_transform() { - return BeginNestedMessage(25); - } - - - using FieldMetadata_BlurRegions = - ::protozero::proto_utils::FieldMetadata< - 26, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - BlurRegion, - LayerState>; - - static constexpr FieldMetadata_BlurRegions kBlurRegions{}; - template T* add_blur_regions() { - return BeginNestedMessage(26); - } - - - using FieldMetadata_WindowInfoHandle = - ::protozero::proto_utils::FieldMetadata< - 27, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerState_WindowInfo, - LayerState>; - - static constexpr FieldMetadata_WindowInfoHandle kWindowInfoHandle{}; - template T* set_window_info_handle() { - return BeginNestedMessage(27); - } - - - using FieldMetadata_BgColorAlpha = - ::protozero::proto_utils::FieldMetadata< - 28, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_BgColorAlpha kBgColorAlpha{}; - void set_bg_color_alpha(float value) { - static constexpr uint32_t field_id = FieldMetadata_BgColorAlpha::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BgColorDataspace = - ::protozero::proto_utils::FieldMetadata< - 29, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState>; - - static constexpr FieldMetadata_BgColorDataspace kBgColorDataspace{}; - void set_bg_color_dataspace(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_BgColorDataspace::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ColorSpaceAgnostic = - ::protozero::proto_utils::FieldMetadata< - 30, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState>; - - static constexpr FieldMetadata_ColorSpaceAgnostic kColorSpaceAgnostic{}; - void set_color_space_agnostic(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ColorSpaceAgnostic::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ShadowRadius = - ::protozero::proto_utils::FieldMetadata< - 31, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_ShadowRadius kShadowRadius{}; - void set_shadow_radius(float value) { - static constexpr uint32_t field_id = FieldMetadata_ShadowRadius::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FrameRateSelectionPriority = - ::protozero::proto_utils::FieldMetadata< - 32, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState>; - - static constexpr FieldMetadata_FrameRateSelectionPriority kFrameRateSelectionPriority{}; - void set_frame_rate_selection_priority(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_FrameRateSelectionPriority::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FrameRate = - ::protozero::proto_utils::FieldMetadata< - 33, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState>; - - static constexpr FieldMetadata_FrameRate kFrameRate{}; - void set_frame_rate(float value) { - static constexpr uint32_t field_id = FieldMetadata_FrameRate::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FrameRateCompatibility = - ::protozero::proto_utils::FieldMetadata< - 34, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState>; - - static constexpr FieldMetadata_FrameRateCompatibility kFrameRateCompatibility{}; - void set_frame_rate_compatibility(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_FrameRateCompatibility::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ChangeFrameRateStrategy = - ::protozero::proto_utils::FieldMetadata< - 35, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState>; - - static constexpr FieldMetadata_ChangeFrameRateStrategy kChangeFrameRateStrategy{}; - void set_change_frame_rate_strategy(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ChangeFrameRateStrategy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FixedTransformHint = - ::protozero::proto_utils::FieldMetadata< - 36, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState>; - - static constexpr FieldMetadata_FixedTransformHint kFixedTransformHint{}; - void set_fixed_transform_hint(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_FixedTransformHint::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FrameNumber = - ::protozero::proto_utils::FieldMetadata< - 37, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerState>; - - static constexpr FieldMetadata_FrameNumber kFrameNumber{}; - void set_frame_number(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_AutoRefresh = - ::protozero::proto_utils::FieldMetadata< - 38, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState>; - - static constexpr FieldMetadata_AutoRefresh kAutoRefresh{}; - void set_auto_refresh(bool value) { - static constexpr uint32_t field_id = FieldMetadata_AutoRefresh::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_IsTrustedOverlay = - ::protozero::proto_utils::FieldMetadata< - 39, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState>; - - static constexpr FieldMetadata_IsTrustedOverlay kIsTrustedOverlay{}; - void set_is_trusted_overlay(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsTrustedOverlay::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_BufferCrop = - ::protozero::proto_utils::FieldMetadata< - 40, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerState>; - - static constexpr FieldMetadata_BufferCrop kBufferCrop{}; - template T* set_buffer_crop() { - return BeginNestedMessage(40); - } - - - using FieldMetadata_DestinationFrame = - ::protozero::proto_utils::FieldMetadata< - 41, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerState>; - - static constexpr FieldMetadata_DestinationFrame kDestinationFrame{}; - template T* set_destination_frame() { - return BeginNestedMessage(41); - } - - - using FieldMetadata_DropInputMode = - ::protozero::proto_utils::FieldMetadata< - 42, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - LayerState_DropInputMode, - LayerState>; - - static constexpr FieldMetadata_DropInputMode kDropInputMode{}; - void set_drop_input_mode(LayerState_DropInputMode value) { - static constexpr uint32_t field_id = FieldMetadata_DropInputMode::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } -}; - -class LayerState_WindowInfo_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerState_WindowInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerState_WindowInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerState_WindowInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_layout_params_flags() const { return at<1>().valid(); } - uint32_t layout_params_flags() const { return at<1>().as_uint32(); } - bool has_layout_params_type() const { return at<2>().valid(); } - int32_t layout_params_type() const { return at<2>().as_int32(); } - bool has_touchable_region() const { return at<3>().valid(); } - ::protozero::ConstBytes touchable_region() const { return at<3>().as_bytes(); } - bool has_surface_inset() const { return at<4>().valid(); } - int32_t surface_inset() const { return at<4>().as_int32(); } - bool has_focusable() const { return at<5>().valid(); } - bool focusable() const { return at<5>().as_bool(); } - bool has_has_wallpaper() const { return at<6>().valid(); } - bool has_wallpaper() const { return at<6>().as_bool(); } - bool has_global_scale_factor() const { return at<7>().valid(); } - float global_scale_factor() const { return at<7>().as_float(); } - bool has_crop_layer_id() const { return at<8>().valid(); } - uint32_t crop_layer_id() const { return at<8>().as_uint32(); } - bool has_replace_touchable_region_with_crop() const { return at<9>().valid(); } - bool replace_touchable_region_with_crop() const { return at<9>().as_bool(); } - bool has_touchable_region_crop() const { return at<10>().valid(); } - ::protozero::ConstBytes touchable_region_crop() const { return at<10>().as_bytes(); } - bool has_transform() const { return at<11>().valid(); } - ::protozero::ConstBytes transform() const { return at<11>().as_bytes(); } - bool has_input_config() const { return at<12>().valid(); } - uint32_t input_config() const { return at<12>().as_uint32(); } -}; - -class LayerState_WindowInfo : public ::protozero::Message { - public: - using Decoder = LayerState_WindowInfo_Decoder; - enum : int32_t { - kLayoutParamsFlagsFieldNumber = 1, - kLayoutParamsTypeFieldNumber = 2, - kTouchableRegionFieldNumber = 3, - kSurfaceInsetFieldNumber = 4, - kFocusableFieldNumber = 5, - kHasWallpaperFieldNumber = 6, - kGlobalScaleFactorFieldNumber = 7, - kCropLayerIdFieldNumber = 8, - kReplaceTouchableRegionWithCropFieldNumber = 9, - kTouchableRegionCropFieldNumber = 10, - kTransformFieldNumber = 11, - kInputConfigFieldNumber = 12, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerState.WindowInfo"; } - - - using FieldMetadata_LayoutParamsFlags = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_LayoutParamsFlags kLayoutParamsFlags{}; - void set_layout_params_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayoutParamsFlags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayoutParamsType = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_LayoutParamsType kLayoutParamsType{}; - void set_layout_params_type(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayoutParamsType::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TouchableRegion = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RegionProto, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_TouchableRegion kTouchableRegion{}; - template T* set_touchable_region() { - return BeginNestedMessage(3); - } - - - using FieldMetadata_SurfaceInset = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_SurfaceInset kSurfaceInset{}; - void set_surface_inset(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_SurfaceInset::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Focusable = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_Focusable kFocusable{}; - void set_focusable(bool value) { - static constexpr uint32_t field_id = FieldMetadata_Focusable::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_HasWallpaper = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_HasWallpaper kHasWallpaper{}; - void set_has_wallpaper(bool value) { - static constexpr uint32_t field_id = FieldMetadata_HasWallpaper::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_GlobalScaleFactor = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_GlobalScaleFactor kGlobalScaleFactor{}; - void set_global_scale_factor(float value) { - static constexpr uint32_t field_id = FieldMetadata_GlobalScaleFactor::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CropLayerId = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_CropLayerId kCropLayerId{}; - void set_crop_layer_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_CropLayerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ReplaceTouchableRegionWithCrop = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_ReplaceTouchableRegionWithCrop kReplaceTouchableRegionWithCrop{}; - void set_replace_touchable_region_with_crop(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ReplaceTouchableRegionWithCrop::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TouchableRegionCrop = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - RectProto, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_TouchableRegionCrop kTouchableRegionCrop{}; - template T* set_touchable_region_crop() { - return BeginNestedMessage(10); - } - - - using FieldMetadata_Transform = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - Transform, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_Transform kTransform{}; - template T* set_transform() { - return BeginNestedMessage(11); - } - - - using FieldMetadata_InputConfig = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState_WindowInfo>; - - static constexpr FieldMetadata_InputConfig kInputConfig{}; - void set_input_config(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_InputConfig::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class LayerState_BufferData_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerState_BufferData_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerState_BufferData_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerState_BufferData_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_buffer_id() const { return at<1>().valid(); } - uint64_t buffer_id() const { return at<1>().as_uint64(); } - bool has_width() const { return at<2>().valid(); } - uint32_t width() const { return at<2>().as_uint32(); } - bool has_height() const { return at<3>().valid(); } - uint32_t height() const { return at<3>().as_uint32(); } - bool has_frame_number() const { return at<4>().valid(); } - uint64_t frame_number() const { return at<4>().as_uint64(); } - bool has_flags() const { return at<5>().valid(); } - uint32_t flags() const { return at<5>().as_uint32(); } - bool has_cached_buffer_id() const { return at<6>().valid(); } - uint64_t cached_buffer_id() const { return at<6>().as_uint64(); } - bool has_pixel_format() const { return at<7>().valid(); } - int32_t pixel_format() const { return at<7>().as_int32(); } - bool has_usage() const { return at<8>().valid(); } - uint64_t usage() const { return at<8>().as_uint64(); } -}; - -class LayerState_BufferData : public ::protozero::Message { - public: - using Decoder = LayerState_BufferData_Decoder; - enum : int32_t { - kBufferIdFieldNumber = 1, - kWidthFieldNumber = 2, - kHeightFieldNumber = 3, - kFrameNumberFieldNumber = 4, - kFlagsFieldNumber = 5, - kCachedBufferIdFieldNumber = 6, - kPixelFormatFieldNumber = 7, - kUsageFieldNumber = 8, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerState.BufferData"; } - - - using BufferDataChange = ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange; - static inline const char* BufferDataChange_Name(BufferDataChange value) { - return ::perfetto::protos::pbzero::LayerState_BufferData_BufferDataChange_Name(value); - } - - using PixelFormat = ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat; - static inline const char* PixelFormat_Name(PixelFormat value) { - return ::perfetto::protos::pbzero::LayerState_BufferData_PixelFormat_Name(value); - } - static inline const BufferDataChange BufferDataChangeNone = BufferDataChange::BufferDataChangeNone; - static inline const BufferDataChange fenceChanged = BufferDataChange::fenceChanged; - static inline const BufferDataChange frameNumberChanged = BufferDataChange::frameNumberChanged; - static inline const BufferDataChange cachedBufferChanged = BufferDataChange::cachedBufferChanged; - static inline const PixelFormat PIXEL_FORMAT_UNKNOWN = PixelFormat::PIXEL_FORMAT_UNKNOWN; - static inline const PixelFormat PIXEL_FORMAT_CUSTOM = PixelFormat::PIXEL_FORMAT_CUSTOM; - static inline const PixelFormat PIXEL_FORMAT_TRANSLUCENT = PixelFormat::PIXEL_FORMAT_TRANSLUCENT; - static inline const PixelFormat PIXEL_FORMAT_TRANSPARENT = PixelFormat::PIXEL_FORMAT_TRANSPARENT; - static inline const PixelFormat PIXEL_FORMAT_OPAQUE = PixelFormat::PIXEL_FORMAT_OPAQUE; - static inline const PixelFormat PIXEL_FORMAT_RGBA_8888 = PixelFormat::PIXEL_FORMAT_RGBA_8888; - static inline const PixelFormat PIXEL_FORMAT_RGBX_8888 = PixelFormat::PIXEL_FORMAT_RGBX_8888; - static inline const PixelFormat PIXEL_FORMAT_RGB_888 = PixelFormat::PIXEL_FORMAT_RGB_888; - static inline const PixelFormat PIXEL_FORMAT_RGB_565 = PixelFormat::PIXEL_FORMAT_RGB_565; - static inline const PixelFormat PIXEL_FORMAT_BGRA_8888 = PixelFormat::PIXEL_FORMAT_BGRA_8888; - static inline const PixelFormat PIXEL_FORMAT_RGBA_5551 = PixelFormat::PIXEL_FORMAT_RGBA_5551; - static inline const PixelFormat PIXEL_FORMAT_RGBA_4444 = PixelFormat::PIXEL_FORMAT_RGBA_4444; - static inline const PixelFormat PIXEL_FORMAT_RGBA_FP16 = PixelFormat::PIXEL_FORMAT_RGBA_FP16; - static inline const PixelFormat PIXEL_FORMAT_RGBA_1010102 = PixelFormat::PIXEL_FORMAT_RGBA_1010102; - static inline const PixelFormat PIXEL_FORMAT_R_8 = PixelFormat::PIXEL_FORMAT_R_8; - - using FieldMetadata_BufferId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_BufferId kBufferId{}; - void set_buffer_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_BufferId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Width = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_Width kWidth{}; - void set_width(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Width::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Height = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_Height kHeight{}; - void set_height(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Height::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_FrameNumber = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_FrameNumber kFrameNumber{}; - void set_frame_number(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_FrameNumber::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_CachedBufferId = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_CachedBufferId kCachedBufferId{}; - void set_cached_buffer_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_CachedBufferId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PixelFormat = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kEnum, - LayerState_BufferData_PixelFormat, - LayerState_BufferData>; - - static constexpr FieldMetadata_PixelFormat kPixelFormat{}; - void set_pixel_format(LayerState_BufferData_PixelFormat value) { - static constexpr uint32_t field_id = FieldMetadata_PixelFormat::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kEnum> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Usage = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - LayerState_BufferData>; - - static constexpr FieldMetadata_Usage kUsage{}; - void set_usage(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_Usage::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } -}; - -class LayerState_Color3_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerState_Color3_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerState_Color3_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerState_Color3_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_r() const { return at<1>().valid(); } - float r() const { return at<1>().as_float(); } - bool has_g() const { return at<2>().valid(); } - float g() const { return at<2>().as_float(); } - bool has_b() const { return at<3>().valid(); } - float b() const { return at<3>().as_float(); } -}; - -class LayerState_Color3 : public ::protozero::Message { - public: - using Decoder = LayerState_Color3_Decoder; - enum : int32_t { - kRFieldNumber = 1, - kGFieldNumber = 2, - kBFieldNumber = 3, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Color3"; } - - - using FieldMetadata_R = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Color3>; - - static constexpr FieldMetadata_R kR{}; - void set_r(float value) { - static constexpr uint32_t field_id = FieldMetadata_R::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_G = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Color3>; - - static constexpr FieldMetadata_G kG{}; - void set_g(float value) { - static constexpr uint32_t field_id = FieldMetadata_G::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_B = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Color3>; - - static constexpr FieldMetadata_B kB{}; - void set_b(float value) { - static constexpr uint32_t field_id = FieldMetadata_B::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class LayerState_Matrix22_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerState_Matrix22_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerState_Matrix22_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerState_Matrix22_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_dsdx() const { return at<1>().valid(); } - float dsdx() const { return at<1>().as_float(); } - bool has_dtdx() const { return at<2>().valid(); } - float dtdx() const { return at<2>().as_float(); } - bool has_dtdy() const { return at<3>().valid(); } - float dtdy() const { return at<3>().as_float(); } - bool has_dsdy() const { return at<4>().valid(); } - float dsdy() const { return at<4>().as_float(); } -}; - -class LayerState_Matrix22 : public ::protozero::Message { - public: - using Decoder = LayerState_Matrix22_Decoder; - enum : int32_t { - kDsdxFieldNumber = 1, - kDtdxFieldNumber = 2, - kDtdyFieldNumber = 3, - kDsdyFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerState.Matrix22"; } - - - using FieldMetadata_Dsdx = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Matrix22>; - - static constexpr FieldMetadata_Dsdx kDsdx{}; - void set_dsdx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dtdx = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Matrix22>; - - static constexpr FieldMetadata_Dtdx kDtdx{}; - void set_dtdx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dtdy = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Matrix22>; - - static constexpr FieldMetadata_Dtdy kDtdy{}; - void set_dtdy(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dsdy = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - LayerState_Matrix22>; - - static constexpr FieldMetadata_Dsdy kDsdy{}; - void set_dsdy(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class TransactionState_Decoder : public ::protozero::TypedProtoDecoder { - public: - TransactionState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TransactionState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TransactionState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_pid() const { return at<1>().valid(); } - int32_t pid() const { return at<1>().as_int32(); } - bool has_uid() const { return at<2>().valid(); } - int32_t uid() const { return at<2>().as_int32(); } - bool has_vsync_id() const { return at<3>().valid(); } - int64_t vsync_id() const { return at<3>().as_int64(); } - bool has_input_event_id() const { return at<4>().valid(); } - int32_t input_event_id() const { return at<4>().as_int32(); } - bool has_post_time() const { return at<5>().valid(); } - int64_t post_time() const { return at<5>().as_int64(); } - bool has_transaction_id() const { return at<6>().valid(); } - uint64_t transaction_id() const { return at<6>().as_uint64(); } - bool has_layer_changes() const { return at<7>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> layer_changes() const { return GetRepeated<::protozero::ConstBytes>(7); } - bool has_display_changes() const { return at<8>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> display_changes() const { return GetRepeated<::protozero::ConstBytes>(8); } - bool has_merged_transaction_ids() const { return at<9>().valid(); } - ::protozero::RepeatedFieldIterator merged_transaction_ids() const { return GetRepeated(9); } -}; - -class TransactionState : public ::protozero::Message { - public: - using Decoder = TransactionState_Decoder; - enum : int32_t { - kPidFieldNumber = 1, - kUidFieldNumber = 2, - kVsyncIdFieldNumber = 3, - kInputEventIdFieldNumber = 4, - kPostTimeFieldNumber = 5, - kTransactionIdFieldNumber = 6, - kLayerChangesFieldNumber = 7, - kDisplayChangesFieldNumber = 8, - kMergedTransactionIdsFieldNumber = 9, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TransactionState"; } - - - using FieldMetadata_Pid = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TransactionState>; - - static constexpr FieldMetadata_Pid kPid{}; - void set_pid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Pid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Uid = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TransactionState>; - - static constexpr FieldMetadata_Uid kUid{}; - void set_uid(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Uid::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_VsyncId = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TransactionState>; - - static constexpr FieldMetadata_VsyncId kVsyncId{}; - void set_vsync_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_InputEventId = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TransactionState>; - - static constexpr FieldMetadata_InputEventId kInputEventId{}; - void set_input_event_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_InputEventId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_PostTime = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TransactionState>; - - static constexpr FieldMetadata_PostTime kPostTime{}; - void set_post_time(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_PostTime::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TransactionId = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TransactionState>; - - static constexpr FieldMetadata_TransactionId kTransactionId{}; - void set_transaction_id(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_TransactionId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerChanges = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerState, - TransactionState>; - - static constexpr FieldMetadata_LayerChanges kLayerChanges{}; - template T* add_layer_changes() { - return BeginNestedMessage(7); - } - - - using FieldMetadata_DisplayChanges = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - DisplayState, - TransactionState>; - - static constexpr FieldMetadata_DisplayChanges kDisplayChanges{}; - template T* add_display_changes() { - return BeginNestedMessage(8); - } - - - using FieldMetadata_MergedTransactionIds = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kUint64, - uint64_t, - TransactionState>; - - static constexpr FieldMetadata_MergedTransactionIds kMergedTransactionIds{}; - void add_merged_transaction_ids(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MergedTransactionIds::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint64> - ::Append(*this, field_id, value); - } -}; - -class Transform_Decoder : public ::protozero::TypedProtoDecoder { - public: - Transform_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit Transform_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit Transform_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_dsdx() const { return at<1>().valid(); } - float dsdx() const { return at<1>().as_float(); } - bool has_dtdx() const { return at<2>().valid(); } - float dtdx() const { return at<2>().as_float(); } - bool has_dtdy() const { return at<3>().valid(); } - float dtdy() const { return at<3>().as_float(); } - bool has_dsdy() const { return at<4>().valid(); } - float dsdy() const { return at<4>().as_float(); } - bool has_tx() const { return at<5>().valid(); } - float tx() const { return at<5>().as_float(); } - bool has_ty() const { return at<6>().valid(); } - float ty() const { return at<6>().as_float(); } -}; - -class Transform : public ::protozero::Message { - public: - using Decoder = Transform_Decoder; - enum : int32_t { - kDsdxFieldNumber = 1, - kDtdxFieldNumber = 2, - kDtdyFieldNumber = 3, - kDsdyFieldNumber = 4, - kTxFieldNumber = 5, - kTyFieldNumber = 6, - }; - static constexpr const char* GetName() { return ".perfetto.protos.Transform"; } - - - using FieldMetadata_Dsdx = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - Transform>; - - static constexpr FieldMetadata_Dsdx kDsdx{}; - void set_dsdx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dsdx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dtdx = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - Transform>; - - static constexpr FieldMetadata_Dtdx kDtdx{}; - void set_dtdx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dtdx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dtdy = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - Transform>; - - static constexpr FieldMetadata_Dtdy kDtdy{}; - void set_dtdy(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dtdy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Dsdy = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - Transform>; - - static constexpr FieldMetadata_Dsdy kDsdy{}; - void set_dsdy(float value) { - static constexpr uint32_t field_id = FieldMetadata_Dsdy::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Tx = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - Transform>; - - static constexpr FieldMetadata_Tx kTx{}; - void set_tx(float value) { - static constexpr uint32_t field_id = FieldMetadata_Tx::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Ty = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFloat, - float, - Transform>; - - static constexpr FieldMetadata_Ty kTy{}; - void set_ty(float value) { - static constexpr uint32_t field_id = FieldMetadata_Ty::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFloat> - ::Append(*this, field_id, value); - } -}; - -class LayerCreationArgs_Decoder : public ::protozero::TypedProtoDecoder { - public: - LayerCreationArgs_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit LayerCreationArgs_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit LayerCreationArgs_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_layer_id() const { return at<1>().valid(); } - uint32_t layer_id() const { return at<1>().as_uint32(); } - bool has_name() const { return at<2>().valid(); } - ::protozero::ConstChars name() const { return at<2>().as_string(); } - bool has_flags() const { return at<3>().valid(); } - uint32_t flags() const { return at<3>().as_uint32(); } - bool has_parent_id() const { return at<4>().valid(); } - uint32_t parent_id() const { return at<4>().as_uint32(); } - bool has_mirror_from_id() const { return at<5>().valid(); } - uint32_t mirror_from_id() const { return at<5>().as_uint32(); } - bool has_add_to_root() const { return at<6>().valid(); } - bool add_to_root() const { return at<6>().as_bool(); } - bool has_layer_stack_to_mirror() const { return at<7>().valid(); } - uint32_t layer_stack_to_mirror() const { return at<7>().as_uint32(); } -}; - -class LayerCreationArgs : public ::protozero::Message { - public: - using Decoder = LayerCreationArgs_Decoder; - enum : int32_t { - kLayerIdFieldNumber = 1, - kNameFieldNumber = 2, - kFlagsFieldNumber = 3, - kParentIdFieldNumber = 4, - kMirrorFromIdFieldNumber = 5, - kAddToRootFieldNumber = 6, - kLayerStackToMirrorFieldNumber = 7, - }; - static constexpr const char* GetName() { return ".perfetto.protos.LayerCreationArgs"; } - - - using FieldMetadata_LayerId = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerCreationArgs>; - - static constexpr FieldMetadata_LayerId kLayerId{}; - void set_layer_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Name = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kString, - std::string, - LayerCreationArgs>; - - static constexpr FieldMetadata_Name kName{}; - void set_name(const char* data, size_t size) { - AppendBytes(FieldMetadata_Name::kFieldId, data, size); - } - void set_name(::protozero::ConstChars chars) { - AppendBytes(FieldMetadata_Name::kFieldId, chars.data, chars.size); - } - void set_name(std::string value) { - static constexpr uint32_t field_id = FieldMetadata_Name::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kString> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Flags = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerCreationArgs>; - - static constexpr FieldMetadata_Flags kFlags{}; - void set_flags(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Flags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_ParentId = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerCreationArgs>; - - static constexpr FieldMetadata_ParentId kParentId{}; - void set_parent_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_ParentId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_MirrorFromId = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerCreationArgs>; - - static constexpr FieldMetadata_MirrorFromId kMirrorFromId{}; - void set_mirror_from_id(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_MirrorFromId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_AddToRoot = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - LayerCreationArgs>; - - static constexpr FieldMetadata_AddToRoot kAddToRoot{}; - void set_add_to_root(bool value) { - static constexpr uint32_t field_id = FieldMetadata_AddToRoot::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LayerStackToMirror = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - LayerCreationArgs>; - - static constexpr FieldMetadata_LayerStackToMirror kLayerStackToMirror{}; - void set_layer_stack_to_mirror(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerStackToMirror::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } -}; - -class DisplayInfo_Decoder : public ::protozero::TypedProtoDecoder { - public: - DisplayInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit DisplayInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit DisplayInfo_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_layer_stack() const { return at<1>().valid(); } - uint32_t layer_stack() const { return at<1>().as_uint32(); } - bool has_display_id() const { return at<2>().valid(); } - int32_t display_id() const { return at<2>().as_int32(); } - bool has_logical_width() const { return at<3>().valid(); } - int32_t logical_width() const { return at<3>().as_int32(); } - bool has_logical_height() const { return at<4>().valid(); } - int32_t logical_height() const { return at<4>().as_int32(); } - bool has_transform_inverse() const { return at<5>().valid(); } - ::protozero::ConstBytes transform_inverse() const { return at<5>().as_bytes(); } - bool has_transform() const { return at<6>().valid(); } - ::protozero::ConstBytes transform() const { return at<6>().as_bytes(); } - bool has_receives_input() const { return at<7>().valid(); } - bool receives_input() const { return at<7>().as_bool(); } - bool has_is_secure() const { return at<8>().valid(); } - bool is_secure() const { return at<8>().as_bool(); } - bool has_is_primary() const { return at<9>().valid(); } - bool is_primary() const { return at<9>().as_bool(); } - bool has_is_virtual() const { return at<10>().valid(); } - bool is_virtual() const { return at<10>().as_bool(); } - bool has_rotation_flags() const { return at<11>().valid(); } - int32_t rotation_flags() const { return at<11>().as_int32(); } - bool has_transform_hint() const { return at<12>().valid(); } - int32_t transform_hint() const { return at<12>().as_int32(); } -}; - -class DisplayInfo : public ::protozero::Message { - public: - using Decoder = DisplayInfo_Decoder; - enum : int32_t { - kLayerStackFieldNumber = 1, - kDisplayIdFieldNumber = 2, - kLogicalWidthFieldNumber = 3, - kLogicalHeightFieldNumber = 4, - kTransformInverseFieldNumber = 5, - kTransformFieldNumber = 6, - kReceivesInputFieldNumber = 7, - kIsSecureFieldNumber = 8, - kIsPrimaryFieldNumber = 9, - kIsVirtualFieldNumber = 10, - kRotationFlagsFieldNumber = 11, - kTransformHintFieldNumber = 12, - }; - static constexpr const char* GetName() { return ".perfetto.protos.DisplayInfo"; } - - - using FieldMetadata_LayerStack = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - DisplayInfo>; - - static constexpr FieldMetadata_LayerStack kLayerStack{}; - void set_layer_stack(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LayerStack::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisplayId = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - DisplayInfo>; - - static constexpr FieldMetadata_DisplayId kDisplayId{}; - void set_display_id(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DisplayId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LogicalWidth = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - DisplayInfo>; - - static constexpr FieldMetadata_LogicalWidth kLogicalWidth{}; - void set_logical_width(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LogicalWidth::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_LogicalHeight = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - DisplayInfo>; - - static constexpr FieldMetadata_LogicalHeight kLogicalHeight{}; - void set_logical_height(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_LogicalHeight::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TransformInverse = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - Transform, - DisplayInfo>; - - static constexpr FieldMetadata_TransformInverse kTransformInverse{}; - template T* set_transform_inverse() { - return BeginNestedMessage(5); - } - - - using FieldMetadata_Transform = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - Transform, - DisplayInfo>; - - static constexpr FieldMetadata_Transform kTransform{}; - template T* set_transform() { - return BeginNestedMessage(6); - } - - - using FieldMetadata_ReceivesInput = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - DisplayInfo>; - - static constexpr FieldMetadata_ReceivesInput kReceivesInput{}; - void set_receives_input(bool value) { - static constexpr uint32_t field_id = FieldMetadata_ReceivesInput::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_IsSecure = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - DisplayInfo>; - - static constexpr FieldMetadata_IsSecure kIsSecure{}; - void set_is_secure(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsSecure::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_IsPrimary = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - DisplayInfo>; - - static constexpr FieldMetadata_IsPrimary kIsPrimary{}; - void set_is_primary(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsPrimary::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_IsVirtual = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - DisplayInfo>; - - static constexpr FieldMetadata_IsVirtual kIsVirtual{}; - void set_is_virtual(bool value) { - static constexpr uint32_t field_id = FieldMetadata_IsVirtual::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_RotationFlags = - ::protozero::proto_utils::FieldMetadata< - 11, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - DisplayInfo>; - - static constexpr FieldMetadata_RotationFlags kRotationFlags{}; - void set_rotation_flags(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_RotationFlags::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_TransformHint = - ::protozero::proto_utils::FieldMetadata< - 12, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - DisplayInfo>; - - static constexpr FieldMetadata_TransformHint kTransformHint{}; - void set_transform_hint(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_TransformHint::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } -}; - -class TransactionTraceEntry_Decoder : public ::protozero::TypedProtoDecoder { - public: - TransactionTraceEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TransactionTraceEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TransactionTraceEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_elapsed_realtime_nanos() const { return at<1>().valid(); } - int64_t elapsed_realtime_nanos() const { return at<1>().as_int64(); } - bool has_vsync_id() const { return at<2>().valid(); } - int64_t vsync_id() const { return at<2>().as_int64(); } - bool has_transactions() const { return at<3>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> transactions() const { return GetRepeated<::protozero::ConstBytes>(3); } - bool has_added_layers() const { return at<4>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_layers() const { return GetRepeated<::protozero::ConstBytes>(4); } - bool has_destroyed_layers() const { return at<5>().valid(); } - ::protozero::RepeatedFieldIterator destroyed_layers() const { return GetRepeated(5); } - bool has_added_displays() const { return at<6>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> added_displays() const { return GetRepeated<::protozero::ConstBytes>(6); } - bool has_removed_displays() const { return at<7>().valid(); } - ::protozero::RepeatedFieldIterator removed_displays() const { return GetRepeated(7); } - bool has_destroyed_layer_handles() const { return at<8>().valid(); } - ::protozero::RepeatedFieldIterator destroyed_layer_handles() const { return GetRepeated(8); } - bool has_displays_changed() const { return at<9>().valid(); } - bool displays_changed() const { return at<9>().as_bool(); } - bool has_displays() const { return at<10>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> displays() const { return GetRepeated<::protozero::ConstBytes>(10); } -}; - -class TransactionTraceEntry : public ::protozero::Message { - public: - using Decoder = TransactionTraceEntry_Decoder; - enum : int32_t { - kElapsedRealtimeNanosFieldNumber = 1, - kVsyncIdFieldNumber = 2, - kTransactionsFieldNumber = 3, - kAddedLayersFieldNumber = 4, - kDestroyedLayersFieldNumber = 5, - kAddedDisplaysFieldNumber = 6, - kRemovedDisplaysFieldNumber = 7, - kDestroyedLayerHandlesFieldNumber = 8, - kDisplaysChangedFieldNumber = 9, - kDisplaysFieldNumber = 10, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceEntry"; } - - - using FieldMetadata_ElapsedRealtimeNanos = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TransactionTraceEntry>; - - static constexpr FieldMetadata_ElapsedRealtimeNanos kElapsedRealtimeNanos{}; - void set_elapsed_realtime_nanos(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_ElapsedRealtimeNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_VsyncId = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kInt64, - int64_t, - TransactionTraceEntry>; - - static constexpr FieldMetadata_VsyncId kVsyncId{}; - void set_vsync_id(int64_t value) { - static constexpr uint32_t field_id = FieldMetadata_VsyncId::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Transactions = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransactionState, - TransactionTraceEntry>; - - static constexpr FieldMetadata_Transactions kTransactions{}; - template T* add_transactions() { - return BeginNestedMessage(3); - } - - - using FieldMetadata_AddedLayers = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - LayerCreationArgs, - TransactionTraceEntry>; - - static constexpr FieldMetadata_AddedLayers kAddedLayers{}; - template T* add_added_layers() { - return BeginNestedMessage(4); - } - - - using FieldMetadata_DestroyedLayers = - ::protozero::proto_utils::FieldMetadata< - 5, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TransactionTraceEntry>; - - static constexpr FieldMetadata_DestroyedLayers kDestroyedLayers{}; - void add_destroyed_layers(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DestroyedLayers::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_AddedDisplays = - ::protozero::proto_utils::FieldMetadata< - 6, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - DisplayState, - TransactionTraceEntry>; - - static constexpr FieldMetadata_AddedDisplays kAddedDisplays{}; - template T* add_added_displays() { - return BeginNestedMessage(6); - } - - - using FieldMetadata_RemovedDisplays = - ::protozero::proto_utils::FieldMetadata< - 7, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kInt32, - int32_t, - TransactionTraceEntry>; - - static constexpr FieldMetadata_RemovedDisplays kRemovedDisplays{}; - void add_removed_displays(int32_t value) { - static constexpr uint32_t field_id = FieldMetadata_RemovedDisplays::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kInt32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DestroyedLayerHandles = - ::protozero::proto_utils::FieldMetadata< - 8, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TransactionTraceEntry>; - - static constexpr FieldMetadata_DestroyedLayerHandles kDestroyedLayerHandles{}; - void add_destroyed_layer_handles(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_DestroyedLayerHandles::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } - - using FieldMetadata_DisplaysChanged = - ::protozero::proto_utils::FieldMetadata< - 9, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kBool, - bool, - TransactionTraceEntry>; - - static constexpr FieldMetadata_DisplaysChanged kDisplaysChanged{}; - void set_displays_changed(bool value) { - static constexpr uint32_t field_id = FieldMetadata_DisplaysChanged::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kBool> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Displays = - ::protozero::proto_utils::FieldMetadata< - 10, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - DisplayInfo, - TransactionTraceEntry>; - - static constexpr FieldMetadata_Displays kDisplays{}; - template T* add_displays() { - return BeginNestedMessage(10); - } - -}; - -class TransactionTraceFile_Decoder : public ::protozero::TypedProtoDecoder { - public: - TransactionTraceFile_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} - explicit TransactionTraceFile_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} - explicit TransactionTraceFile_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} - bool has_magic_number() const { return at<1>().valid(); } - uint64_t magic_number() const { return at<1>().as_uint64(); } - bool has_entry() const { return at<2>().valid(); } - ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> entry() const { return GetRepeated<::protozero::ConstBytes>(2); } - bool has_real_to_elapsed_time_offset_nanos() const { return at<3>().valid(); } - uint64_t real_to_elapsed_time_offset_nanos() const { return at<3>().as_uint64(); } - bool has_version() const { return at<4>().valid(); } - uint32_t version() const { return at<4>().as_uint32(); } -}; - -class TransactionTraceFile : public ::protozero::Message { - public: - using Decoder = TransactionTraceFile_Decoder; - enum : int32_t { - kMagicNumberFieldNumber = 1, - kEntryFieldNumber = 2, - kRealToElapsedTimeOffsetNanosFieldNumber = 3, - kVersionFieldNumber = 4, - }; - static constexpr const char* GetName() { return ".perfetto.protos.TransactionTraceFile"; } - - - using MagicNumber = ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber; - static inline const char* MagicNumber_Name(MagicNumber value) { - return ::perfetto::protos::pbzero::TransactionTraceFile_MagicNumber_Name(value); - } - static inline const MagicNumber INVALID = MagicNumber::INVALID; - static inline const MagicNumber MAGIC_NUMBER_L = MagicNumber::MAGIC_NUMBER_L; - static inline const MagicNumber MAGIC_NUMBER_H = MagicNumber::MAGIC_NUMBER_H; - - using FieldMetadata_MagicNumber = - ::protozero::proto_utils::FieldMetadata< - 1, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed64, - uint64_t, - TransactionTraceFile>; - - static constexpr FieldMetadata_MagicNumber kMagicNumber{}; - void set_magic_number(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_MagicNumber::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Entry = - ::protozero::proto_utils::FieldMetadata< - 2, - ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, - ::protozero::proto_utils::ProtoSchemaType::kMessage, - TransactionTraceEntry, - TransactionTraceFile>; - - static constexpr FieldMetadata_Entry kEntry{}; - template T* add_entry() { - return BeginNestedMessage(2); - } - - - using FieldMetadata_RealToElapsedTimeOffsetNanos = - ::protozero::proto_utils::FieldMetadata< - 3, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kFixed64, - uint64_t, - TransactionTraceFile>; - - static constexpr FieldMetadata_RealToElapsedTimeOffsetNanos kRealToElapsedTimeOffsetNanos{}; - void set_real_to_elapsed_time_offset_nanos(uint64_t value) { - static constexpr uint32_t field_id = FieldMetadata_RealToElapsedTimeOffsetNanos::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kFixed64> - ::Append(*this, field_id, value); - } - - using FieldMetadata_Version = - ::protozero::proto_utils::FieldMetadata< - 4, - ::protozero::proto_utils::RepetitionType::kNotRepeated, - ::protozero::proto_utils::ProtoSchemaType::kUint32, - uint32_t, - TransactionTraceFile>; - - static constexpr FieldMetadata_Version kVersion{}; - void set_version(uint32_t value) { - static constexpr uint32_t field_id = FieldMetadata_Version::kFieldId; - // Call the appropriate protozero::Message::Append(field_id, ...) - // method based on the type of the field. - ::protozero::internal::FieldWriter< - ::protozero::proto_utils::ProtoSchemaType::kUint32> - ::Append(*this, field_id, value); - } }; } // Namespace. @@ -68353,6 +68157,94 @@ class ChromeTracedValue : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/chrome/chrome_trigger.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRIGGER_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_CHROME_CHROME_TRIGGER_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class ChromeTrigger_Decoder : public ::protozero::TypedProtoDecoder { + public: + ChromeTrigger_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ChromeTrigger_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ChromeTrigger_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_trigger_name() const { return at<1>().valid(); } + ::protozero::ConstChars trigger_name() const { return at<1>().as_string(); } + bool has_trigger_name_hash() const { return at<2>().valid(); } + uint32_t trigger_name_hash() const { return at<2>().as_uint32(); } +}; + +class ChromeTrigger : public ::protozero::Message { + public: + using Decoder = ChromeTrigger_Decoder; + enum : int32_t { + kTriggerNameFieldNumber = 1, + kTriggerNameHashFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ChromeTrigger"; } + + + using FieldMetadata_TriggerName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ChromeTrigger>; + + static constexpr FieldMetadata_TriggerName kTriggerName{}; + void set_trigger_name(const char* data, size_t size) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, data, size); + } + void set_trigger_name(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_TriggerName::kFieldId, chars.data, chars.size); + } + void set_trigger_name(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerName::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_TriggerNameHash = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kFixed32, + uint32_t, + ChromeTrigger>; + + static constexpr FieldMetadata_TriggerNameHash kTriggerNameHash{}; + void set_trigger_name_hash(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TriggerNameHash::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kFixed32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -71843,6 +71735,9 @@ class CpuhpLatencyFtraceEvent; class CpuhpMultiEnterFtraceEvent; class CpuhpPauseFtraceEvent; class CrosEcSensorhubDataFtraceEvent; +class DcvshFreqFtraceEvent; +class DevicePmCallbackEndFtraceEvent; +class DevicePmCallbackStartFtraceEvent; class DmaAllocContiguousRetryFtraceEvent; class DmaFenceEmitFtraceEvent; class DmaFenceInitFtraceEvent; @@ -71993,7 +71888,11 @@ class F2fsVmPageMkwriteFtraceEvent; class F2fsWriteBeginFtraceEvent; class F2fsWriteCheckpointFtraceEvent; class F2fsWriteEndFtraceEvent; +class FastrpcDmaAllocFtraceEvent; +class FastrpcDmaFreeFtraceEvent; +class FastrpcDmaMapFtraceEvent; class FastrpcDmaStatFtraceEvent; +class FastrpcDmaUnmapFtraceEvent; class FenceDestroyFtraceEvent; class FenceEnableSignalFtraceEvent; class FenceInitFtraceEvent; @@ -72002,6 +71901,8 @@ class FuncgraphEntryFtraceEvent; class FuncgraphExitFtraceEvent; class G2dTracingMarkWriteFtraceEvent; class GenericFtraceEvent; +class GoogleIccEventFtraceEvent; +class GoogleIrmEventFtraceEvent; class GpuFrequencyFtraceEvent; class GpuMemTotalFtraceEvent; class GpuWorkPeriodFtraceEvent; @@ -72044,6 +71945,7 @@ class IrqHandlerEntryFtraceEvent; class IrqHandlerExitFtraceEvent; class KfreeFtraceEvent; class KfreeSkbFtraceEvent; +class KgslGpuFrequencyFtraceEvent; class KmallocFtraceEvent; class KmallocNodeFtraceEvent; class KmemCacheAllocFtraceEvent; @@ -72093,6 +71995,29 @@ class MaliMaliKCPUCQSWAITSTARTFtraceEvent; class MaliMaliKCPUFENCESIGNALFtraceEvent; class MaliMaliKCPUFENCEWAITENDFtraceEvent; class MaliMaliKCPUFENCEWAITSTARTFtraceEvent; +class MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent; +class MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent; +class MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent; +class MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent; +class MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent; +class MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent; +class MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent; +class MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent; +class MaliMaliPMMCUINSLEEPFtraceEvent; +class MaliMaliPMMCUOFFFtraceEvent; +class MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent; +class MaliMaliPMMCUONFtraceEvent; +class MaliMaliPMMCUONGLBREINITPENDFtraceEvent; +class MaliMaliPMMCUONHALTFtraceEvent; +class MaliMaliPMMCUONHWCNTDISABLEFtraceEvent; +class MaliMaliPMMCUONHWCNTENABLEFtraceEvent; +class MaliMaliPMMCUONPENDHALTFtraceEvent; +class MaliMaliPMMCUONPENDSLEEPFtraceEvent; +class MaliMaliPMMCUONSLEEPINITIATEFtraceEvent; +class MaliMaliPMMCUPENDOFFFtraceEvent; +class MaliMaliPMMCUPENDONRELOADFtraceEvent; +class MaliMaliPMMCUPOWERDOWNFtraceEvent; +class MaliMaliPMMCURESETWAITFtraceEvent; class MaliTracingMarkWriteFtraceEvent; class MarkVictimFtraceEvent; class MdpCmdKickoffFtraceEvent; @@ -72208,6 +72133,8 @@ class SysExitFtraceEvent; class TaskNewtaskFtraceEvent; class TaskRenameFtraceEvent; class TcpRetransmitSkbFtraceEvent; +class ThermalExynosAcpmBulkFtraceEvent; +class ThermalExynosAcpmHighOverheadFtraceEvent; class ThermalTemperatureFtraceEvent; class TracingMarkWriteFtraceEvent; class TrapRegFtraceEvent; @@ -72259,7 +72186,7 @@ namespace perfetto { namespace protos { namespace pbzero { -class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { +class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -73222,6 +73149,76 @@ class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_f2fs_gc_end() const { return at<497>().valid(); } ::protozero::ConstBytes f2fs_gc_end() const { return at<497>().as_bytes(); } + bool has_fastrpc_dma_free() const { return at<498>().valid(); } + ::protozero::ConstBytes fastrpc_dma_free() const { return at<498>().as_bytes(); } + bool has_fastrpc_dma_alloc() const { return at<499>().valid(); } + ::protozero::ConstBytes fastrpc_dma_alloc() const { return at<499>().as_bytes(); } + bool has_fastrpc_dma_unmap() const { return at<500>().valid(); } + ::protozero::ConstBytes fastrpc_dma_unmap() const { return at<500>().as_bytes(); } + bool has_fastrpc_dma_map() const { return at<501>().valid(); } + ::protozero::ConstBytes fastrpc_dma_map() const { return at<501>().as_bytes(); } + bool has_google_icc_event() const { return at<502>().valid(); } + ::protozero::ConstBytes google_icc_event() const { return at<502>().as_bytes(); } + bool has_google_irm_event() const { return at<503>().valid(); } + ::protozero::ConstBytes google_irm_event() const { return at<503>().as_bytes(); } + bool has_device_pm_callback_start() const { return at<504>().valid(); } + ::protozero::ConstBytes device_pm_callback_start() const { return at<504>().as_bytes(); } + bool has_device_pm_callback_end() const { return at<505>().valid(); } + ::protozero::ConstBytes device_pm_callback_end() const { return at<505>().as_bytes(); } + bool has_thermal_exynos_acpm_bulk() const { return at<506>().valid(); } + ::protozero::ConstBytes thermal_exynos_acpm_bulk() const { return at<506>().as_bytes(); } + bool has_thermal_exynos_acpm_high_overhead() const { return at<507>().valid(); } + ::protozero::ConstBytes thermal_exynos_acpm_high_overhead() const { return at<507>().as_bytes(); } + bool has_dcvsh_freq() const { return at<508>().valid(); } + ::protozero::ConstBytes dcvsh_freq() const { return at<508>().as_bytes(); } + bool has_kgsl_gpu_frequency() const { return at<509>().valid(); } + ::protozero::ConstBytes kgsl_gpu_frequency() const { return at<509>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_cores_down_scale_notify_pend() const { return at<510>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_cores_down_scale_notify_pend() const { return at<510>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_cores_notify_pend() const { return at<511>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_cores_notify_pend() const { return at<511>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_core_inactive_pend() const { return at<512>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_core_inactive_pend() const { return at<512>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_mcu_on_recheck() const { return at<513>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_mcu_on_recheck() const { return at<513>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_shaders_core_off_pend() const { return at<514>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_core_off_pend() const { return at<514>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_shaders_pend_off() const { return at<515>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_pend_off() const { return at<515>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_shaders_pend_on() const { return at<516>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_pend_on() const { return at<516>().as_bytes(); } + bool has_mali_mali_pm_mcu_hctl_shaders_ready_off() const { return at<517>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_hctl_shaders_ready_off() const { return at<517>().as_bytes(); } + bool has_mali_mali_pm_mcu_in_sleep() const { return at<518>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_in_sleep() const { return at<518>().as_bytes(); } + bool has_mali_mali_pm_mcu_off() const { return at<519>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_off() const { return at<519>().as_bytes(); } + bool has_mali_mali_pm_mcu_on() const { return at<520>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on() const { return at<520>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_core_attr_update_pend() const { return at<521>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_core_attr_update_pend() const { return at<521>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_glb_reinit_pend() const { return at<522>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_glb_reinit_pend() const { return at<522>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_halt() const { return at<523>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_halt() const { return at<523>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_hwcnt_disable() const { return at<524>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_hwcnt_disable() const { return at<524>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_hwcnt_enable() const { return at<525>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_hwcnt_enable() const { return at<525>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_pend_halt() const { return at<526>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_pend_halt() const { return at<526>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_pend_sleep() const { return at<527>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_pend_sleep() const { return at<527>().as_bytes(); } + bool has_mali_mali_pm_mcu_on_sleep_initiate() const { return at<528>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_on_sleep_initiate() const { return at<528>().as_bytes(); } + bool has_mali_mali_pm_mcu_pend_off() const { return at<529>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_pend_off() const { return at<529>().as_bytes(); } + bool has_mali_mali_pm_mcu_pend_on_reload() const { return at<530>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_pend_on_reload() const { return at<530>().as_bytes(); } + bool has_mali_mali_pm_mcu_power_down() const { return at<531>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_power_down() const { return at<531>().as_bytes(); } + bool has_mali_mali_pm_mcu_reset_wait() const { return at<532>().valid(); } + ::protozero::ConstBytes mali_mali_pm_mcu_reset_wait() const { return at<532>().as_bytes(); } }; class FtraceEvent : public ::protozero::Message { @@ -73707,6 +73704,41 @@ class FtraceEvent : public ::protozero::Message { kF2fsBackgroundGcFieldNumber = 495, kF2fsGcBeginFieldNumber = 496, kF2fsGcEndFieldNumber = 497, + kFastrpcDmaFreeFieldNumber = 498, + kFastrpcDmaAllocFieldNumber = 499, + kFastrpcDmaUnmapFieldNumber = 500, + kFastrpcDmaMapFieldNumber = 501, + kGoogleIccEventFieldNumber = 502, + kGoogleIrmEventFieldNumber = 503, + kDevicePmCallbackStartFieldNumber = 504, + kDevicePmCallbackEndFieldNumber = 505, + kThermalExynosAcpmBulkFieldNumber = 506, + kThermalExynosAcpmHighOverheadFieldNumber = 507, + kDcvshFreqFieldNumber = 508, + kKgslGpuFrequencyFieldNumber = 509, + kMaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFieldNumber = 510, + kMaliMaliPMMCUHCTLCORESNOTIFYPENDFieldNumber = 511, + kMaliMaliPMMCUHCTLCOREINACTIVEPENDFieldNumber = 512, + kMaliMaliPMMCUHCTLMCUONRECHECKFieldNumber = 513, + kMaliMaliPMMCUHCTLSHADERSCOREOFFPENDFieldNumber = 514, + kMaliMaliPMMCUHCTLSHADERSPENDOFFFieldNumber = 515, + kMaliMaliPMMCUHCTLSHADERSPENDONFieldNumber = 516, + kMaliMaliPMMCUHCTLSHADERSREADYOFFFieldNumber = 517, + kMaliMaliPMMCUINSLEEPFieldNumber = 518, + kMaliMaliPMMCUOFFFieldNumber = 519, + kMaliMaliPMMCUONFieldNumber = 520, + kMaliMaliPMMCUONCOREATTRUPDATEPENDFieldNumber = 521, + kMaliMaliPMMCUONGLBREINITPENDFieldNumber = 522, + kMaliMaliPMMCUONHALTFieldNumber = 523, + kMaliMaliPMMCUONHWCNTDISABLEFieldNumber = 524, + kMaliMaliPMMCUONHWCNTENABLEFieldNumber = 525, + kMaliMaliPMMCUONPENDHALTFieldNumber = 526, + kMaliMaliPMMCUONPENDSLEEPFieldNumber = 527, + kMaliMaliPMMCUONSLEEPINITIATEFieldNumber = 528, + kMaliMaliPMMCUPENDOFFFieldNumber = 529, + kMaliMaliPMMCUPENDONRELOADFieldNumber = 530, + kMaliMaliPMMCUPOWERDOWNFieldNumber = 531, + kMaliMaliPMMCURESETWAITFieldNumber = 532, }; static constexpr const char* GetName() { return ".perfetto.protos.FtraceEvent"; } @@ -80428,6 +80460,496 @@ class FtraceEvent : public ::protozero::Message { return BeginNestedMessage(497); } + + using FieldMetadata_FastrpcDmaFree = + ::protozero::proto_utils::FieldMetadata< + 498, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaFreeFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaFree kFastrpcDmaFree{}; + template T* set_fastrpc_dma_free() { + return BeginNestedMessage(498); + } + + + using FieldMetadata_FastrpcDmaAlloc = + ::protozero::proto_utils::FieldMetadata< + 499, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaAllocFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaAlloc kFastrpcDmaAlloc{}; + template T* set_fastrpc_dma_alloc() { + return BeginNestedMessage(499); + } + + + using FieldMetadata_FastrpcDmaUnmap = + ::protozero::proto_utils::FieldMetadata< + 500, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaUnmapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaUnmap kFastrpcDmaUnmap{}; + template T* set_fastrpc_dma_unmap() { + return BeginNestedMessage(500); + } + + + using FieldMetadata_FastrpcDmaMap = + ::protozero::proto_utils::FieldMetadata< + 501, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + FastrpcDmaMapFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_FastrpcDmaMap kFastrpcDmaMap{}; + template T* set_fastrpc_dma_map() { + return BeginNestedMessage(501); + } + + + using FieldMetadata_GoogleIccEvent = + ::protozero::proto_utils::FieldMetadata< + 502, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GoogleIccEventFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_GoogleIccEvent kGoogleIccEvent{}; + template T* set_google_icc_event() { + return BeginNestedMessage(502); + } + + + using FieldMetadata_GoogleIrmEvent = + ::protozero::proto_utils::FieldMetadata< + 503, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + GoogleIrmEventFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_GoogleIrmEvent kGoogleIrmEvent{}; + template T* set_google_irm_event() { + return BeginNestedMessage(503); + } + + + using FieldMetadata_DevicePmCallbackStart = + ::protozero::proto_utils::FieldMetadata< + 504, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DevicePmCallbackStartFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DevicePmCallbackStart kDevicePmCallbackStart{}; + template T* set_device_pm_callback_start() { + return BeginNestedMessage(504); + } + + + using FieldMetadata_DevicePmCallbackEnd = + ::protozero::proto_utils::FieldMetadata< + 505, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DevicePmCallbackEndFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DevicePmCallbackEnd kDevicePmCallbackEnd{}; + template T* set_device_pm_callback_end() { + return BeginNestedMessage(505); + } + + + using FieldMetadata_ThermalExynosAcpmBulk = + ::protozero::proto_utils::FieldMetadata< + 506, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ThermalExynosAcpmBulkFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ThermalExynosAcpmBulk kThermalExynosAcpmBulk{}; + template T* set_thermal_exynos_acpm_bulk() { + return BeginNestedMessage(506); + } + + + using FieldMetadata_ThermalExynosAcpmHighOverhead = + ::protozero::proto_utils::FieldMetadata< + 507, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ThermalExynosAcpmHighOverheadFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_ThermalExynosAcpmHighOverhead kThermalExynosAcpmHighOverhead{}; + template T* set_thermal_exynos_acpm_high_overhead() { + return BeginNestedMessage(507); + } + + + using FieldMetadata_DcvshFreq = + ::protozero::proto_utils::FieldMetadata< + 508, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + DcvshFreqFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_DcvshFreq kDcvshFreq{}; + template T* set_dcvsh_freq() { + return BeginNestedMessage(508); + } + + + using FieldMetadata_KgslGpuFrequency = + ::protozero::proto_utils::FieldMetadata< + 509, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + KgslGpuFrequencyFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_KgslGpuFrequency kKgslGpuFrequency{}; + template T* set_kgsl_gpu_frequency() { + return BeginNestedMessage(509); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPEND = + ::protozero::proto_utils::FieldMetadata< + 510, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPEND kMaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPEND{}; + template T* set_mali_mali_pm_mcu_hctl_cores_down_scale_notify_pend() { + return BeginNestedMessage(510); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLCORESNOTIFYPEND = + ::protozero::proto_utils::FieldMetadata< + 511, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLCORESNOTIFYPEND kMaliMaliPMMCUHCTLCORESNOTIFYPEND{}; + template T* set_mali_mali_pm_mcu_hctl_cores_notify_pend() { + return BeginNestedMessage(511); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLCOREINACTIVEPEND = + ::protozero::proto_utils::FieldMetadata< + 512, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLCOREINACTIVEPEND kMaliMaliPMMCUHCTLCOREINACTIVEPEND{}; + template T* set_mali_mali_pm_mcu_hctl_core_inactive_pend() { + return BeginNestedMessage(512); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLMCUONRECHECK = + ::protozero::proto_utils::FieldMetadata< + 513, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLMCUONRECHECK kMaliMaliPMMCUHCTLMCUONRECHECK{}; + template T* set_mali_mali_pm_mcu_hctl_mcu_on_recheck() { + return BeginNestedMessage(513); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLSHADERSCOREOFFPEND = + ::protozero::proto_utils::FieldMetadata< + 514, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSCOREOFFPEND kMaliMaliPMMCUHCTLSHADERSCOREOFFPEND{}; + template T* set_mali_mali_pm_mcu_hctl_shaders_core_off_pend() { + return BeginNestedMessage(514); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDOFF = + ::protozero::proto_utils::FieldMetadata< + 515, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDOFF kMaliMaliPMMCUHCTLSHADERSPENDOFF{}; + template T* set_mali_mali_pm_mcu_hctl_shaders_pend_off() { + return BeginNestedMessage(515); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDON = + ::protozero::proto_utils::FieldMetadata< + 516, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSPENDON kMaliMaliPMMCUHCTLSHADERSPENDON{}; + template T* set_mali_mali_pm_mcu_hctl_shaders_pend_on() { + return BeginNestedMessage(516); + } + + + using FieldMetadata_MaliMaliPMMCUHCTLSHADERSREADYOFF = + ::protozero::proto_utils::FieldMetadata< + 517, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUHCTLSHADERSREADYOFF kMaliMaliPMMCUHCTLSHADERSREADYOFF{}; + template T* set_mali_mali_pm_mcu_hctl_shaders_ready_off() { + return BeginNestedMessage(517); + } + + + using FieldMetadata_MaliMaliPMMCUINSLEEP = + ::protozero::proto_utils::FieldMetadata< + 518, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUINSLEEPFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUINSLEEP kMaliMaliPMMCUINSLEEP{}; + template T* set_mali_mali_pm_mcu_in_sleep() { + return BeginNestedMessage(518); + } + + + using FieldMetadata_MaliMaliPMMCUOFF = + ::protozero::proto_utils::FieldMetadata< + 519, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUOFFFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUOFF kMaliMaliPMMCUOFF{}; + template T* set_mali_mali_pm_mcu_off() { + return BeginNestedMessage(519); + } + + + using FieldMetadata_MaliMaliPMMCUON = + ::protozero::proto_utils::FieldMetadata< + 520, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUON kMaliMaliPMMCUON{}; + template T* set_mali_mali_pm_mcu_on() { + return BeginNestedMessage(520); + } + + + using FieldMetadata_MaliMaliPMMCUONCOREATTRUPDATEPEND = + ::protozero::proto_utils::FieldMetadata< + 521, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONCOREATTRUPDATEPEND kMaliMaliPMMCUONCOREATTRUPDATEPEND{}; + template T* set_mali_mali_pm_mcu_on_core_attr_update_pend() { + return BeginNestedMessage(521); + } + + + using FieldMetadata_MaliMaliPMMCUONGLBREINITPEND = + ::protozero::proto_utils::FieldMetadata< + 522, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONGLBREINITPENDFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONGLBREINITPEND kMaliMaliPMMCUONGLBREINITPEND{}; + template T* set_mali_mali_pm_mcu_on_glb_reinit_pend() { + return BeginNestedMessage(522); + } + + + using FieldMetadata_MaliMaliPMMCUONHALT = + ::protozero::proto_utils::FieldMetadata< + 523, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONHALTFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONHALT kMaliMaliPMMCUONHALT{}; + template T* set_mali_mali_pm_mcu_on_halt() { + return BeginNestedMessage(523); + } + + + using FieldMetadata_MaliMaliPMMCUONHWCNTDISABLE = + ::protozero::proto_utils::FieldMetadata< + 524, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONHWCNTDISABLEFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONHWCNTDISABLE kMaliMaliPMMCUONHWCNTDISABLE{}; + template T* set_mali_mali_pm_mcu_on_hwcnt_disable() { + return BeginNestedMessage(524); + } + + + using FieldMetadata_MaliMaliPMMCUONHWCNTENABLE = + ::protozero::proto_utils::FieldMetadata< + 525, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONHWCNTENABLEFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONHWCNTENABLE kMaliMaliPMMCUONHWCNTENABLE{}; + template T* set_mali_mali_pm_mcu_on_hwcnt_enable() { + return BeginNestedMessage(525); + } + + + using FieldMetadata_MaliMaliPMMCUONPENDHALT = + ::protozero::proto_utils::FieldMetadata< + 526, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONPENDHALTFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONPENDHALT kMaliMaliPMMCUONPENDHALT{}; + template T* set_mali_mali_pm_mcu_on_pend_halt() { + return BeginNestedMessage(526); + } + + + using FieldMetadata_MaliMaliPMMCUONPENDSLEEP = + ::protozero::proto_utils::FieldMetadata< + 527, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONPENDSLEEPFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONPENDSLEEP kMaliMaliPMMCUONPENDSLEEP{}; + template T* set_mali_mali_pm_mcu_on_pend_sleep() { + return BeginNestedMessage(527); + } + + + using FieldMetadata_MaliMaliPMMCUONSLEEPINITIATE = + ::protozero::proto_utils::FieldMetadata< + 528, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUONSLEEPINITIATEFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUONSLEEPINITIATE kMaliMaliPMMCUONSLEEPINITIATE{}; + template T* set_mali_mali_pm_mcu_on_sleep_initiate() { + return BeginNestedMessage(528); + } + + + using FieldMetadata_MaliMaliPMMCUPENDOFF = + ::protozero::proto_utils::FieldMetadata< + 529, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUPENDOFFFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUPENDOFF kMaliMaliPMMCUPENDOFF{}; + template T* set_mali_mali_pm_mcu_pend_off() { + return BeginNestedMessage(529); + } + + + using FieldMetadata_MaliMaliPMMCUPENDONRELOAD = + ::protozero::proto_utils::FieldMetadata< + 530, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUPENDONRELOADFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUPENDONRELOAD kMaliMaliPMMCUPENDONRELOAD{}; + template T* set_mali_mali_pm_mcu_pend_on_reload() { + return BeginNestedMessage(530); + } + + + using FieldMetadata_MaliMaliPMMCUPOWERDOWN = + ::protozero::proto_utils::FieldMetadata< + 531, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCUPOWERDOWNFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCUPOWERDOWN kMaliMaliPMMCUPOWERDOWN{}; + template T* set_mali_mali_pm_mcu_power_down() { + return BeginNestedMessage(531); + } + + + using FieldMetadata_MaliMaliPMMCURESETWAIT = + ::protozero::proto_utils::FieldMetadata< + 532, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + MaliMaliPMMCURESETWAITFtraceEvent, + FtraceEvent>; + + static constexpr FieldMetadata_MaliMaliPMMCURESETWAIT kMaliMaliPMMCURESETWAIT{}; + template T* set_mali_mali_pm_mcu_reset_wait() { + return BeginNestedMessage(532); + } + }; } // Namespace. @@ -89672,6 +90194,88 @@ class CrosEcSensorhubDataFtraceEvent : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/dcvsh.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DCVSH_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_DCVSH_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class DcvshFreqFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DcvshFreqFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DcvshFreqFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DcvshFreqFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cpu() const { return at<1>().valid(); } + uint64_t cpu() const { return at<1>().as_uint64(); } + bool has_freq() const { return at<2>().valid(); } + uint64_t freq() const { return at<2>().as_uint64(); } +}; + +class DcvshFreqFtraceEvent : public ::protozero::Message { + public: + using Decoder = DcvshFreqFtraceEvent_Decoder; + enum : int32_t { + kCpuFieldNumber = 1, + kFreqFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DcvshFreqFtraceEvent"; } + + + using FieldMetadata_Cpu = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DcvshFreqFtraceEvent>; + + static constexpr FieldMetadata_Cpu kCpu{}; + void set_cpu(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cpu::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Freq = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + DcvshFreqFtraceEvent>; + + static constexpr FieldMetadata_Freq kFreq{}; + void set_freq(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Freq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -108760,6 +109364,448 @@ namespace perfetto { namespace protos { namespace pbzero { +class FastrpcDmaMapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaMapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaMapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaMapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_fd() const { return at<2>().valid(); } + int32_t fd() const { return at<2>().as_int32(); } + bool has_phys() const { return at<3>().valid(); } + uint64_t phys() const { return at<3>().as_uint64(); } + bool has_size() const { return at<4>().valid(); } + uint64_t size() const { return at<4>().as_uint64(); } + bool has_len() const { return at<5>().valid(); } + uint64_t len() const { return at<5>().as_uint64(); } + bool has_attr() const { return at<6>().valid(); } + uint32_t attr() const { return at<6>().as_uint32(); } + bool has_mflags() const { return at<7>().valid(); } + int32_t mflags() const { return at<7>().as_int32(); } +}; + +class FastrpcDmaMapFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaMapFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kFdFieldNumber = 2, + kPhysFieldNumber = 3, + kSizeFieldNumber = 4, + kLenFieldNumber = 5, + kAttrFieldNumber = 6, + kMflagsFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaMapFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Fd = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Fd kFd{}; + void set_fd(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Fd::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Len = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Len kLen{}; + void set_len(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Len::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Attr = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Attr kAttr{}; + void set_attr(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Attr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mflags = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaMapFtraceEvent>; + + static constexpr FieldMetadata_Mflags kMflags{}; + void set_mflags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaUnmapFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaUnmapFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaUnmapFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaUnmapFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_phys() const { return at<2>().valid(); } + uint64_t phys() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class FastrpcDmaUnmapFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaUnmapFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kPhysFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaUnmapFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaUnmapFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaUnmapFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaUnmapFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaAllocFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaAllocFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaAllocFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaAllocFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_phys() const { return at<2>().valid(); } + uint64_t phys() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } + bool has_attr() const { return at<4>().valid(); } + uint64_t attr() const { return at<4>().as_uint64(); } + bool has_mflags() const { return at<5>().valid(); } + int32_t mflags() const { return at<5>().as_int32(); } +}; + +class FastrpcDmaAllocFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaAllocFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kPhysFieldNumber = 2, + kSizeFieldNumber = 3, + kAttrFieldNumber = 4, + kMflagsFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaAllocFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Attr = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Attr kAttr{}; + void set_attr(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Attr::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Mflags = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaAllocFtraceEvent>; + + static constexpr FieldMetadata_Mflags kMflags{}; + void set_mflags(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Mflags::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class FastrpcDmaFreeFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + FastrpcDmaFreeFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit FastrpcDmaFreeFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit FastrpcDmaFreeFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_cid() const { return at<1>().valid(); } + int32_t cid() const { return at<1>().as_int32(); } + bool has_phys() const { return at<2>().valid(); } + uint64_t phys() const { return at<2>().as_uint64(); } + bool has_size() const { return at<3>().valid(); } + uint64_t size() const { return at<3>().as_uint64(); } +}; + +class FastrpcDmaFreeFtraceEvent : public ::protozero::Message { + public: + using Decoder = FastrpcDmaFreeFtraceEvent_Decoder; + enum : int32_t { + kCidFieldNumber = 1, + kPhysFieldNumber = 2, + kSizeFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.FastrpcDmaFreeFtraceEvent"; } + + + using FieldMetadata_Cid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + FastrpcDmaFreeFtraceEvent>; + + static constexpr FieldMetadata_Cid kCid{}; + void set_cid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Cid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Phys = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaFreeFtraceEvent>; + + static constexpr FieldMetadata_Phys kPhys{}; + void set_phys(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Phys::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Size = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + FastrpcDmaFreeFtraceEvent>; + + static constexpr FieldMetadata_Size kSize{}; + void set_size(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Size::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + class FastrpcDmaStatFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: FastrpcDmaStatFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} @@ -109974,6 +111020,182 @@ class G2dTracingMarkWriteFtraceEvent : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/google_icc_trace.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_ICC_TRACE_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_ICC_TRACE_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class GoogleIccEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GoogleIccEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GoogleIccEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GoogleIccEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event() const { return at<1>().valid(); } + ::protozero::ConstChars event() const { return at<1>().as_string(); } + bool has_timestamp() const { return at<2>().valid(); } + uint64_t timestamp() const { return at<2>().as_uint64(); } +}; + +class GoogleIccEventFtraceEvent : public ::protozero::Message { + public: + using Decoder = GoogleIccEventFtraceEvent_Decoder; + enum : int32_t { + kEventFieldNumber = 1, + kTimestampFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GoogleIccEventFtraceEvent"; } + + + using FieldMetadata_Event = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GoogleIccEventFtraceEvent>; + + static constexpr FieldMetadata_Event kEvent{}; + void set_event(const char* data, size_t size) { + AppendBytes(FieldMetadata_Event::kFieldId, data, size); + } + void set_event(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Event::kFieldId, chars.data, chars.size); + } + void set_event(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GoogleIccEventFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/google_irm_trace.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_IRM_TRACE_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_GOOGLE_IRM_TRACE_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class GoogleIrmEventFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + GoogleIrmEventFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit GoogleIrmEventFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit GoogleIrmEventFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_event() const { return at<1>().valid(); } + ::protozero::ConstChars event() const { return at<1>().as_string(); } + bool has_timestamp() const { return at<2>().valid(); } + uint64_t timestamp() const { return at<2>().as_uint64(); } +}; + +class GoogleIrmEventFtraceEvent : public ::protozero::Message { + public: + using Decoder = GoogleIrmEventFtraceEvent_Decoder; + enum : int32_t { + kEventFieldNumber = 1, + kTimestampFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.GoogleIrmEventFtraceEvent"; } + + + using FieldMetadata_Event = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + GoogleIrmEventFtraceEvent>; + + static constexpr FieldMetadata_Event kEvent{}; + void set_event(const char* data, size_t size) { + AppendBytes(FieldMetadata_Event::kFieldId, data, size); + } + void set_event(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Event::kFieldId, chars.data, chars.size); + } + void set_event(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + GoogleIrmEventFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -112291,6 +113513,88 @@ class SoftirqEntryFtraceEvent : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/kgsl.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KGSL_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_KGSL_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class KgslGpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + KgslGpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit KgslGpuFrequencyFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit KgslGpuFrequencyFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_gpu_freq() const { return at<1>().valid(); } + uint32_t gpu_freq() const { return at<1>().as_uint32(); } + bool has_gpu_id() const { return at<2>().valid(); } + uint32_t gpu_id() const { return at<2>().as_uint32(); } +}; + +class KgslGpuFrequencyFtraceEvent : public ::protozero::Message { + public: + using Decoder = KgslGpuFrequencyFtraceEvent_Decoder; + enum : int32_t { + kGpuFreqFieldNumber = 1, + kGpuIdFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.KgslGpuFrequencyFtraceEvent"; } + + + using FieldMetadata_GpuFreq = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KgslGpuFrequencyFtraceEvent>; + + static constexpr FieldMetadata_GpuFreq kGpuFreq{}; + void set_gpu_freq(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuFreq::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_GpuId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + KgslGpuFrequencyFtraceEvent>; + + static constexpr FieldMetadata_GpuId kGpuId{}; + void set_gpu_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_GpuId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -119036,6 +120340,1823 @@ namespace perfetto { namespace protos { namespace pbzero { +class MaliMaliPMMCURESETWAITFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCURESETWAITFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCURESETWAITFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCURESETWAITFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCURESETWAITFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCURESETWAITFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCURESETWAITFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCURESETWAITFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCURESETWAITFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCURESETWAITFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUPOWERDOWNFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUPOWERDOWNFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUPOWERDOWNFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUPOWERDOWNFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUPOWERDOWNFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUPOWERDOWNFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUPENDONRELOADFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUPENDONRELOADFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUPENDONRELOADFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUPENDONRELOADFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUPENDONRELOADFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUPENDONRELOADFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUPENDOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUPENDOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUPENDOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUPENDOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUPENDOFFFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUPENDOFFFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUPENDOFFFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUPENDOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUPENDOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUPENDOFFFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONSLEEPINITIATEFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONSLEEPINITIATEFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONSLEEPINITIATEFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONSLEEPINITIATEFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONSLEEPINITIATEFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONSLEEPINITIATEFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONPENDSLEEPFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONPENDSLEEPFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONPENDSLEEPFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONPENDSLEEPFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONPENDSLEEPFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONPENDSLEEPFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONPENDHALTFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONPENDHALTFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONPENDHALTFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONPENDHALTFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONPENDHALTFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONPENDHALTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONHWCNTENABLEFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONHWCNTENABLEFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONHWCNTENABLEFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONHWCNTENABLEFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONHWCNTENABLEFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONHWCNTENABLEFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONHWCNTDISABLEFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONHWCNTDISABLEFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONHWCNTDISABLEFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONHWCNTDISABLEFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONHWCNTDISABLEFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONHWCNTDISABLEFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONHALTFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONHALTFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONHALTFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONHALTFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONHALTFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONHALTFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONHALTFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONHALTFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONHALTFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONHALTFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONGLBREINITPENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONGLBREINITPENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONGLBREINITPENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONGLBREINITPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONGLBREINITPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONGLBREINITPENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONCOREATTRUPDATEPENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUONFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUONFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUONFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUONFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUONFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUONFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUONFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUONFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUONFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUONFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUOFFFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUOFFFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUOFFFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUOFFFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUINSLEEPFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUINSLEEPFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUINSLEEPFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUINSLEEPFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUINSLEEPFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUINSLEEPFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUINSLEEPFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUINSLEEPFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUINSLEEPFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUINSLEEPFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLSHADERSREADYOFFFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLSHADERSPENDONFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLSHADERSPENDOFFFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLSHADERSCOREOFFPENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLMCUONRECHECKFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLCOREINACTIVEPENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLCORESNOTIFYPENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + +class MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_kctx_tgid() const { return at<1>().valid(); } + int32_t kctx_tgid() const { return at<1>().as_int32(); } + bool has_kctx_id() const { return at<2>().valid(); } + uint32_t kctx_id() const { return at<2>().as_uint32(); } + bool has_info_val() const { return at<3>().valid(); } + uint64_t info_val() const { return at<3>().as_uint64(); } +}; + +class MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent : public ::protozero::Message { + public: + using Decoder = MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent_Decoder; + enum : int32_t { + kKctxTgidFieldNumber = 1, + kKctxIdFieldNumber = 2, + kInfoValFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent"; } + + + using FieldMetadata_KctxTgid = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxTgid kKctxTgid{}; + void set_kctx_tgid(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxTgid::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KctxId = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent>; + + static constexpr FieldMetadata_KctxId kKctxId{}; + void set_kctx_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KctxId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_InfoVal = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + MaliMaliPMMCUHCTLCORESDOWNSCALENOTIFYPENDFtraceEvent>; + + static constexpr FieldMetadata_InfoVal kInfoVal{}; + void set_info_val(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_InfoVal::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + class MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: MaliMaliCSFINTERRUPTENDFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} @@ -124346,6 +127467,242 @@ namespace perfetto { namespace protos { namespace pbzero { +class DevicePmCallbackEndFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DevicePmCallbackEndFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DevicePmCallbackEndFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DevicePmCallbackEndFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_device() const { return at<1>().valid(); } + ::protozero::ConstChars device() const { return at<1>().as_string(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_error() const { return at<3>().valid(); } + int32_t error() const { return at<3>().as_int32(); } +}; + +class DevicePmCallbackEndFtraceEvent : public ::protozero::Message { + public: + using Decoder = DevicePmCallbackEndFtraceEvent_Decoder; + enum : int32_t { + kDeviceFieldNumber = 1, + kDriverFieldNumber = 2, + kErrorFieldNumber = 3, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DevicePmCallbackEndFtraceEvent"; } + + + using FieldMetadata_Device = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DevicePmCallbackEndFtraceEvent>; + + static constexpr FieldMetadata_Device kDevice{}; + void set_device(const char* data, size_t size) { + AppendBytes(FieldMetadata_Device::kFieldId, data, size); + } + void set_device(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Device::kFieldId, chars.data, chars.size); + } + void set_device(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DevicePmCallbackEndFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Error = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DevicePmCallbackEndFtraceEvent>; + + static constexpr FieldMetadata_Error kError{}; + void set_error(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Error::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class DevicePmCallbackStartFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + DevicePmCallbackStartFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit DevicePmCallbackStartFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit DevicePmCallbackStartFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_device() const { return at<1>().valid(); } + ::protozero::ConstChars device() const { return at<1>().as_string(); } + bool has_driver() const { return at<2>().valid(); } + ::protozero::ConstChars driver() const { return at<2>().as_string(); } + bool has_parent() const { return at<3>().valid(); } + ::protozero::ConstChars parent() const { return at<3>().as_string(); } + bool has_pm_ops() const { return at<4>().valid(); } + ::protozero::ConstChars pm_ops() const { return at<4>().as_string(); } + bool has_event() const { return at<5>().valid(); } + int32_t event() const { return at<5>().as_int32(); } +}; + +class DevicePmCallbackStartFtraceEvent : public ::protozero::Message { + public: + using Decoder = DevicePmCallbackStartFtraceEvent_Decoder; + enum : int32_t { + kDeviceFieldNumber = 1, + kDriverFieldNumber = 2, + kParentFieldNumber = 3, + kPmOpsFieldNumber = 4, + kEventFieldNumber = 5, + }; + static constexpr const char* GetName() { return ".perfetto.protos.DevicePmCallbackStartFtraceEvent"; } + + + using FieldMetadata_Device = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DevicePmCallbackStartFtraceEvent>; + + static constexpr FieldMetadata_Device kDevice{}; + void set_device(const char* data, size_t size) { + AppendBytes(FieldMetadata_Device::kFieldId, data, size); + } + void set_device(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Device::kFieldId, chars.data, chars.size); + } + void set_device(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Device::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Driver = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DevicePmCallbackStartFtraceEvent>; + + static constexpr FieldMetadata_Driver kDriver{}; + void set_driver(const char* data, size_t size) { + AppendBytes(FieldMetadata_Driver::kFieldId, data, size); + } + void set_driver(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Driver::kFieldId, chars.data, chars.size); + } + void set_driver(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Driver::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Parent = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DevicePmCallbackStartFtraceEvent>; + + static constexpr FieldMetadata_Parent kParent{}; + void set_parent(const char* data, size_t size) { + AppendBytes(FieldMetadata_Parent::kFieldId, data, size); + } + void set_parent(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Parent::kFieldId, chars.data, chars.size); + } + void set_parent(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Parent::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PmOps = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + DevicePmCallbackStartFtraceEvent>; + + static constexpr FieldMetadata_PmOps kPmOps{}; + void set_pm_ops(const char* data, size_t size) { + AppendBytes(FieldMetadata_PmOps::kFieldId, data, size); + } + void set_pm_ops(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_PmOps::kFieldId, chars.data, chars.size); + } + void set_pm_ops(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_PmOps::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Event = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + DevicePmCallbackStartFtraceEvent>; + + static constexpr FieldMetadata_Event kEvent{}; + void set_event(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_Event::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + class GpuWorkPeriodFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { public: GpuWorkPeriodFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} @@ -130696,6 +134053,440 @@ class ThermalTemperatureFtraceEvent : public ::protozero::Message { } }; +} // Namespace. +} // Namespace. +} // Namespace. +#endif // Include guard. +// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/thermal_exynos.pbzero.h +// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT. + +#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_EXYNOS_PROTO_H_ +#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_THERMAL_EXYNOS_PROTO_H_ + +#include +#include + +// gen_amalgamated expanded: #include "perfetto/protozero/field_writer.h" +// gen_amalgamated expanded: #include "perfetto/protozero/message.h" +// gen_amalgamated expanded: #include "perfetto/protozero/packed_repeated_fields.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_decoder.h" +// gen_amalgamated expanded: #include "perfetto/protozero/proto_utils.h" + + +namespace perfetto { +namespace protos { +namespace pbzero { + +class ThermalExynosAcpmHighOverheadFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ThermalExynosAcpmHighOverheadFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ThermalExynosAcpmHighOverheadFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ThermalExynosAcpmHighOverheadFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tz_id() const { return at<1>().valid(); } + int32_t tz_id() const { return at<1>().as_int32(); } + bool has_current_temp() const { return at<2>().valid(); } + uint32_t current_temp() const { return at<2>().as_uint32(); } + bool has_ctrl_temp() const { return at<3>().valid(); } + uint32_t ctrl_temp() const { return at<3>().as_uint32(); } + bool has_cdev_state() const { return at<4>().valid(); } + uint32_t cdev_state() const { return at<4>().as_uint32(); } + bool has_pid_et_p() const { return at<5>().valid(); } + int32_t pid_et_p() const { return at<5>().as_int32(); } + bool has_k_p() const { return at<6>().valid(); } + int32_t k_p() const { return at<6>().as_int32(); } + bool has_k_i() const { return at<7>().valid(); } + int32_t k_i() const { return at<7>().as_int32(); } +}; + +class ThermalExynosAcpmHighOverheadFtraceEvent : public ::protozero::Message { + public: + using Decoder = ThermalExynosAcpmHighOverheadFtraceEvent_Decoder; + enum : int32_t { + kTzIdFieldNumber = 1, + kCurrentTempFieldNumber = 2, + kCtrlTempFieldNumber = 3, + kCdevStateFieldNumber = 4, + kPidEtPFieldNumber = 5, + kKPFieldNumber = 6, + kKIFieldNumber = 7, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ThermalExynosAcpmHighOverheadFtraceEvent"; } + + + using FieldMetadata_TzId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_TzId kTzId{}; + void set_tz_id(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TzId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentTemp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_CurrentTemp kCurrentTemp{}; + void set_current_temp(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentTemp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CtrlTemp = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_CtrlTemp kCtrlTemp{}; + void set_ctrl_temp(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtrlTemp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CdevState = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_CdevState kCdevState{}; + void set_cdev_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CdevState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PidEtP = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_PidEtP kPidEtP{}; + void set_pid_et_p(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PidEtP::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KP = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_KP kKP{}; + void set_k_p(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KP::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KI = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmHighOverheadFtraceEvent>; + + static constexpr FieldMetadata_KI kKI{}; + void set_k_i(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KI::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } +}; + +class ThermalExynosAcpmBulkFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder { + public: + ThermalExynosAcpmBulkFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ThermalExynosAcpmBulkFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ThermalExynosAcpmBulkFtraceEvent_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_tz_id() const { return at<1>().valid(); } + uint32_t tz_id() const { return at<1>().as_uint32(); } + bool has_current_temp() const { return at<2>().valid(); } + uint32_t current_temp() const { return at<2>().as_uint32(); } + bool has_ctrl_temp() const { return at<3>().valid(); } + uint32_t ctrl_temp() const { return at<3>().as_uint32(); } + bool has_cdev_state() const { return at<4>().valid(); } + uint32_t cdev_state() const { return at<4>().as_uint32(); } + bool has_pid_et_p() const { return at<5>().valid(); } + int32_t pid_et_p() const { return at<5>().as_int32(); } + bool has_pid_power_range() const { return at<6>().valid(); } + int32_t pid_power_range() const { return at<6>().as_int32(); } + bool has_pid_p() const { return at<7>().valid(); } + int32_t pid_p() const { return at<7>().as_int32(); } + bool has_pid_i() const { return at<8>().valid(); } + int32_t pid_i() const { return at<8>().as_int32(); } + bool has_k_p() const { return at<9>().valid(); } + int32_t k_p() const { return at<9>().as_int32(); } + bool has_k_i() const { return at<10>().valid(); } + int32_t k_i() const { return at<10>().as_int32(); } + bool has_timestamp() const { return at<11>().valid(); } + uint64_t timestamp() const { return at<11>().as_uint64(); } +}; + +class ThermalExynosAcpmBulkFtraceEvent : public ::protozero::Message { + public: + using Decoder = ThermalExynosAcpmBulkFtraceEvent_Decoder; + enum : int32_t { + kTzIdFieldNumber = 1, + kCurrentTempFieldNumber = 2, + kCtrlTempFieldNumber = 3, + kCdevStateFieldNumber = 4, + kPidEtPFieldNumber = 5, + kPidPowerRangeFieldNumber = 6, + kPidPFieldNumber = 7, + kPidIFieldNumber = 8, + kKPFieldNumber = 9, + kKIFieldNumber = 10, + kTimestampFieldNumber = 11, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ThermalExynosAcpmBulkFtraceEvent"; } + + + using FieldMetadata_TzId = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_TzId kTzId{}; + void set_tz_id(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_TzId::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CurrentTemp = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_CurrentTemp kCurrentTemp{}; + void set_current_temp(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CurrentTemp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CtrlTemp = + ::protozero::proto_utils::FieldMetadata< + 3, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_CtrlTemp kCtrlTemp{}; + void set_ctrl_temp(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CtrlTemp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_CdevState = + ::protozero::proto_utils::FieldMetadata< + 4, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint32, + uint32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_CdevState kCdevState{}; + void set_cdev_state(uint32_t value) { + static constexpr uint32_t field_id = FieldMetadata_CdevState::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PidEtP = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_PidEtP kPidEtP{}; + void set_pid_et_p(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PidEtP::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PidPowerRange = + ::protozero::proto_utils::FieldMetadata< + 6, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_PidPowerRange kPidPowerRange{}; + void set_pid_power_range(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PidPowerRange::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PidP = + ::protozero::proto_utils::FieldMetadata< + 7, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_PidP kPidP{}; + void set_pid_p(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PidP::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_PidI = + ::protozero::proto_utils::FieldMetadata< + 8, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_PidI kPidI{}; + void set_pid_i(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_PidI::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KP = + ::protozero::proto_utils::FieldMetadata< + 9, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_KP kKP{}; + void set_k_p(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KP::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_KI = + ::protozero::proto_utils::FieldMetadata< + 10, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kInt32, + int32_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_KI kKI{}; + void set_k_i(int32_t value) { + static constexpr uint32_t field_id = FieldMetadata_KI::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kInt32> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Timestamp = + ::protozero::proto_utils::FieldMetadata< + 11, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ThermalExynosAcpmBulkFtraceEvent>; + + static constexpr FieldMetadata_Timestamp kTimestamp{}; + void set_timestamp(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_Timestamp::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } +}; + } // Namespace. } // Namespace. } // Namespace. @@ -137215,7 +141006,7 @@ class InternedGraphicsContext : public ::protozero::Message { } }; -class GpuRenderStageEvent_Decoder : public ::protozero::TypedProtoDecoder { +class GpuRenderStageEvent_Decoder : public ::protozero::TypedProtoDecoder { public: GpuRenderStageEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit GpuRenderStageEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -151896,7 +155687,7 @@ class ProcessStats : public ::protozero::Message { } }; -class ProcessStats_Process_Decoder : public ::protozero::TypedProtoDecoder { +class ProcessStats_Process_Decoder : public ::protozero::TypedProtoDecoder { public: ProcessStats_Process_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit ProcessStats_Process_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -151941,6 +155732,8 @@ class ProcessStats_Process_Decoder : public ::protozero::TypedProtoDecoder().as_uint64(); } bool has_smr_pss_shmem_kb() const { return at<20>().valid(); } uint64_t smr_pss_shmem_kb() const { return at<20>().as_uint64(); } + bool has_smr_swap_pss_kb() const { return at<23>().valid(); } + uint64_t smr_swap_pss_kb() const { return at<23>().as_uint64(); } bool has_runtime_user_mode() const { return at<21>().valid(); } uint64_t runtime_user_mode() const { return at<21>().as_uint64(); } bool has_runtime_kernel_mode() const { return at<22>().valid(); } @@ -151971,6 +155764,7 @@ class ProcessStats_Process : public ::protozero::Message { kSmrPssAnonKbFieldNumber = 18, kSmrPssFileKbFieldNumber = 19, kSmrPssShmemKbFieldNumber = 20, + kSmrSwapPssKbFieldNumber = 23, kRuntimeUserModeFieldNumber = 21, kRuntimeKernelModeFieldNumber = 22, }; @@ -152329,6 +156123,24 @@ class ProcessStats_Process : public ::protozero::Message { ::Append(*this, field_id, value); } + using FieldMetadata_SmrSwapPssKb = + ::protozero::proto_utils::FieldMetadata< + 23, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kUint64, + uint64_t, + ProcessStats_Process>; + + static constexpr FieldMetadata_SmrSwapPssKb kSmrSwapPssKb{}; + void set_smr_swap_pss_kb(uint64_t value) { + static constexpr uint32_t field_id = FieldMetadata_SmrSwapPssKb::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kUint64> + ::Append(*this, field_id, value); + } + using FieldMetadata_RuntimeUserMode = ::protozero::proto_utils::FieldMetadata< 21, @@ -154248,6 +158060,8 @@ class ChromePerformanceMarkTranslationTable_MarkHashToNameEntry; class ChromePerformanceMarkTranslationTable_SiteHashToNameEntry; class ChromeUserEventTranslationTable; class ChromeUserEventTranslationTable_ActionHashToNameEntry; +class ProcessTrackNameTranslationTable; +class ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry; class SliceNameTranslationTable; class SliceNameTranslationTable_RawToDeobfuscatedNameEntry; } // Namespace pbzero. @@ -154258,6 +158072,110 @@ namespace perfetto { namespace protos { namespace pbzero { +class ProcessTrackNameTranslationTable_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessTrackNameTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessTrackNameTranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessTrackNameTranslationTable_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_raw_to_deobfuscated_name() const { return at<1>().valid(); } + ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> raw_to_deobfuscated_name() const { return GetRepeated<::protozero::ConstBytes>(1); } +}; + +class ProcessTrackNameTranslationTable : public ::protozero::Message { + public: + using Decoder = ProcessTrackNameTranslationTable_Decoder; + enum : int32_t { + kRawToDeobfuscatedNameFieldNumber = 1, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessTrackNameTranslationTable"; } + + using RawToDeobfuscatedNameEntry = ::perfetto::protos::pbzero::ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry; + + using FieldMetadata_RawToDeobfuscatedName = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry, + ProcessTrackNameTranslationTable>; + + static constexpr FieldMetadata_RawToDeobfuscatedName kRawToDeobfuscatedName{}; + template T* add_raw_to_deobfuscated_name() { + return BeginNestedMessage(1); + } + +}; + +class ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder : public ::protozero::TypedProtoDecoder { + public: + ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} + explicit ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} + explicit ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {} + bool has_key() const { return at<1>().valid(); } + ::protozero::ConstChars key() const { return at<1>().as_string(); } + bool has_value() const { return at<2>().valid(); } + ::protozero::ConstChars value() const { return at<2>().as_string(); } +}; + +class ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry : public ::protozero::Message { + public: + using Decoder = ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry_Decoder; + enum : int32_t { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + static constexpr const char* GetName() { return ".perfetto.protos.ProcessTrackNameTranslationTable.RawToDeobfuscatedNameEntry"; } + + + using FieldMetadata_Key = + ::protozero::proto_utils::FieldMetadata< + 1, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry>; + + static constexpr FieldMetadata_Key kKey{}; + void set_key(const char* data, size_t size) { + AppendBytes(FieldMetadata_Key::kFieldId, data, size); + } + void set_key(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Key::kFieldId, chars.data, chars.size); + } + void set_key(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Key::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } + + using FieldMetadata_Value = + ::protozero::proto_utils::FieldMetadata< + 2, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kString, + std::string, + ProcessTrackNameTranslationTable_RawToDeobfuscatedNameEntry>; + + static constexpr FieldMetadata_Value kValue{}; + void set_value(const char* data, size_t size) { + AppendBytes(FieldMetadata_Value::kFieldId, data, size); + } + void set_value(::protozero::ConstChars chars) { + AppendBytes(FieldMetadata_Value::kFieldId, chars.data, chars.size); + } + void set_value(std::string value) { + static constexpr uint32_t field_id = FieldMetadata_Value::kFieldId; + // Call the appropriate protozero::Message::Append(field_id, ...) + // method based on the type of the field. + ::protozero::internal::FieldWriter< + ::protozero::proto_utils::ProtoSchemaType::kString> + ::Append(*this, field_id, value); + } +}; + class SliceNameTranslationTable_Decoder : public ::protozero::TypedProtoDecoder { public: SliceNameTranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} @@ -154738,7 +158656,7 @@ class ChromeHistorgramTranslationTable_HashToNameEntry : public ::protozero::Mes } }; -class TranslationTable_Decoder : public ::protozero::TypedProtoDecoder { +class TranslationTable_Decoder : public ::protozero::TypedProtoDecoder { public: TranslationTable_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {} explicit TranslationTable_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast(raw.data()), raw.size()) {} @@ -154751,6 +158669,8 @@ class TranslationTable_Decoder : public ::protozero::TypedProtoDecoder().as_bytes(); } bool has_slice_name() const { return at<4>().valid(); } ::protozero::ConstBytes slice_name() const { return at<4>().as_bytes(); } + bool has_process_track_name() const { return at<5>().valid(); } + ::protozero::ConstBytes process_track_name() const { return at<5>().as_bytes(); } }; class TranslationTable : public ::protozero::Message { @@ -154761,6 +158681,7 @@ class TranslationTable : public ::protozero::Message { kChromeUserEventFieldNumber = 2, kChromePerformanceMarkFieldNumber = 3, kSliceNameFieldNumber = 4, + kProcessTrackNameFieldNumber = 5, }; static constexpr const char* GetName() { return ".perfetto.protos.TranslationTable"; } @@ -154820,6 +158741,20 @@ class TranslationTable : public ::protozero::Message { return BeginNestedMessage(4); } + + using FieldMetadata_ProcessTrackName = + ::protozero::proto_utils::FieldMetadata< + 5, + ::protozero::proto_utils::RepetitionType::kNotRepeated, + ::protozero::proto_utils::ProtoSchemaType::kMessage, + ProcessTrackNameTranslationTable, + TranslationTable>; + + static constexpr FieldMetadata_ProcessTrackName kProcessTrackName{}; + template T* set_process_track_name() { + return BeginNestedMessage(5); + } + }; } // Namespace. @@ -155406,6 +159341,7 @@ namespace perfetto { namespace protos { namespace pbzero { class DebugAnnotation; +class TestExtensionChild; } // Namespace pbzero. } // Namespace protos. } // Namespace perfetto. @@ -155598,6 +159534,14 @@ class TestExtension : public ::perfetto::protos::pbzero::TrackEvent { ::protozero::proto_utils::ProtoSchemaType::kUint32> ::Append(*this, field_id, value); } + enum : int32_t { + kStringExtensionForTestingFieldNumber = 9900, + kStringExtensionForTesting2FieldNumber = 9905, + kIntExtensionForTestingFieldNumber = 9901, + kOmittedExtensionForTestingFieldNumber = 9902, + kNestedMessageExtensionForTestingFieldNumber = 9903, + kUintExtensionForTestingFieldNumber = 9904, + }; }; } // Namespace. } // Namespace. @@ -161373,6 +165317,7 @@ class TraceStats_BufferStats; class GetTraceStatsRequest; class AttachResponse; class TraceConfig; +class TraceConfig_SessionSemaphore; class TraceConfig_CmdTraceStartDelay; class TraceConfig_AndroidReportConfig; class TraceConfig_TraceFilter;