From f3f90565e810204c794847e76ac792b6dab043bc Mon Sep 17 00:00:00 2001
From: Denis Palmeiro <dpalmeiro@mozilla.com>
Date: Mon, 19 Aug 2024 21:07:28 +0000
Subject: [PATCH] Bug 1912106: Update to perfetto v47.0. r=smaug

Differential Revision: https://phabricator.services.mozilla.com/D219542
---
 third_party/perfetto/LICENSE         |   27 +
 third_party/perfetto/moz.yaml        |    4 +-
 third_party/perfetto/sdk/perfetto.cc |  235 ++-
 third_party/perfetto/sdk/perfetto.h  | 2075 +++++++++++++++++++++++++-
 4 files changed, 2311 insertions(+), 30 deletions(-)

diff --git a/third_party/perfetto/LICENSE b/third_party/perfetto/LICENSE
index bb056df22395..cd2eba57bff1 100644
--- a/third_party/perfetto/LICENSE
+++ b/third_party/perfetto/LICENSE
@@ -187,3 +187,30 @@
    limitations under the License.
 
 
+   Copyright 2015 The Chromium Authors
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+      * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+      * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+      * Neither the name of Google LLC nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/third_party/perfetto/moz.yaml b/third_party/perfetto/moz.yaml
index 8863114e26dc..3392814d14ad 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: v46.0 (2024-06-13T17:08:13+00:00).
-  revision: v46.0
+  release: v47.0 (2024-08-07T12:54:13+00:00).
+  revision: v47.0
 
 updatebot:
   maintainer-phab: denispal
diff --git a/third_party/perfetto/sdk/perfetto.cc b/third_party/perfetto/sdk/perfetto.cc
index 368c90ccfbd2..b10dd5aa920b 100644
--- a/third_party/perfetto/sdk/perfetto.cc
+++ b/third_party/perfetto/sdk/perfetto.cc
@@ -745,6 +745,10 @@ std::string GetCurExecutableDir();
 void* AlignedAlloc(size_t alignment, size_t size);
 void AlignedFree(void*);
 
+// Detects Sync-mode MTE (currently being tested in some Android builds).
+// This is known to use extra memory for the stack history buffer.
+bool IsSyncMemoryTaggingEnabled();
+
 // A RAII version of the above, which takes care of pairing Aligned{Alloc,Free}.
 template <typename T>
 struct AlignedDeleter {
@@ -2090,7 +2094,7 @@ inline Status OkStatus() {
   return Status();
 }
 
-PERFETTO_PRINTF_FORMAT(1, 2) Status ErrStatus(const char* format, ...);
+Status ErrStatus(const char* format, ...) PERFETTO_PRINTF_FORMAT(1, 2);
 
 }  // namespace base
 }  // namespace perfetto
@@ -6552,6 +6556,25 @@ std::optional<int32_t> GetTimezoneOffsetMins() {
 #include <mach/vm_page_size.h>
 #endif
 
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+#include <linux/prctl.h>
+#include <sys/prctl.h>
+
+#ifndef PR_GET_TAGGED_ADDR_CTRL
+#define PR_GET_TAGGED_ADDR_CTRL 56
+#endif
+
+#ifndef PR_TAGGED_ADDR_ENABLE
+#define PR_TAGGED_ADDR_ENABLE (1UL << 0)
+#endif
+
+#ifndef PR_MTE_TCF_SYNC
+#define PR_MTE_TCF_SYNC (1UL << 1)
+#endif
+
+#endif  // OS_LINUX | OS_ANDROID
+
 #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
 #include <Windows.h>
 #include <io.h>
@@ -6832,6 +6855,23 @@ void AlignedFree(void* ptr) {
 #endif
 }
 
+bool IsSyncMemoryTaggingEnabled() {
+#if PERFETTO_BUILDFLAG(PERFETTO_OS_LINUX) || \
+    PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
+  // Compute only once per lifetime of the process.
+  static bool cached_value = [] {
+    const int res = prctl(PR_GET_TAGGED_ADDR_CTRL, 0, 0, 0, 0);
+    if (res < 0)
+      return false;
+    const uint32_t actl = static_cast<uint32_t>(res);
+    return (actl & PR_TAGGED_ADDR_ENABLE) && (actl & PR_MTE_TCF_SYNC);
+  }();
+  return cached_value;
+#else
+  return false;
+#endif
+}
+
 std::string HexDump(const void* data_void, size_t len, size_t bytes_per_line) {
   const char* data = reinterpret_cast<const char*>(data_void);
   std::string res;
@@ -7655,7 +7695,7 @@ void Watchdog::ThreadMain() {
 
     bool threshold_exceeded = false;
     guard.lock();
-    if (CheckMemory_Locked(rss_bytes)) {
+    if (CheckMemory_Locked(rss_bytes) && !IsSyncMemoryTaggingEnabled()) {
       threshold_exceeded = true;
       crash_reason = WatchdogCrashReason::kMemGuardrail;
     } else if (CheckCpu_Locked(cpu_time)) {
@@ -7901,7 +7941,7 @@ class UnixTaskRunner : public TaskRunner {
   void RunFileDescriptorWatch(PlatformHandle);
 
   ThreadChecker thread_checker_;
-  PlatformThreadId created_thread_id_ = GetThreadId();
+  std::atomic<PlatformThreadId> created_thread_id_ = GetThreadId();
 
   EventFd event_;
 
@@ -8223,7 +8263,7 @@ void UnixTaskRunner::WakeUp() {
 
 void UnixTaskRunner::Run() {
   PERFETTO_DCHECK_THREAD(thread_checker_);
-  created_thread_id_ = GetThreadId();
+  created_thread_id_.store(GetThreadId(), std::memory_order_relaxed);
   quit_ = false;
   for (;;) {
     int poll_timeout_ms;
@@ -8470,7 +8510,7 @@ void UnixTaskRunner::RemoveFileDescriptorWatch(PlatformHandle fd) {
 }
 
 bool UnixTaskRunner::RunsTasksOnCurrentThread() const {
-  return GetThreadId() == created_thread_id_;
+  return GetThreadId() == created_thread_id_.load(std::memory_order_relaxed);
 }
 
 }  // namespace base
@@ -16091,7 +16131,8 @@ ProtoLogConfig& ProtoLogConfig::operator=(ProtoLogConfig&&) = default;
 bool ProtoLogConfig::operator==(const ProtoLogConfig& other) const {
   return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
    && ::protozero::internal::gen_helpers::EqualsField(group_overrides_, other.group_overrides_)
-   && ::protozero::internal::gen_helpers::EqualsField(tracing_mode_, other.tracing_mode_);
+   && ::protozero::internal::gen_helpers::EqualsField(tracing_mode_, other.tracing_mode_)
+   && ::protozero::internal::gen_helpers::EqualsField(default_log_from_level_, other.default_log_from_level_);
 }
 
 int ProtoLogConfig::group_overrides_size() const { return static_cast<int>(group_overrides_.size()); }
@@ -16115,6 +16156,9 @@ bool ProtoLogConfig::ParseFromArray(const void* raw, size_t size) {
       case 2 /* tracing_mode */:
         field.get(&tracing_mode_);
         break;
+      case 3 /* default_log_from_level */:
+        field.get(&default_log_from_level_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -16146,6 +16190,11 @@ void ProtoLogConfig::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeVarInt(2, tracing_mode_, msg);
   }
 
+  // Field 3: default_log_from_level
+  if (_has_field_[3]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(3, default_log_from_level_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -16314,6 +16363,92 @@ void SurfaceFlingerTransactionsConfig::Serialize(::protozero::Message* msg) cons
   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/windowmanager_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/windowmanager_config.gen.h"
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+
+WindowManagerConfig::WindowManagerConfig() = default;
+WindowManagerConfig::~WindowManagerConfig() = default;
+WindowManagerConfig::WindowManagerConfig(const WindowManagerConfig&) = default;
+WindowManagerConfig& WindowManagerConfig::operator=(const WindowManagerConfig&) = default;
+WindowManagerConfig::WindowManagerConfig(WindowManagerConfig&&) noexcept = default;
+WindowManagerConfig& WindowManagerConfig::operator=(WindowManagerConfig&&) = default;
+
+bool WindowManagerConfig::operator==(const WindowManagerConfig& other) const {
+  return ::protozero::internal::gen_helpers::EqualsField(unknown_fields_, other.unknown_fields_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_frequency_, other.log_frequency_)
+   && ::protozero::internal::gen_helpers::EqualsField(log_level_, other.log_level_);
+}
+
+bool WindowManagerConfig::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 /* log_frequency */:
+        field.get(&log_frequency_);
+        break;
+      case 2 /* log_level */:
+        field.get(&log_level_);
+        break;
+      default:
+        field.SerializeAndAppendTo(&unknown_fields_);
+        break;
+    }
+  }
+  return !packed_error && !dec.bytes_left();
+}
+
+std::string WindowManagerConfig::SerializeAsString() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsString();
+}
+
+std::vector<uint8_t> WindowManagerConfig::SerializeAsArray() const {
+  ::protozero::internal::gen_helpers::MessageSerializer msg;
+  Serialize(msg.get());
+  return msg.SerializeAsArray();
+}
+
+void WindowManagerConfig::Serialize(::protozero::Message* msg) const {
+  // Field 1: log_frequency
+  if (_has_field_[1]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(1, log_frequency_, msg);
+  }
+
+  // Field 2: log_level
+  if (_has_field_[2]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(2, log_level_, msg);
+  }
+
+  protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
+}
+
 }  // namespace perfetto
 }  // namespace protos
 }  // namespace gen
@@ -16349,6 +16484,7 @@ bool FtraceConfig::operator==(const FtraceConfig& other) const {
    && ::protozero::internal::gen_helpers::EqualsField(ftrace_events_, other.ftrace_events_)
    && ::protozero::internal::gen_helpers::EqualsField(atrace_categories_, other.atrace_categories_)
    && ::protozero::internal::gen_helpers::EqualsField(atrace_apps_, other.atrace_apps_)
+   && ::protozero::internal::gen_helpers::EqualsField(atrace_categories_prefer_sdk_, other.atrace_categories_prefer_sdk_)
    && ::protozero::internal::gen_helpers::EqualsField(buffer_size_kb_, other.buffer_size_kb_)
    && ::protozero::internal::gen_helpers::EqualsField(drain_period_ms_, other.drain_period_ms_)
    && ::protozero::internal::gen_helpers::EqualsField(drain_buffer_percent_, other.drain_buffer_percent_)
@@ -16373,6 +16509,7 @@ bool FtraceConfig::ParseFromArray(const void* raw, size_t size) {
   ftrace_events_.clear();
   atrace_categories_.clear();
   atrace_apps_.clear();
+  atrace_categories_prefer_sdk_.clear();
   syscall_events_.clear();
   function_filters_.clear();
   function_graph_roots_.clear();
@@ -16397,6 +16534,10 @@ bool FtraceConfig::ParseFromArray(const void* raw, size_t size) {
         atrace_apps_.emplace_back();
         ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_apps_.back());
         break;
+      case 28 /* atrace_categories_prefer_sdk */:
+        atrace_categories_prefer_sdk_.emplace_back();
+        ::protozero::internal::gen_helpers::DeserializeString(field, &atrace_categories_prefer_sdk_.back());
+        break;
       case 10 /* buffer_size_kb */:
         field.get(&buffer_size_kb_);
         break;
@@ -16490,6 +16631,11 @@ void FtraceConfig::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeString(3, it, msg);
   }
 
+  // Field 28: atrace_categories_prefer_sdk
+  for (auto& it : atrace_categories_prefer_sdk_) {
+    ::protozero::internal::gen_helpers::SerializeString(28, it, msg);
+  }
+
   // Field 10: buffer_size_kb
   if (_has_field_[10]) {
     ::protozero::internal::gen_helpers::SerializeVarInt(10, buffer_size_kb_, msg);
@@ -18828,7 +18974,9 @@ bool SysStatsConfig::operator==(const SysStatsConfig& other) const {
    && ::protozero::internal::gen_helpers::EqualsField(cpufreq_period_ms_, other.cpufreq_period_ms_)
    && ::protozero::internal::gen_helpers::EqualsField(buddyinfo_period_ms_, other.buddyinfo_period_ms_)
    && ::protozero::internal::gen_helpers::EqualsField(diskstat_period_ms_, other.diskstat_period_ms_)
-   && ::protozero::internal::gen_helpers::EqualsField(psi_period_ms_, other.psi_period_ms_);
+   && ::protozero::internal::gen_helpers::EqualsField(psi_period_ms_, other.psi_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(thermal_period_ms_, other.thermal_period_ms_)
+   && ::protozero::internal::gen_helpers::EqualsField(cpuidle_period_ms_, other.cpuidle_period_ms_);
 }
 
 bool SysStatsConfig::ParseFromArray(const void* raw, size_t size) {
@@ -18880,6 +19028,12 @@ bool SysStatsConfig::ParseFromArray(const void* raw, size_t size) {
       case 11 /* psi_period_ms */:
         field.get(&psi_period_ms_);
         break;
+      case 12 /* thermal_period_ms */:
+        field.get(&thermal_period_ms_);
+        break;
+      case 13 /* cpuidle_period_ms */:
+        field.get(&cpuidle_period_ms_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -18956,6 +19110,16 @@ void SysStatsConfig::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeVarInt(11, psi_period_ms_, msg);
   }
 
+  // Field 12: thermal_period_ms
+  if (_has_field_[12]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(12, thermal_period_ms_, msg);
+  }
+
+  // Field 13: cpuidle_period_ms
+  if (_has_field_[13]) {
+    ::protozero::internal::gen_helpers::SerializeVarInt(13, cpuidle_period_ms_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -19339,6 +19503,7 @@ void ChromeConfig::Serialize(::protozero::Message* msg) const {
 // gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
 // 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"
@@ -20115,6 +20280,7 @@ bool DataSourceConfig::operator==(const DataSourceConfig& other) const {
    && ::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(windowmanager_config_, other.windowmanager_config_)
    && ::protozero::internal::gen_helpers::EqualsField(legacy_config_, other.legacy_config_)
    && ::protozero::internal::gen_helpers::EqualsField(for_testing_, other.for_testing_);
 }
@@ -20240,6 +20406,9 @@ bool DataSourceConfig::ParseFromArray(const void* raw, size_t size) {
       case 129 /* pixel_modem_config */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &pixel_modem_config_);
         break;
+      case 130 /* windowmanager_config */:
+        ::protozero::internal::gen_helpers::DeserializeString(field, &windowmanager_config_);
+        break;
       case 1000 /* legacy_config */:
         ::protozero::internal::gen_helpers::DeserializeString(field, &legacy_config_);
         break;
@@ -20452,6 +20621,11 @@ void DataSourceConfig::Serialize(::protozero::Message* msg) const {
     msg->AppendString(129, pixel_modem_config_);
   }
 
+  // Field 130: windowmanager_config
+  if (_has_field_[130]) {
+    msg->AppendString(130, windowmanager_config_);
+  }
+
   // Field 1000: legacy_config
   if (_has_field_[1000]) {
     ::protozero::internal::gen_helpers::SerializeString(1000, legacy_config_, msg);
@@ -20673,6 +20847,7 @@ void InterceptorConfig::Serialize(::protozero::Message* msg) const {
 // gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
 // 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"
@@ -21263,6 +21438,7 @@ void TestConfig_DummyFields::Serialize(::protozero::Message* msg) const {
 // gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
 // 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"
@@ -24767,7 +24943,9 @@ bool ChromeFrameReporter::operator==(const ChromeFrameReporter& other) const {
    && ::protozero::internal::gen_helpers::EqualsField(layer_tree_host_id_, other.layer_tree_host_id_)
    && ::protozero::internal::gen_helpers::EqualsField(has_high_latency_, other.has_high_latency_)
    && ::protozero::internal::gen_helpers::EqualsField(frame_type_, other.frame_type_)
-   && ::protozero::internal::gen_helpers::EqualsField(high_latency_contribution_stage_, other.high_latency_contribution_stage_);
+   && ::protozero::internal::gen_helpers::EqualsField(high_latency_contribution_stage_, other.high_latency_contribution_stage_)
+   && ::protozero::internal::gen_helpers::EqualsField(checkerboarded_needs_raster_, other.checkerboarded_needs_raster_)
+   && ::protozero::internal::gen_helpers::EqualsField(checkerboarded_needs_record_, other.checkerboarded_needs_record_);
 }
 
 bool ChromeFrameReporter::ParseFromArray(const void* raw, size_t size) {
@@ -24824,6 +25002,12 @@ bool ChromeFrameReporter::ParseFromArray(const void* raw, size_t size) {
         high_latency_contribution_stage_.emplace_back();
         ::protozero::internal::gen_helpers::DeserializeString(field, &high_latency_contribution_stage_.back());
         break;
+      case 15 /* checkerboarded_needs_raster */:
+        field.get(&checkerboarded_needs_raster_);
+        break;
+      case 16 /* checkerboarded_needs_record */:
+        field.get(&checkerboarded_needs_record_);
+        break;
       default:
         field.SerializeAndAppendTo(&unknown_fields_);
         break;
@@ -24915,6 +25099,16 @@ void ChromeFrameReporter::Serialize(::protozero::Message* msg) const {
     ::protozero::internal::gen_helpers::SerializeString(14, it, msg);
   }
 
+  // Field 15: checkerboarded_needs_raster
+  if (_has_field_[15]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(15, checkerboarded_needs_raster_, msg);
+  }
+
+  // Field 16: checkerboarded_needs_record
+  if (_has_field_[16]) {
+    ::protozero::internal::gen_helpers::SerializeTinyVarInt(16, checkerboarded_needs_record_, msg);
+  }
+
   protozero::internal::gen_helpers::SerializeUnknownFields(unknown_fields_, msg);
 }
 
@@ -28770,6 +28964,8 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const {
 // Intentionally empty (crbug.com/998165)
 // gen_amalgamated begin source: gen/protos/perfetto/config/android/surfaceflinger_transactions_config.pbzero.cc
 // Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/config/android/windowmanager_config.pbzero.cc
+// Intentionally empty (crbug.com/998165)
 // gen_amalgamated begin source: gen/protos/perfetto/config/ftrace/ftrace_config.pbzero.cc
 // Intentionally empty (crbug.com/998165)
 // gen_amalgamated begin source: gen/protos/perfetto/config/gpu/gpu_counter_config.pbzero.cc
@@ -28846,6 +29042,8 @@ void TrackEvent_LegacyEvent::Serialize(::protozero::Message* msg) const {
 // Intentionally empty (crbug.com/998165)
 // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/android_fs.pbzero.cc
 // Intentionally empty (crbug.com/998165)
+// gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/bcl_exynos.pbzero.cc
+// Intentionally empty (crbug.com/998165)
 // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/binder.pbzero.cc
 // Intentionally empty (crbug.com/998165)
 // gen_amalgamated begin source: gen/protos/perfetto/trace/ftrace/block.pbzero.cc
@@ -37456,6 +37654,7 @@ TracingMuxerImpl::FindDataSourceRes TracingMuxerImpl::SetupDataSourceImpl(
     internal_state->data_source = rds.factory();
     internal_state->interceptor = nullptr;
     internal_state->interceptor_id = 0;
+    internal_state->will_notify_on_stop = rds.descriptor.will_notify_on_stop();
 
     if (cfg.has_interceptor_config()) {
       for (size_t j = 0; j < interceptors_.size(); j++) {
@@ -37668,6 +37867,7 @@ void TracingMuxerImpl::StopDataSource_AsyncEnd(TracingBackendId backend_id,
   const uint32_t mask = ~(1 << ds.instance_idx);
   ds.static_state->valid_instances.fetch_and(mask, std::memory_order_acq_rel);
 
+  bool will_notify_on_stop;
   // Take the mutex to prevent that the data source is in the middle of
   // a Trace() execution where it called GetDataSourceLocked() while we
   // destroy it.
@@ -37681,6 +37881,7 @@ void TracingMuxerImpl::StopDataSource_AsyncEnd(TracingBackendId backend_id,
     ds.internal_state->interceptor.reset();
     ds.internal_state->config.reset();
     ds.internal_state->async_stop_in_progress = false;
+    will_notify_on_stop = ds.internal_state->will_notify_on_stop;
     startup_buffer_reservation =
         ds.internal_state->startup_target_buffer_reservation.load(
             std::memory_order_relaxed);
@@ -37735,7 +37936,7 @@ void TracingMuxerImpl::StopDataSource_AsyncEnd(TracingBackendId backend_id,
     // Flush any commits that might have been batched by SharedMemoryArbiter.
     producer->service_->MaybeSharedMemoryArbiter()
         ->FlushPendingCommitDataRequests();
-    if (instance_id)
+    if (instance_id && will_notify_on_stop)
       producer->service_->NotifyDataSourceStopped(instance_id);
   }
   producer->SweepDeadServices();
@@ -41048,8 +41249,8 @@ const char* GetVersionCode();
 #ifndef GEN_PERFETTO_VERSION_GEN_H_
 #define GEN_PERFETTO_VERSION_GEN_H_
 
-#define PERFETTO_VERSION_STRING() "v46.0-7114ea53e"
-#define PERFETTO_VERSION_SCM_REVISION() "7114ea53e3297191d34072cd64cf8a7be7076bb6"
+#define PERFETTO_VERSION_STRING() "v47.0-a85300002"
+#define PERFETTO_VERSION_SCM_REVISION() "a853000023857ebd63b4c72802d795ba13a4ff33"
 
 #endif  // GEN_PERFETTO_VERSION_GEN_H_
 /*
@@ -50118,6 +50319,14 @@ void TracingServiceImpl::EmitSystemInfo(std::vector<TracePacket>* packets) {
   } else {
     PERFETTO_ELOG("Unable to read ro.soc.model");
   }
+
+  std::string hw_rev_value = base::GetAndroidProp("ro.boot.hardware.revision");
+  if (!hw_rev_value.empty()) {
+    info->set_android_hardware_revision(hw_rev_value);
+  } else {
+    PERFETTO_ELOG("Unable to read ro.boot.hardware.revision");
+  }
+
 #endif  // PERFETTO_BUILDFLAG(PERFETTO_OS_ANDROID)
   packet->set_trusted_uid(static_cast<int32_t>(uid_));
   packet->set_trusted_packet_sequence_id(kServicePacketSequenceID);
@@ -51461,6 +51670,7 @@ TracingService* InProcessTracingBackend::GetOrCreateService(
 // gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
 // 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"
@@ -53230,6 +53440,7 @@ void EnableTracingRequest::Serialize(::protozero::Message* msg) const {
 // gen_amalgamated expanded: #include "protos/perfetto/config/etw/etw_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/v8_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/chrome/chrome_config.gen.h"
+// gen_amalgamated expanded: #include "protos/perfetto/config/android/windowmanager_config.gen.h"
 // gen_amalgamated expanded: #include "protos/perfetto/config/android/surfaceflinger_transactions_config.gen.h"
 // 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"
@@ -62515,7 +62726,7 @@ void ProducerIPCClientImpl::OnConnect() {
                                   std::move(on_cmd));
 
   // If there are pending Sync() requests, send them now.
-  for (const auto& pending_sync : pending_sync_reqs_)
+  for (auto& pending_sync : pending_sync_reqs_)
     Sync(std::move(pending_sync));
   pending_sync_reqs_.clear();
 }
diff --git a/third_party/perfetto/sdk/perfetto.h b/third_party/perfetto/sdk/perfetto.h
index 972e9dbff547..d93f89c849ac 100644
--- a/third_party/perfetto/sdk/perfetto.h
+++ b/third_party/perfetto/sdk/perfetto.h
@@ -1192,6 +1192,7 @@ struct ContiguousMemoryRange {
 
 #include <assert.h>
 #include <stdint.h>
+#include <string.h>
 
 // gen_amalgamated expanded: #include "perfetto/public/compiler.h"
 
@@ -1334,6 +1335,18 @@ static inline int64_t PerfettoPbZigZagDecode64(uint64_t value) {
   return PERFETTO_STATIC_CAST(int64_t, ((value >> 1) ^ mask));
 }
 
+static inline uint64_t PerfettoPbDoubleToFixed64(double value) {
+  uint64_t val;
+  memcpy(&val, &value, sizeof val);
+  return val;
+}
+
+static inline uint32_t PerfettoPbFloatToFixed32(float value) {
+  uint32_t val;
+  memcpy(&val, &value, sizeof val);
+  return val;
+}
+
 #endif  // INCLUDE_PERFETTO_PUBLIC_PB_UTILS_H_
 /*
  * Copyright (C) 2017 The Android Open Source Project
@@ -2202,6 +2215,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag
     kProtologConfigFieldNumber = 126,
     kAndroidInputEventConfigFieldNumber = 128,
     kPixelModemConfigFieldNumber = 129,
+    kWindowmanagerConfigFieldNumber = 130,
     kLegacyConfigFieldNumber = 1000,
     kForTestingFieldNumber = 1001,
   };
@@ -2342,6 +2356,9 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag
   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); }
 
+  const std::string& windowmanager_config_raw() const { return windowmanager_config_; }
+  void set_windowmanager_config_raw(const std::string& raw) { windowmanager_config_ = raw; _has_field_.set(130); }
+
   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); }
@@ -2388,6 +2405,7 @@ class PERFETTO_EXPORT_COMPONENT DataSourceConfig : public ::protozero::CppMessag
   std::string protolog_config_;  // [lazy=true]
   std::string android_input_event_config_;  // [lazy=true]
   std::string pixel_modem_config_;  // [lazy=true]
+  std::string windowmanager_config_;  // [lazy=true]
   std::string legacy_config_{};
   ::protozero::CopyablePtr<TestConfig> for_testing_;
 
@@ -3257,6 +3275,10 @@ struct DataSourceState {
   // second time.
   bool async_stop_in_progress = false;
 
+  // Whether this data source instance should call NotifyDataSourceStopped()
+  // when it's stopped.
+  bool will_notify_on_stop = false;
+
   // This lock is not held to implement Trace() and it's used only if the trace
   // code wants to access its own data source state.
   // This is to prevent that accessing the data source on an arbitrary embedder
@@ -24051,6 +24073,11 @@ enum MeminfoCounters : int {
   MEMINFO_VMALLOC_CHUNK = 31,
   MEMINFO_CMA_TOTAL = 32,
   MEMINFO_CMA_FREE = 33,
+  MEMINFO_GPU = 34,
+  MEMINFO_ZRAM = 35,
+  MEMINFO_MISC = 36,
+  MEMINFO_ION_HEAP = 37,
+  MEMINFO_ION_HEAP_POOL = 38,
 };
 enum VmstatCounters : int {
   VMSTAT_UNSPECIFIED = 0,
@@ -29579,10 +29606,15 @@ enum MeminfoCounters : int32_t {
   MEMINFO_VMALLOC_CHUNK = 31,
   MEMINFO_CMA_TOTAL = 32,
   MEMINFO_CMA_FREE = 33,
+  MEMINFO_GPU = 34,
+  MEMINFO_ZRAM = 35,
+  MEMINFO_MISC = 36,
+  MEMINFO_ION_HEAP = 37,
+  MEMINFO_ION_HEAP_POOL = 38,
 };
 
 constexpr MeminfoCounters MeminfoCounters_MIN = MeminfoCounters::MEMINFO_UNSPECIFIED;
-constexpr MeminfoCounters MeminfoCounters_MAX = MeminfoCounters::MEMINFO_CMA_FREE;
+constexpr MeminfoCounters MeminfoCounters_MAX = MeminfoCounters::MEMINFO_ION_HEAP_POOL;
 
 
 PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
@@ -29689,6 +29721,21 @@ const char* MeminfoCounters_Name(::perfetto::protos::pbzero::MeminfoCounters val
 
   case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_CMA_FREE:
     return "MEMINFO_CMA_FREE";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_GPU:
+    return "MEMINFO_GPU";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ZRAM:
+    return "MEMINFO_ZRAM";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_MISC:
+    return "MEMINFO_MISC";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ION_HEAP:
+    return "MEMINFO_ION_HEAP";
+
+  case ::perfetto::protos::pbzero::MeminfoCounters::MEMINFO_ION_HEAP_POOL:
+    return "MEMINFO_ION_HEAP_POOL";
   }
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
@@ -33438,6 +33485,7 @@ class PERFETTO_EXPORT_COMPONENT ProtoLogConfig : public ::protozero::CppMessageO
   enum FieldNumbers {
     kGroupOverridesFieldNumber = 1,
     kTracingModeFieldNumber = 2,
+    kDefaultLogFromLevelFieldNumber = 3,
   };
 
   ProtoLogConfig();
@@ -33464,15 +33512,20 @@ class PERFETTO_EXPORT_COMPONENT ProtoLogConfig : public ::protozero::CppMessageO
   ProtoLogConfig_TracingMode tracing_mode() const { return tracing_mode_; }
   void set_tracing_mode(ProtoLogConfig_TracingMode value) { tracing_mode_ = value; _has_field_.set(2); }
 
+  bool has_default_log_from_level() const { return _has_field_[3]; }
+  ProtoLogLevel default_log_from_level() const { return default_log_from_level_; }
+  void set_default_log_from_level(ProtoLogLevel value) { default_log_from_level_ = value; _has_field_.set(3); }
+
  private:
   std::vector<ProtoLogGroup> group_overrides_;
   ProtoLogConfig_TracingMode tracing_mode_{};
+  ProtoLogLevel default_log_from_level_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<3> _has_field_{};
+  std::bitset<4> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -33679,6 +33732,108 @@ class PERFETTO_EXPORT_COMPONENT SurfaceFlingerTransactionsConfig : public ::prot
 }  // namespace gen
 
 #endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_SURFACEFLINGER_TRANSACTIONS_CONFIG_PROTO_CPP_H_
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/windowmanager_config.gen.h
+// DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_CPP_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_CPP_H_
+
+#include <stdint.h>
+#include <bitset>
+#include <vector>
+#include <string>
+#include <type_traits>
+
+// 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 WindowManagerConfig;
+enum WindowManagerConfig_LogFrequency : int;
+enum WindowManagerConfig_LogLevel : int;
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+namespace protozero {
+class Message;
+}  // namespace protozero
+
+namespace perfetto {
+namespace protos {
+namespace gen {
+enum WindowManagerConfig_LogFrequency : int {
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_UNSPECIFIED = 0,
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_FRAME = 1,
+  WindowManagerConfig_LogFrequency_LOG_FREQUENCY_TRANSACTION = 2,
+};
+enum WindowManagerConfig_LogLevel : int {
+  WindowManagerConfig_LogLevel_LOG_LEVEL_UNSPECIFIED = 0,
+  WindowManagerConfig_LogLevel_LOG_LEVEL_VERBOSE = 1,
+  WindowManagerConfig_LogLevel_LOG_LEVEL_DEBUG = 2,
+  WindowManagerConfig_LogLevel_LOG_LEVEL_CRITICAL = 3,
+};
+
+class PERFETTO_EXPORT_COMPONENT WindowManagerConfig : public ::protozero::CppMessageObj {
+ public:
+  using LogFrequency = WindowManagerConfig_LogFrequency;
+  static constexpr auto LOG_FREQUENCY_UNSPECIFIED = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_UNSPECIFIED;
+  static constexpr auto LOG_FREQUENCY_FRAME = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_FRAME;
+  static constexpr auto LOG_FREQUENCY_TRANSACTION = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_TRANSACTION;
+  static constexpr auto LogFrequency_MIN = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_UNSPECIFIED;
+  static constexpr auto LogFrequency_MAX = WindowManagerConfig_LogFrequency_LOG_FREQUENCY_TRANSACTION;
+  using LogLevel = WindowManagerConfig_LogLevel;
+  static constexpr auto LOG_LEVEL_UNSPECIFIED = WindowManagerConfig_LogLevel_LOG_LEVEL_UNSPECIFIED;
+  static constexpr auto LOG_LEVEL_VERBOSE = WindowManagerConfig_LogLevel_LOG_LEVEL_VERBOSE;
+  static constexpr auto LOG_LEVEL_DEBUG = WindowManagerConfig_LogLevel_LOG_LEVEL_DEBUG;
+  static constexpr auto LOG_LEVEL_CRITICAL = WindowManagerConfig_LogLevel_LOG_LEVEL_CRITICAL;
+  static constexpr auto LogLevel_MIN = WindowManagerConfig_LogLevel_LOG_LEVEL_UNSPECIFIED;
+  static constexpr auto LogLevel_MAX = WindowManagerConfig_LogLevel_LOG_LEVEL_CRITICAL;
+  enum FieldNumbers {
+    kLogFrequencyFieldNumber = 1,
+    kLogLevelFieldNumber = 2,
+  };
+
+  WindowManagerConfig();
+  ~WindowManagerConfig() override;
+  WindowManagerConfig(WindowManagerConfig&&) noexcept;
+  WindowManagerConfig& operator=(WindowManagerConfig&&);
+  WindowManagerConfig(const WindowManagerConfig&);
+  WindowManagerConfig& operator=(const WindowManagerConfig&);
+  bool operator==(const WindowManagerConfig&) const;
+  bool operator!=(const WindowManagerConfig& other) const { return !(*this == other); }
+
+  bool ParseFromArray(const void*, size_t) override;
+  std::string SerializeAsString() const override;
+  std::vector<uint8_t> SerializeAsArray() const override;
+  void Serialize(::protozero::Message*) const;
+
+  bool has_log_frequency() const { return _has_field_[1]; }
+  WindowManagerConfig_LogFrequency log_frequency() const { return log_frequency_; }
+  void set_log_frequency(WindowManagerConfig_LogFrequency value) { log_frequency_ = value; _has_field_.set(1); }
+
+  bool has_log_level() const { return _has_field_[2]; }
+  WindowManagerConfig_LogLevel log_level() const { return log_level_; }
+  void set_log_level(WindowManagerConfig_LogLevel value) { log_level_ = value; _has_field_.set(2); }
+
+ private:
+  WindowManagerConfig_LogFrequency log_frequency_{};
+  WindowManagerConfig_LogLevel log_level_{};
+
+  // Allows to preserve unknown protobuf fields for compatibility
+  // with future versions of .proto files.
+  std::string unknown_fields_;
+
+  std::bitset<3> _has_field_{};
+};
+
+}  // namespace perfetto
+}  // namespace protos
+}  // namespace gen
+
+#endif  // PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_CPP_H_
 // gen_amalgamated begin header: gen/protos/perfetto/config/ftrace/ftrace_config.gen.h
 // DO NOT EDIT. Autogenerated by Perfetto cppgen_plugin
 #ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_FTRACE_FTRACE_CONFIG_PROTO_CPP_H_
@@ -33734,6 +33889,7 @@ class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj
     kFtraceEventsFieldNumber = 1,
     kAtraceCategoriesFieldNumber = 2,
     kAtraceAppsFieldNumber = 3,
+    kAtraceCategoriesPreferSdkFieldNumber = 28,
     kBufferSizeKbFieldNumber = 10,
     kDrainPeriodMsFieldNumber = 11,
     kDrainBufferPercentFieldNumber = 26,
@@ -33789,6 +33945,13 @@ class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj
   void add_atrace_apps(std::string value) { atrace_apps_.emplace_back(value); }
   std::string* add_atrace_apps() { atrace_apps_.emplace_back(); return &atrace_apps_.back(); }
 
+  const std::vector<std::string>& atrace_categories_prefer_sdk() const { return atrace_categories_prefer_sdk_; }
+  std::vector<std::string>* mutable_atrace_categories_prefer_sdk() { return &atrace_categories_prefer_sdk_; }
+  int atrace_categories_prefer_sdk_size() const { return static_cast<int>(atrace_categories_prefer_sdk_.size()); }
+  void clear_atrace_categories_prefer_sdk() { atrace_categories_prefer_sdk_.clear(); }
+  void add_atrace_categories_prefer_sdk(std::string value) { atrace_categories_prefer_sdk_.emplace_back(value); }
+  std::string* add_atrace_categories_prefer_sdk() { atrace_categories_prefer_sdk_.emplace_back(); return &atrace_categories_prefer_sdk_.back(); }
+
   bool has_buffer_size_kb() const { return _has_field_[10]; }
   uint32_t buffer_size_kb() const { return buffer_size_kb_; }
   void set_buffer_size_kb(uint32_t value) { buffer_size_kb_ = value; _has_field_.set(10); }
@@ -33874,6 +34037,7 @@ class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj
   std::vector<std::string> ftrace_events_;
   std::vector<std::string> atrace_categories_;
   std::vector<std::string> atrace_apps_;
+  std::vector<std::string> atrace_categories_prefer_sdk_;
   uint32_t buffer_size_kb_{};
   uint32_t drain_period_ms_{};
   uint32_t drain_buffer_percent_{};
@@ -33897,7 +34061,7 @@ class PERFETTO_EXPORT_COMPONENT FtraceConfig : public ::protozero::CppMessageObj
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<28> _has_field_{};
+  std::bitset<29> _has_field_{};
 };
 
 
@@ -36628,6 +36792,8 @@ class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageO
     kBuddyinfoPeriodMsFieldNumber = 9,
     kDiskstatPeriodMsFieldNumber = 10,
     kPsiPeriodMsFieldNumber = 11,
+    kThermalPeriodMsFieldNumber = 12,
+    kCpuidlePeriodMsFieldNumber = 13,
   };
 
   SysStatsConfig();
@@ -36697,6 +36863,14 @@ class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageO
   uint32_t psi_period_ms() const { return psi_period_ms_; }
   void set_psi_period_ms(uint32_t value) { psi_period_ms_ = value; _has_field_.set(11); }
 
+  bool has_thermal_period_ms() const { return _has_field_[12]; }
+  uint32_t thermal_period_ms() const { return thermal_period_ms_; }
+  void set_thermal_period_ms(uint32_t value) { thermal_period_ms_ = value; _has_field_.set(12); }
+
+  bool has_cpuidle_period_ms() const { return _has_field_[13]; }
+  uint32_t cpuidle_period_ms() const { return cpuidle_period_ms_; }
+  void set_cpuidle_period_ms(uint32_t value) { cpuidle_period_ms_ = value; _has_field_.set(13); }
+
  private:
   uint32_t meminfo_period_ms_{};
   std::vector<MeminfoCounters> meminfo_counters_;
@@ -36709,12 +36883,14 @@ class PERFETTO_EXPORT_COMPONENT SysStatsConfig : public ::protozero::CppMessageO
   uint32_t buddyinfo_period_ms_{};
   uint32_t diskstat_period_ms_{};
   uint32_t psi_period_ms_{};
+  uint32_t thermal_period_ms_{};
+  uint32_t cpuidle_period_ms_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<12> _has_field_{};
+  std::bitset<14> _has_field_{};
 };
 
 }  // namespace perfetto
@@ -39325,7 +39501,7 @@ class ProtoLogGroup : public ::protozero::Message {
   }
 };
 
-class ProtoLogConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ProtoLogConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
  public:
   ProtoLogConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ProtoLogConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -39334,6 +39510,8 @@ class ProtoLogConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> group_overrides() const { return GetRepeated<::protozero::ConstBytes>(1); }
   bool has_tracing_mode() const { return at<2>().valid(); }
   int32_t tracing_mode() const { return at<2>().as_int32(); }
+  bool has_default_log_from_level() const { return at<3>().valid(); }
+  int32_t default_log_from_level() const { return at<3>().as_int32(); }
 };
 
 class ProtoLogConfig : public ::protozero::Message {
@@ -39342,6 +39520,7 @@ class ProtoLogConfig : public ::protozero::Message {
   enum : int32_t {
     kGroupOverridesFieldNumber = 1,
     kTracingModeFieldNumber = 2,
+    kDefaultLogFromLevelFieldNumber = 3,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogConfig"; }
 
@@ -39384,6 +39563,24 @@ class ProtoLogConfig : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kEnum>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_DefaultLogFromLevel =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      ProtoLogLevel,
+      ProtoLogConfig>;
+
+  static constexpr FieldMetadata_DefaultLogFromLevel kDefaultLogFromLevel{};
+  void set_default_log_from_level(ProtoLogLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_DefaultLogFromLevel::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);
+  }
 };
 
 } // Namespace.
@@ -39699,6 +39896,181 @@ class SurfaceFlingerTransactionsConfig : public ::protozero::Message {
   }
 };
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/config/android/windowmanager_config.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_CONFIG_ANDROID_WINDOWMANAGER_CONFIG_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// 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_WindowManagerConfig {
+enum LogFrequency : int32_t;
+}  // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogFrequency = perfetto_pbzero_enum_WindowManagerConfig::LogFrequency;
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogLevel : int32_t;
+}  // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogLevel = perfetto_pbzero_enum_WindowManagerConfig::LogLevel;
+} // Namespace pbzero.
+} // Namespace protos.
+} // Namespace perfetto.
+
+namespace perfetto {
+namespace protos {
+namespace pbzero {
+
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogFrequency : int32_t {
+  LOG_FREQUENCY_UNSPECIFIED = 0,
+  LOG_FREQUENCY_FRAME = 1,
+  LOG_FREQUENCY_TRANSACTION = 2,
+};
+} // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogFrequency = perfetto_pbzero_enum_WindowManagerConfig::LogFrequency;
+
+
+constexpr WindowManagerConfig_LogFrequency WindowManagerConfig_LogFrequency_MIN = WindowManagerConfig_LogFrequency::LOG_FREQUENCY_UNSPECIFIED;
+constexpr WindowManagerConfig_LogFrequency WindowManagerConfig_LogFrequency_MAX = WindowManagerConfig_LogFrequency::LOG_FREQUENCY_TRANSACTION;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* WindowManagerConfig_LogFrequency_Name(::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_UNSPECIFIED:
+    return "LOG_FREQUENCY_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_FRAME:
+    return "LOG_FREQUENCY_FRAME";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency::LOG_FREQUENCY_TRANSACTION:
+    return "LOG_FREQUENCY_TRANSACTION";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+namespace perfetto_pbzero_enum_WindowManagerConfig {
+enum LogLevel : int32_t {
+  LOG_LEVEL_UNSPECIFIED = 0,
+  LOG_LEVEL_VERBOSE = 1,
+  LOG_LEVEL_DEBUG = 2,
+  LOG_LEVEL_CRITICAL = 3,
+};
+} // namespace perfetto_pbzero_enum_WindowManagerConfig
+using WindowManagerConfig_LogLevel = perfetto_pbzero_enum_WindowManagerConfig::LogLevel;
+
+
+constexpr WindowManagerConfig_LogLevel WindowManagerConfig_LogLevel_MIN = WindowManagerConfig_LogLevel::LOG_LEVEL_UNSPECIFIED;
+constexpr WindowManagerConfig_LogLevel WindowManagerConfig_LogLevel_MAX = WindowManagerConfig_LogLevel::LOG_LEVEL_CRITICAL;
+
+
+PERFETTO_PROTOZERO_CONSTEXPR14_OR_INLINE
+const char* WindowManagerConfig_LogLevel_Name(::perfetto::protos::pbzero::WindowManagerConfig_LogLevel value) {
+  switch (value) {
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_UNSPECIFIED:
+    return "LOG_LEVEL_UNSPECIFIED";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_VERBOSE:
+    return "LOG_LEVEL_VERBOSE";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_DEBUG:
+    return "LOG_LEVEL_DEBUG";
+
+  case ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel::LOG_LEVEL_CRITICAL:
+    return "LOG_LEVEL_CRITICAL";
+  }
+  return "PBZERO_UNKNOWN_ENUM_VALUE";
+}
+
+class WindowManagerConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  WindowManagerConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit WindowManagerConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit WindowManagerConfig_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_log_frequency() const { return at<1>().valid(); }
+  int32_t log_frequency() const { return at<1>().as_int32(); }
+  bool has_log_level() const { return at<2>().valid(); }
+  int32_t log_level() const { return at<2>().as_int32(); }
+};
+
+class WindowManagerConfig : public ::protozero::Message {
+ public:
+  using Decoder = WindowManagerConfig_Decoder;
+  enum : int32_t {
+    kLogFrequencyFieldNumber = 1,
+    kLogLevelFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.WindowManagerConfig"; }
+
+
+  using LogFrequency = ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency;
+  static inline const char* LogFrequency_Name(LogFrequency value) {
+    return ::perfetto::protos::pbzero::WindowManagerConfig_LogFrequency_Name(value);
+  }
+
+  using LogLevel = ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel;
+  static inline const char* LogLevel_Name(LogLevel value) {
+    return ::perfetto::protos::pbzero::WindowManagerConfig_LogLevel_Name(value);
+  }
+  static inline const LogFrequency LOG_FREQUENCY_UNSPECIFIED = LogFrequency::LOG_FREQUENCY_UNSPECIFIED;
+  static inline const LogFrequency LOG_FREQUENCY_FRAME = LogFrequency::LOG_FREQUENCY_FRAME;
+  static inline const LogFrequency LOG_FREQUENCY_TRANSACTION = LogFrequency::LOG_FREQUENCY_TRANSACTION;
+  static inline const LogLevel LOG_LEVEL_UNSPECIFIED = LogLevel::LOG_LEVEL_UNSPECIFIED;
+  static inline const LogLevel LOG_LEVEL_VERBOSE = LogLevel::LOG_LEVEL_VERBOSE;
+  static inline const LogLevel LOG_LEVEL_DEBUG = LogLevel::LOG_LEVEL_DEBUG;
+  static inline const LogLevel LOG_LEVEL_CRITICAL = LogLevel::LOG_LEVEL_CRITICAL;
+
+  using FieldMetadata_LogFrequency =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      WindowManagerConfig_LogFrequency,
+      WindowManagerConfig>;
+
+  static constexpr FieldMetadata_LogFrequency kLogFrequency{};
+  void set_log_frequency(WindowManagerConfig_LogFrequency value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogFrequency::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_LogLevel =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kEnum,
+      WindowManagerConfig_LogLevel,
+      WindowManagerConfig>;
+
+  static constexpr FieldMetadata_LogLevel kLogLevel{};
+  void set_log_level(WindowManagerConfig_LogLevel value) {
+    static constexpr uint32_t field_id = FieldMetadata_LogLevel::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);
+  }
+};
+
 } // Namespace.
 } // Namespace.
 } // Namespace.
@@ -39766,7 +40138,7 @@ const char* FtraceConfig_KsymsMemPolicy_Name(::perfetto::protos::pbzero::FtraceC
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class FtraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/27, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class FtraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/28, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
  public:
   FtraceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -39777,6 +40149,8 @@ class FtraceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_I
   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_categories() const { return GetRepeated<::protozero::ConstChars>(2); }
   bool has_atrace_apps() const { return at<3>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_apps() const { return GetRepeated<::protozero::ConstChars>(3); }
+  bool has_atrace_categories_prefer_sdk() const { return at<28>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstChars> atrace_categories_prefer_sdk() const { return GetRepeated<::protozero::ConstChars>(28); }
   bool has_buffer_size_kb() const { return at<10>().valid(); }
   uint32_t buffer_size_kb() const { return at<10>().as_uint32(); }
   bool has_drain_period_ms() const { return at<11>().valid(); }
@@ -39822,6 +40196,7 @@ class FtraceConfig : public ::protozero::Message {
     kFtraceEventsFieldNumber = 1,
     kAtraceCategoriesFieldNumber = 2,
     kAtraceAppsFieldNumber = 3,
+    kAtraceCategoriesPreferSdkFieldNumber = 28,
     kBufferSizeKbFieldNumber = 10,
     kDrainPeriodMsFieldNumber = 11,
     kDrainBufferPercentFieldNumber = 26,
@@ -39926,6 +40301,30 @@ class FtraceConfig : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_AtraceCategoriesPreferSdk =
+    ::protozero::proto_utils::FieldMetadata<
+      28,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      FtraceConfig>;
+
+  static constexpr FieldMetadata_AtraceCategoriesPreferSdk kAtraceCategoriesPreferSdk{};
+  void add_atrace_categories_prefer_sdk(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AtraceCategoriesPreferSdk::kFieldId, data, size);
+  }
+  void add_atrace_categories_prefer_sdk(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AtraceCategoriesPreferSdk::kFieldId, chars.data, chars.size);
+  }
+  void add_atrace_categories_prefer_sdk(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AtraceCategoriesPreferSdk::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_BufferSizeKb =
     ::protozero::proto_utils::FieldMetadata<
       10,
@@ -47038,7 +47437,7 @@ const char* SysStatsConfig_StatCounters_Name(::perfetto::protos::pbzero::SysStat
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class SysStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/11, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SysStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
  public:
   SysStatsConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit SysStatsConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -47065,6 +47464,10 @@ class SysStatsConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD
   uint32_t diskstat_period_ms() const { return at<10>().as_uint32(); }
   bool has_psi_period_ms() const { return at<11>().valid(); }
   uint32_t psi_period_ms() const { return at<11>().as_uint32(); }
+  bool has_thermal_period_ms() const { return at<12>().valid(); }
+  uint32_t thermal_period_ms() const { return at<12>().as_uint32(); }
+  bool has_cpuidle_period_ms() const { return at<13>().valid(); }
+  uint32_t cpuidle_period_ms() const { return at<13>().as_uint32(); }
 };
 
 class SysStatsConfig : public ::protozero::Message {
@@ -47082,6 +47485,8 @@ class SysStatsConfig : public ::protozero::Message {
     kBuddyinfoPeriodMsFieldNumber = 9,
     kDiskstatPeriodMsFieldNumber = 10,
     kPsiPeriodMsFieldNumber = 11,
+    kThermalPeriodMsFieldNumber = 12,
+    kCpuidlePeriodMsFieldNumber = 13,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.SysStatsConfig"; }
 
@@ -47293,6 +47698,42 @@ class SysStatsConfig : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_ThermalPeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
+
+  static constexpr FieldMetadata_ThermalPeriodMs kThermalPeriodMs{};
+  void set_thermal_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_ThermalPeriodMs::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_CpuidlePeriodMs =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStatsConfig>;
+
+  static constexpr FieldMetadata_CpuidlePeriodMs kCpuidlePeriodMs{};
+  void set_cpuidle_period_ms(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuidlePeriodMs::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.
@@ -48577,6 +49018,7 @@ class TestConfig;
 class TrackEventConfig;
 class V8Config;
 class VulkanMemoryConfig;
+class WindowManagerConfig;
 namespace perfetto_pbzero_enum_DataSourceConfig {
 enum SessionInitiator : int32_t;
 }  // namespace perfetto_pbzero_enum_DataSourceConfig
@@ -48614,7 +49056,7 @@ const char* DataSourceConfig_SessionInitiator_Name(::perfetto::protos::pbzero::D
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/129, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/130, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
  public:
   DataSourceConfig_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit DataSourceConfig_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -48693,6 +49135,8 @@ class DataSourceConfig_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIE
   ::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(); }
+  bool has_windowmanager_config() const { return at<130>().valid(); }
+  ::protozero::ConstBytes windowmanager_config() const { return at<130>().as_bytes(); }
   // field legacy_config omitted because its id is too high
   // field for_testing omitted because its id is too high
 };
@@ -48738,6 +49182,7 @@ class DataSourceConfig : public ::protozero::Message {
     kProtologConfigFieldNumber = 126,
     kAndroidInputEventConfigFieldNumber = 128,
     kPixelModemConfigFieldNumber = 129,
+    kWindowmanagerConfigFieldNumber = 130,
     kLegacyConfigFieldNumber = 1000,
     kForTestingFieldNumber = 1001,
   };
@@ -49411,6 +49856,24 @@ class DataSourceConfig : public ::protozero::Message {
   }
 
 
+  using FieldMetadata_WindowmanagerConfig =
+    ::protozero::proto_utils::FieldMetadata<
+      130,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      WindowManagerConfig,
+      DataSourceConfig>;
+
+  static constexpr FieldMetadata_WindowmanagerConfig kWindowmanagerConfig{};
+  template <typename T = WindowManagerConfig> T* set_windowmanager_config() {
+    return BeginNestedMessage<T>(130);
+  }
+
+  void set_windowmanager_config_raw(const std::string& raw) {
+    return AppendBytes(130, raw.data(), raw.size());
+  }
+
+
   using FieldMetadata_LegacyConfig =
     ::protozero::proto_utils::FieldMetadata<
       1000,
@@ -53508,7 +53971,7 @@ namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/10, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
  public:
   SystemInfo_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit SystemInfo_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -53519,6 +53982,8 @@ class SystemInfo_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=
   ::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_android_hardware_revision() const { return at<10>().valid(); }
+  ::protozero::ConstChars android_hardware_revision() const { return at<10>().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(); }
@@ -53540,6 +54005,7 @@ class SystemInfo : public ::protozero::Message {
     kUtsnameFieldNumber = 1,
     kAndroidBuildFingerprintFieldNumber = 2,
     kAndroidSocModelFieldNumber = 9,
+    kAndroidHardwareRevisionFieldNumber = 10,
     kTracingServiceVersionFieldNumber = 4,
     kAndroidSdkVersionFieldNumber = 5,
     kPageSizeFieldNumber = 6,
@@ -53612,6 +54078,30 @@ class SystemInfo : public ::protozero::Message {
         ::Append(*this, field_id, value);
   }
 
+  using FieldMetadata_AndroidHardwareRevision =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SystemInfo>;
+
+  static constexpr FieldMetadata_AndroidHardwareRevision kAndroidHardwareRevision{};
+  void set_android_hardware_revision(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_AndroidHardwareRevision::kFieldId, data, size);
+  }
+  void set_android_hardware_revision(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_AndroidHardwareRevision::kFieldId, chars.data, chars.size);
+  }
+  void set_android_hardware_revision(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_AndroidHardwareRevision::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,
@@ -54081,7 +54571,7 @@ namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class WinscopeExtensions_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class WinscopeExtensions_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
  public:
   WinscopeExtensions_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit WinscopeExtensions_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -54271,7 +54761,7 @@ class ProtoLogViewerConfig_Group : public ::protozero::Message {
   }
 };
 
-class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
  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<const uint8_t*>(raw.data()), raw.size()) {}
@@ -54284,6 +54774,8 @@ class ProtoLogViewerConfig_MessageData_Decoder : public ::protozero::TypedProtoD
   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(); }
+  bool has_location() const { return at<5>().valid(); }
+  ::protozero::ConstChars location() const { return at<5>().as_string(); }
 };
 
 class ProtoLogViewerConfig_MessageData : public ::protozero::Message {
@@ -54294,6 +54786,7 @@ class ProtoLogViewerConfig_MessageData : public ::protozero::Message {
     kMessageFieldNumber = 2,
     kLevelFieldNumber = 3,
     kGroupIdFieldNumber = 4,
+    kLocationFieldNumber = 5,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.ProtoLogViewerConfig.MessageData"; }
 
@@ -54375,6 +54868,30 @@ class ProtoLogViewerConfig_MessageData : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Location =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      ProtoLogViewerConfig_MessageData>;
+
+  static constexpr FieldMetadata_Location kLocation{};
+  void set_location(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_Location::kFieldId, data, size);
+  }
+  void set_location(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_Location::kFieldId, chars.data, chars.size);
+  }
+  void set_location(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_Location::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 ProtoLogMessage_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/6, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
@@ -71679,6 +72196,7 @@ class AndroidFsDatawriteEndFtraceEvent;
 class AndroidFsDatawriteStartFtraceEvent;
 class AndroidFsFsyncEndFtraceEvent;
 class AndroidFsFsyncStartFtraceEvent;
+class BclIrqTriggerFtraceEvent;
 class BinderCommandFtraceEvent;
 class BinderLockFtraceEvent;
 class BinderLockedFtraceEvent;
@@ -71945,6 +72463,10 @@ class IrqHandlerEntryFtraceEvent;
 class IrqHandlerExitFtraceEvent;
 class KfreeFtraceEvent;
 class KfreeSkbFtraceEvent;
+class KgslAdrenoCmdbatchQueuedFtraceEvent;
+class KgslAdrenoCmdbatchRetiredFtraceEvent;
+class KgslAdrenoCmdbatchSubmittedFtraceEvent;
+class KgslAdrenoCmdbatchSyncFtraceEvent;
 class KgslGpuFrequencyFtraceEvent;
 class KmallocFtraceEvent;
 class KmallocNodeFtraceEvent;
@@ -72186,7 +72708,7 @@ namespace perfetto {
 namespace protos {
 namespace pbzero {
 
-class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/532, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/537, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
  public:
   FtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit FtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -73219,6 +73741,16 @@ class FtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   ::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(); }
+  bool has_bcl_irq_trigger() const { return at<533>().valid(); }
+  ::protozero::ConstBytes bcl_irq_trigger() const { return at<533>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_queued() const { return at<534>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_queued() const { return at<534>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_submitted() const { return at<535>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_submitted() const { return at<535>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_sync() const { return at<536>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_sync() const { return at<536>().as_bytes(); }
+  bool has_kgsl_adreno_cmdbatch_retired() const { return at<537>().valid(); }
+  ::protozero::ConstBytes kgsl_adreno_cmdbatch_retired() const { return at<537>().as_bytes(); }
 };
 
 class FtraceEvent : public ::protozero::Message {
@@ -73739,6 +74271,11 @@ class FtraceEvent : public ::protozero::Message {
     kMaliMaliPMMCUPENDONRELOADFieldNumber = 530,
     kMaliMaliPMMCUPOWERDOWNFieldNumber = 531,
     kMaliMaliPMMCURESETWAITFieldNumber = 532,
+    kBclIrqTriggerFieldNumber = 533,
+    kKgslAdrenoCmdbatchQueuedFieldNumber = 534,
+    kKgslAdrenoCmdbatchSubmittedFieldNumber = 535,
+    kKgslAdrenoCmdbatchSyncFieldNumber = 536,
+    kKgslAdrenoCmdbatchRetiredFieldNumber = 537,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.FtraceEvent"; }
 
@@ -80950,6 +81487,76 @@ class FtraceEvent : public ::protozero::Message {
     return BeginNestedMessage<T>(532);
   }
 
+
+  using FieldMetadata_BclIrqTrigger =
+    ::protozero::proto_utils::FieldMetadata<
+      533,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      BclIrqTriggerFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_BclIrqTrigger kBclIrqTrigger{};
+  template <typename T = BclIrqTriggerFtraceEvent> T* set_bcl_irq_trigger() {
+    return BeginNestedMessage<T>(533);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchQueued =
+    ::protozero::proto_utils::FieldMetadata<
+      534,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchQueuedFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchQueued kKgslAdrenoCmdbatchQueued{};
+  template <typename T = KgslAdrenoCmdbatchQueuedFtraceEvent> T* set_kgsl_adreno_cmdbatch_queued() {
+    return BeginNestedMessage<T>(534);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchSubmitted =
+    ::protozero::proto_utils::FieldMetadata<
+      535,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchSubmitted kKgslAdrenoCmdbatchSubmitted{};
+  template <typename T = KgslAdrenoCmdbatchSubmittedFtraceEvent> T* set_kgsl_adreno_cmdbatch_submitted() {
+    return BeginNestedMessage<T>(535);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchSync =
+    ::protozero::proto_utils::FieldMetadata<
+      536,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchSyncFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchSync kKgslAdrenoCmdbatchSync{};
+  template <typename T = KgslAdrenoCmdbatchSyncFtraceEvent> T* set_kgsl_adreno_cmdbatch_sync() {
+    return BeginNestedMessage<T>(536);
+  }
+
+
+  using FieldMetadata_KgslAdrenoCmdbatchRetired =
+    ::protozero::proto_utils::FieldMetadata<
+      537,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      KgslAdrenoCmdbatchRetiredFtraceEvent,
+      FtraceEvent>;
+
+  static constexpr FieldMetadata_KgslAdrenoCmdbatchRetired kKgslAdrenoCmdbatchRetired{};
+  template <typename T = KgslAdrenoCmdbatchRetiredFtraceEvent> T* set_kgsl_adreno_cmdbatch_retired() {
+    return BeginNestedMessage<T>(537);
+  }
+
 };
 
 } // Namespace.
@@ -83151,6 +83758,235 @@ class AndroidFsDatareadEndFtraceEvent : public ::protozero::Message {
   }
 };
 
+} // Namespace.
+} // Namespace.
+} // Namespace.
+#endif  // Include guard.
+// gen_amalgamated begin header: gen/protos/perfetto/trace/ftrace/bcl_exynos.pbzero.h
+// Autogenerated by the ProtoZero compiler plugin. DO NOT EDIT.
+
+#ifndef PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_BCL_EXYNOS_PROTO_H_
+#define PERFETTO_PROTOS_PROTOS_PERFETTO_TRACE_FTRACE_BCL_EXYNOS_PROTO_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// 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 BclIrqTriggerFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/9, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  BclIrqTriggerFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit BclIrqTriggerFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit BclIrqTriggerFtraceEvent_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_throttle() const { return at<2>().valid(); }
+  int32_t throttle() const { return at<2>().as_int32(); }
+  bool has_cpu0_limit() const { return at<3>().valid(); }
+  int32_t cpu0_limit() const { return at<3>().as_int32(); }
+  bool has_cpu1_limit() const { return at<4>().valid(); }
+  int32_t cpu1_limit() const { return at<4>().as_int32(); }
+  bool has_cpu2_limit() const { return at<5>().valid(); }
+  int32_t cpu2_limit() const { return at<5>().as_int32(); }
+  bool has_tpu_limit() const { return at<6>().valid(); }
+  int32_t tpu_limit() const { return at<6>().as_int32(); }
+  bool has_gpu_limit() const { return at<7>().valid(); }
+  int32_t gpu_limit() const { return at<7>().as_int32(); }
+  bool has_voltage() const { return at<8>().valid(); }
+  int32_t voltage() const { return at<8>().as_int32(); }
+  bool has_capacity() const { return at<9>().valid(); }
+  int32_t capacity() const { return at<9>().as_int32(); }
+};
+
+class BclIrqTriggerFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = BclIrqTriggerFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kThrottleFieldNumber = 2,
+    kCpu0LimitFieldNumber = 3,
+    kCpu1LimitFieldNumber = 4,
+    kCpu2LimitFieldNumber = 5,
+    kTpuLimitFieldNumber = 6,
+    kGpuLimitFieldNumber = 7,
+    kVoltageFieldNumber = 8,
+    kCapacityFieldNumber = 9,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.BclIrqTriggerFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  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_Throttle =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Throttle kThrottle{};
+  void set_throttle(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Throttle::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_Cpu0Limit =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu0Limit kCpu0Limit{};
+  void set_cpu0_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu0Limit::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_Cpu1Limit =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu1Limit kCpu1Limit{};
+  void set_cpu1_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu1Limit::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_Cpu2Limit =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Cpu2Limit kCpu2Limit{};
+  void set_cpu2_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Cpu2Limit::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_TpuLimit =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_TpuLimit kTpuLimit{};
+  void set_tpu_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_TpuLimit::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_GpuLimit =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_GpuLimit kGpuLimit{};
+  void set_gpu_limit(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_GpuLimit::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_Voltage =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Voltage kVoltage{};
+  void set_voltage(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Voltage::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_Capacity =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      BclIrqTriggerFtraceEvent>;
+
+  static constexpr FieldMetadata_Capacity kCapacity{};
+  void set_capacity(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Capacity::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.
@@ -113537,6 +114373,889 @@ namespace perfetto {
 namespace protos {
 namespace pbzero {
 
+class KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/17, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchRetiredFtraceEvent_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_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_inflight() const { return at<3>().valid(); }
+  int64_t inflight() const { return at<3>().as_int64(); }
+  bool has_recovery() const { return at<4>().valid(); }
+  uint32_t recovery() const { return at<4>().as_uint32(); }
+  bool has_flags() const { return at<5>().valid(); }
+  uint32_t flags() const { return at<5>().as_uint32(); }
+  bool has_start() const { return at<6>().valid(); }
+  uint64_t start() const { return at<6>().as_uint64(); }
+  bool has_retire() const { return at<7>().valid(); }
+  uint64_t retire() const { return at<7>().as_uint64(); }
+  bool has_prio() const { return at<8>().valid(); }
+  int32_t prio() const { return at<8>().as_int32(); }
+  bool has_rb_id() const { return at<9>().valid(); }
+  int32_t rb_id() const { return at<9>().as_int32(); }
+  bool has_rptr() const { return at<10>().valid(); }
+  uint32_t rptr() const { return at<10>().as_uint32(); }
+  bool has_wptr() const { return at<11>().valid(); }
+  uint32_t wptr() const { return at<11>().as_uint32(); }
+  bool has_q_inflight() const { return at<12>().valid(); }
+  int32_t q_inflight() const { return at<12>().as_int32(); }
+  bool has_fault_recovery() const { return at<13>().valid(); }
+  uint64_t fault_recovery() const { return at<13>().as_uint64(); }
+  bool has_dispatch_queue() const { return at<14>().valid(); }
+  uint32_t dispatch_queue() const { return at<14>().as_uint32(); }
+  bool has_submitted_to_rb() const { return at<15>().valid(); }
+  uint64_t submitted_to_rb() const { return at<15>().as_uint64(); }
+  bool has_retired_on_gmu() const { return at<16>().valid(); }
+  uint64_t retired_on_gmu() const { return at<16>().as_uint64(); }
+  bool has_active() const { return at<17>().valid(); }
+  uint64_t active() const { return at<17>().as_uint64(); }
+};
+
+class KgslAdrenoCmdbatchRetiredFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslAdrenoCmdbatchRetiredFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kInflightFieldNumber = 3,
+    kRecoveryFieldNumber = 4,
+    kFlagsFieldNumber = 5,
+    kStartFieldNumber = 6,
+    kRetireFieldNumber = 7,
+    kPrioFieldNumber = 8,
+    kRbIdFieldNumber = 9,
+    kRptrFieldNumber = 10,
+    kWptrFieldNumber = 11,
+    kQInflightFieldNumber = 12,
+    kFaultRecoveryFieldNumber = 13,
+    kDispatchQueueFieldNumber = 14,
+    kSubmittedToRbFieldNumber = 15,
+    kRetiredOnGmuFieldNumber = 16,
+    kActiveFieldNumber = 17,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  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_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_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::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Inflight =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Inflight kInflight{};
+  void set_inflight(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Inflight::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_Recovery =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Recovery kRecovery{};
+  void set_recovery(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Recovery::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<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  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_Start =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Start kStart{};
+  void set_start(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Start::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_Retire =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Retire kRetire{};
+  void set_retire(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Retire::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_Prio =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::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_RbId =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_RbId kRbId{};
+  void set_rb_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RbId::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_Rptr =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Rptr kRptr{};
+  void set_rptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rptr::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_Wptr =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Wptr kWptr{};
+  void set_wptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wptr::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_QInflight =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_QInflight kQInflight{};
+  void set_q_inflight(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QInflight::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_FaultRecovery =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_FaultRecovery kFaultRecovery{};
+  void set_fault_recovery(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_FaultRecovery::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_DispatchQueue =
+    ::protozero::proto_utils::FieldMetadata<
+      14,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_DispatchQueue kDispatchQueue{};
+  void set_dispatch_queue(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DispatchQueue::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_SubmittedToRb =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_SubmittedToRb kSubmittedToRb{};
+  void set_submitted_to_rb(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_SubmittedToRb::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_RetiredOnGmu =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_RetiredOnGmu kRetiredOnGmu{};
+  void set_retired_on_gmu(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RetiredOnGmu::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_Active =
+    ::protozero::proto_utils::FieldMetadata<
+      17,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchRetiredFtraceEvent>;
+
+  static constexpr FieldMetadata_Active kActive{};
+  void set_active(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Active::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 KgslAdrenoCmdbatchSyncFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/4, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  KgslAdrenoCmdbatchSyncFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchSyncFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchSyncFtraceEvent_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_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_ticks() const { return at<3>().valid(); }
+  uint64_t ticks() const { return at<3>().as_uint64(); }
+  bool has_prio() const { return at<4>().valid(); }
+  int32_t prio() const { return at<4>().as_int32(); }
+};
+
+class KgslAdrenoCmdbatchSyncFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslAdrenoCmdbatchSyncFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kTicksFieldNumber = 3,
+    kPrioFieldNumber = 4,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
+
+  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_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_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::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Ticks =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
+
+  static constexpr FieldMetadata_Ticks kTicks{};
+  void set_ticks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ticks::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_Prio =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSyncFtraceEvent>;
+
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::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 KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/13, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchSubmittedFtraceEvent_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_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_inflight() const { return at<3>().valid(); }
+  int64_t inflight() const { return at<3>().as_int64(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_ticks() const { return at<5>().valid(); }
+  uint64_t ticks() const { return at<5>().as_uint64(); }
+  bool has_secs() const { return at<6>().valid(); }
+  uint64_t secs() const { return at<6>().as_uint64(); }
+  bool has_usecs() const { return at<7>().valid(); }
+  uint64_t usecs() const { return at<7>().as_uint64(); }
+  bool has_prio() const { return at<8>().valid(); }
+  int32_t prio() const { return at<8>().as_int32(); }
+  bool has_rb_id() const { return at<9>().valid(); }
+  int32_t rb_id() const { return at<9>().as_int32(); }
+  bool has_rptr() const { return at<10>().valid(); }
+  uint32_t rptr() const { return at<10>().as_uint32(); }
+  bool has_wptr() const { return at<11>().valid(); }
+  uint32_t wptr() const { return at<11>().as_uint32(); }
+  bool has_q_inflight() const { return at<12>().valid(); }
+  int32_t q_inflight() const { return at<12>().as_int32(); }
+  bool has_dispatch_queue() const { return at<13>().valid(); }
+  int32_t dispatch_queue() const { return at<13>().as_int32(); }
+};
+
+class KgslAdrenoCmdbatchSubmittedFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslAdrenoCmdbatchSubmittedFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kInflightFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kTicksFieldNumber = 5,
+    kSecsFieldNumber = 6,
+    kUsecsFieldNumber = 7,
+    kPrioFieldNumber = 8,
+    kRbIdFieldNumber = 9,
+    kRptrFieldNumber = 10,
+    kWptrFieldNumber = 11,
+    kQInflightFieldNumber = 12,
+    kDispatchQueueFieldNumber = 13,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  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_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_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::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Inflight =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt64,
+      int64_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Inflight kInflight{};
+  void set_inflight(int64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Inflight::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_Flags =
+    ::protozero::proto_utils::FieldMetadata<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  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_Ticks =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Ticks kTicks{};
+  void set_ticks(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Ticks::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_Secs =
+    ::protozero::proto_utils::FieldMetadata<
+      6,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Secs kSecs{};
+  void set_secs(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Secs::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_Usecs =
+    ::protozero::proto_utils::FieldMetadata<
+      7,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Usecs kUsecs{};
+  void set_usecs(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Usecs::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_Prio =
+    ::protozero::proto_utils::FieldMetadata<
+      8,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::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_RbId =
+    ::protozero::proto_utils::FieldMetadata<
+      9,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_RbId kRbId{};
+  void set_rb_id(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_RbId::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_Rptr =
+    ::protozero::proto_utils::FieldMetadata<
+      10,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Rptr kRptr{};
+  void set_rptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Rptr::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_Wptr =
+    ::protozero::proto_utils::FieldMetadata<
+      11,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_Wptr kWptr{};
+  void set_wptr(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Wptr::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_QInflight =
+    ::protozero::proto_utils::FieldMetadata<
+      12,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_QInflight kQInflight{};
+  void set_q_inflight(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_QInflight::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_DispatchQueue =
+    ::protozero::proto_utils::FieldMetadata<
+      13,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kInt32,
+      int32_t,
+      KgslAdrenoCmdbatchSubmittedFtraceEvent>;
+
+  static constexpr FieldMetadata_DispatchQueue kDispatchQueue{};
+  void set_dispatch_queue(int32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DispatchQueue::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 KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/5, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit KgslAdrenoCmdbatchQueuedFtraceEvent_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_timestamp() const { return at<2>().valid(); }
+  uint32_t timestamp() const { return at<2>().as_uint32(); }
+  bool has_queued() const { return at<3>().valid(); }
+  uint32_t queued() const { return at<3>().as_uint32(); }
+  bool has_flags() const { return at<4>().valid(); }
+  uint32_t flags() const { return at<4>().as_uint32(); }
+  bool has_prio() const { return at<5>().valid(); }
+  uint32_t prio() const { return at<5>().as_uint32(); }
+};
+
+class KgslAdrenoCmdbatchQueuedFtraceEvent : public ::protozero::Message {
+ public:
+  using Decoder = KgslAdrenoCmdbatchQueuedFtraceEvent_Decoder;
+  enum : int32_t {
+    kIdFieldNumber = 1,
+    kTimestampFieldNumber = 2,
+    kQueuedFieldNumber = 3,
+    kFlagsFieldNumber = 4,
+    kPrioFieldNumber = 5,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent"; }
+
+
+  using FieldMetadata_Id =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
+
+  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_Timestamp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
+
+  static constexpr FieldMetadata_Timestamp kTimestamp{};
+  void set_timestamp(uint32_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::kUint32>
+        ::Append(*this, field_id, value);
+  }
+
+  using FieldMetadata_Queued =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
+
+  static constexpr FieldMetadata_Queued kQueued{};
+  void set_queued(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Queued::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<
+      4,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
+
+  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_Prio =
+    ::protozero::proto_utils::FieldMetadata<
+      5,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      KgslAdrenoCmdbatchQueuedFtraceEvent>;
+
+  static constexpr FieldMetadata_Prio kPrio{};
+  void set_prio(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Prio::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 KgslGpuFrequencyFtraceEvent_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
  public:
   KgslGpuFrequencyFtraceEvent_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
@@ -149980,7 +151699,7 @@ const char* ChromeFrameReporter_FrameType_Name(::perfetto::protos::pbzero::Chrom
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class ChromeFrameReporter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class ChromeFrameReporter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
  public:
   ChromeFrameReporter_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit ChromeFrameReporter_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -150013,6 +151732,10 @@ class ChromeFrameReporter_Decoder : public ::protozero::TypedProtoDecoder</*MAX_
   int32_t frame_type() const { return at<13>().as_int32(); }
   bool has_high_latency_contribution_stage() const { return at<14>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstChars> high_latency_contribution_stage() const { return GetRepeated<::protozero::ConstChars>(14); }
+  bool has_checkerboarded_needs_raster() const { return at<15>().valid(); }
+  bool checkerboarded_needs_raster() const { return at<15>().as_bool(); }
+  bool has_checkerboarded_needs_record() const { return at<16>().valid(); }
+  bool checkerboarded_needs_record() const { return at<16>().as_bool(); }
 };
 
 class ChromeFrameReporter : public ::protozero::Message {
@@ -150033,6 +151756,8 @@ class ChromeFrameReporter : public ::protozero::Message {
     kHasHighLatencyFieldNumber = 12,
     kFrameTypeFieldNumber = 13,
     kHighLatencyContributionStageFieldNumber = 14,
+    kCheckerboardedNeedsRasterFieldNumber = 15,
+    kCheckerboardedNeedsRecordFieldNumber = 16,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.ChromeFrameReporter"; }
 
@@ -150328,6 +152053,42 @@ class ChromeFrameReporter : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kString>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_CheckerboardedNeedsRaster =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
+
+  static constexpr FieldMetadata_CheckerboardedNeedsRaster kCheckerboardedNeedsRaster{};
+  void set_checkerboarded_needs_raster(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CheckerboardedNeedsRaster::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_CheckerboardedNeedsRecord =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kBool,
+      bool,
+      ChromeFrameReporter>;
+
+  static constexpr FieldMetadata_CheckerboardedNeedsRecord kCheckerboardedNeedsRecord{};
+  void set_checkerboarded_needs_record(bool value) {
+    static constexpr uint32_t field_id = FieldMetadata_CheckerboardedNeedsRecord::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);
+  }
 };
 
 } // Namespace.
@@ -156760,12 +158521,15 @@ namespace perfetto {
 namespace protos {
 namespace pbzero {
 class SysStats_BuddyInfo;
+class SysStats_CpuIdleState;
+class SysStats_CpuIdleStateEntry;
 class SysStats_CpuTimes;
 class SysStats_DevfreqValue;
 class SysStats_DiskStat;
 class SysStats_InterruptCount;
 class SysStats_MeminfoValue;
 class SysStats_PsiSample;
+class SysStats_ThermalZone;
 class SysStats_VmstatValue;
 enum MeminfoCounters : int32_t;
 namespace perfetto_pbzero_enum_SysStats_PsiSample {
@@ -156826,7 +158590,7 @@ const char* SysStats_PsiSample_PsiResource_Name(::perfetto::protos::pbzero::SysS
   return "PBZERO_UNKNOWN_ENUM_VALUE";
 }
 
-class SysStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/14, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class SysStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/16, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
  public:
   SysStats_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit SysStats_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -156859,6 +158623,10 @@ class SysStats_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> disk_stat() const { return GetRepeated<::protozero::ConstBytes>(13); }
   bool has_psi() const { return at<14>().valid(); }
   ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> psi() const { return GetRepeated<::protozero::ConstBytes>(14); }
+  bool has_thermal_zone() const { return at<15>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> thermal_zone() const { return GetRepeated<::protozero::ConstBytes>(15); }
+  bool has_cpuidle_state() const { return at<16>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpuidle_state() const { return GetRepeated<::protozero::ConstBytes>(16); }
 };
 
 class SysStats : public ::protozero::Message {
@@ -156879,6 +158647,8 @@ class SysStats : public ::protozero::Message {
     kBuddyInfoFieldNumber = 12,
     kDiskStatFieldNumber = 13,
     kPsiFieldNumber = 14,
+    kThermalZoneFieldNumber = 15,
+    kCpuidleStateFieldNumber = 16,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.SysStats"; }
 
@@ -156890,6 +158660,9 @@ class SysStats : public ::protozero::Message {
   using BuddyInfo = ::perfetto::protos::pbzero::SysStats_BuddyInfo;
   using DiskStat = ::perfetto::protos::pbzero::SysStats_DiskStat;
   using PsiSample = ::perfetto::protos::pbzero::SysStats_PsiSample;
+  using ThermalZone = ::perfetto::protos::pbzero::SysStats_ThermalZone;
+  using CpuIdleStateEntry = ::perfetto::protos::pbzero::SysStats_CpuIdleStateEntry;
+  using CpuIdleState = ::perfetto::protos::pbzero::SysStats_CpuIdleState;
 
   using FieldMetadata_Meminfo =
     ::protozero::proto_utils::FieldMetadata<
@@ -157106,6 +158879,243 @@ class SysStats : public ::protozero::Message {
     return BeginNestedMessage<T>(14);
   }
 
+
+  using FieldMetadata_ThermalZone =
+    ::protozero::proto_utils::FieldMetadata<
+      15,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_ThermalZone,
+      SysStats>;
+
+  static constexpr FieldMetadata_ThermalZone kThermalZone{};
+  template <typename T = SysStats_ThermalZone> T* add_thermal_zone() {
+    return BeginNestedMessage<T>(15);
+  }
+
+
+  using FieldMetadata_CpuidleState =
+    ::protozero::proto_utils::FieldMetadata<
+      16,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_CpuIdleState,
+      SysStats>;
+
+  static constexpr FieldMetadata_CpuidleState kCpuidleState{};
+  template <typename T = SysStats_CpuIdleState> T* add_cpuidle_state() {
+    return BeginNestedMessage<T>(16);
+  }
+
+};
+
+class SysStats_CpuIdleState_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+ public:
+  SysStats_CpuIdleState_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_CpuIdleState_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_CpuIdleState_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_cpu_id() const { return at<1>().valid(); }
+  uint32_t cpu_id() const { return at<1>().as_uint32(); }
+  bool has_cpuidle_state_entry() const { return at<2>().valid(); }
+  ::protozero::RepeatedFieldIterator<::protozero::ConstBytes> cpuidle_state_entry() const { return GetRepeated<::protozero::ConstBytes>(2); }
+};
+
+class SysStats_CpuIdleState : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_CpuIdleState_Decoder;
+  enum : int32_t {
+    kCpuIdFieldNumber = 1,
+    kCpuidleStateEntryFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuIdleState"; }
+
+
+  using FieldMetadata_CpuId =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      SysStats_CpuIdleState>;
+
+  static constexpr FieldMetadata_CpuId kCpuId{};
+  void set_cpu_id(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_CpuId::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_CpuidleStateEntry =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kRepeatedNotPacked,
+      ::protozero::proto_utils::ProtoSchemaType::kMessage,
+      SysStats_CpuIdleStateEntry,
+      SysStats_CpuIdleState>;
+
+  static constexpr FieldMetadata_CpuidleStateEntry kCpuidleStateEntry{};
+  template <typename T = SysStats_CpuIdleStateEntry> T* add_cpuidle_state_entry() {
+    return BeginNestedMessage<T>(2);
+  }
+
+};
+
+class SysStats_CpuIdleStateEntry_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  SysStats_CpuIdleStateEntry_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_CpuIdleStateEntry_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_CpuIdleStateEntry_Decoder(const ::protozero::ConstBytes& raw) : TypedProtoDecoder(raw.data, raw.size) {}
+  bool has_state() const { return at<1>().valid(); }
+  ::protozero::ConstChars state() const { return at<1>().as_string(); }
+  bool has_duration_us() const { return at<2>().valid(); }
+  uint64_t duration_us() const { return at<2>().as_uint64(); }
+};
+
+class SysStats_CpuIdleStateEntry : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_CpuIdleStateEntry_Decoder;
+  enum : int32_t {
+    kStateFieldNumber = 1,
+    kDurationUsFieldNumber = 2,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.CpuIdleStateEntry"; }
+
+
+  using FieldMetadata_State =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_CpuIdleStateEntry>;
+
+  static constexpr FieldMetadata_State kState{};
+  void set_state(const char* data, size_t size) {
+    AppendBytes(FieldMetadata_State::kFieldId, data, size);
+  }
+  void set_state(::protozero::ConstChars chars) {
+    AppendBytes(FieldMetadata_State::kFieldId, chars.data, chars.size);
+  }
+  void set_state(std::string value) {
+    static constexpr uint32_t field_id = FieldMetadata_State::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_DurationUs =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_CpuIdleStateEntry>;
+
+  static constexpr FieldMetadata_DurationUs kDurationUs{};
+  void set_duration_us(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_DurationUs::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 SysStats_ThermalZone_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
+ public:
+  SysStats_ThermalZone_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
+  explicit SysStats_ThermalZone_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
+  explicit SysStats_ThermalZone_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_temp() const { return at<2>().valid(); }
+  uint64_t temp() const { return at<2>().as_uint64(); }
+  bool has_type() const { return at<3>().valid(); }
+  ::protozero::ConstChars type() const { return at<3>().as_string(); }
+};
+
+class SysStats_ThermalZone : public ::protozero::Message {
+ public:
+  using Decoder = SysStats_ThermalZone_Decoder;
+  enum : int32_t {
+    kNameFieldNumber = 1,
+    kTempFieldNumber = 2,
+    kTypeFieldNumber = 3,
+  };
+  static constexpr const char* GetName() { return ".perfetto.protos.SysStats.ThermalZone"; }
+
+
+  using FieldMetadata_Name =
+    ::protozero::proto_utils::FieldMetadata<
+      1,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_ThermalZone>;
+
+  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_Temp =
+    ::protozero::proto_utils::FieldMetadata<
+      2,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint64,
+      uint64_t,
+      SysStats_ThermalZone>;
+
+  static constexpr FieldMetadata_Temp kTemp{};
+  void set_temp(uint64_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Temp::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_Type =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kString,
+      std::string,
+      SysStats_ThermalZone>;
+
+  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);
+  }
 };
 
 class SysStats_PsiSample_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/false> {
@@ -157967,7 +159977,7 @@ class CpuInfo : public ::protozero::Message {
 
 };
 
-class CpuInfo_Cpu_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/2, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
+class CpuInfo_Cpu_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID=*/3, /*HAS_NONPACKED_REPEATED_FIELDS=*/true> {
  public:
   CpuInfo_Cpu_Decoder(const uint8_t* data, size_t len) : TypedProtoDecoder(data, len) {}
   explicit CpuInfo_Cpu_Decoder(const std::string& raw) : TypedProtoDecoder(reinterpret_cast<const uint8_t*>(raw.data()), raw.size()) {}
@@ -157976,6 +159986,8 @@ class CpuInfo_Cpu_Decoder : public ::protozero::TypedProtoDecoder</*MAX_FIELD_ID
   ::protozero::ConstChars processor() const { return at<1>().as_string(); }
   bool has_frequencies() const { return at<2>().valid(); }
   ::protozero::RepeatedFieldIterator<uint32_t> frequencies() const { return GetRepeated<uint32_t>(2); }
+  bool has_capacity() const { return at<3>().valid(); }
+  uint32_t capacity() const { return at<3>().as_uint32(); }
 };
 
 class CpuInfo_Cpu : public ::protozero::Message {
@@ -157984,6 +159996,7 @@ class CpuInfo_Cpu : public ::protozero::Message {
   enum : int32_t {
     kProcessorFieldNumber = 1,
     kFrequenciesFieldNumber = 2,
+    kCapacityFieldNumber = 3,
   };
   static constexpr const char* GetName() { return ".perfetto.protos.CpuInfo.Cpu"; }
 
@@ -158029,6 +160042,24 @@ class CpuInfo_Cpu : public ::protozero::Message {
       ::protozero::proto_utils::ProtoSchemaType::kUint32>
         ::Append(*this, field_id, value);
   }
+
+  using FieldMetadata_Capacity =
+    ::protozero::proto_utils::FieldMetadata<
+      3,
+      ::protozero::proto_utils::RepetitionType::kNotRepeated,
+      ::protozero::proto_utils::ProtoSchemaType::kUint32,
+      uint32_t,
+      CpuInfo_Cpu>;
+
+  static constexpr FieldMetadata_Capacity kCapacity{};
+  void set_capacity(uint32_t value) {
+    static constexpr uint32_t field_id = FieldMetadata_Capacity::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.
@@ -161891,6 +163922,8 @@ class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMes
     kHasHighLatencyFieldNumber = 12,
     kFrameTypeFieldNumber = 13,
     kHighLatencyContributionStageFieldNumber = 14,
+    kCheckerboardedNeedsRasterFieldNumber = 15,
+    kCheckerboardedNeedsRecordFieldNumber = 16,
   };
 
   ChromeFrameReporter();
@@ -161966,6 +163999,14 @@ class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMes
   void add_high_latency_contribution_stage(std::string value) { high_latency_contribution_stage_.emplace_back(value); }
   std::string* add_high_latency_contribution_stage() { high_latency_contribution_stage_.emplace_back(); return &high_latency_contribution_stage_.back(); }
 
+  bool has_checkerboarded_needs_raster() const { return _has_field_[15]; }
+  bool checkerboarded_needs_raster() const { return checkerboarded_needs_raster_; }
+  void set_checkerboarded_needs_raster(bool value) { checkerboarded_needs_raster_ = value; _has_field_.set(15); }
+
+  bool has_checkerboarded_needs_record() const { return _has_field_[16]; }
+  bool checkerboarded_needs_record() const { return checkerboarded_needs_record_; }
+  void set_checkerboarded_needs_record(bool value) { checkerboarded_needs_record_ = value; _has_field_.set(16); }
+
  private:
   ChromeFrameReporter_State state_{};
   ChromeFrameReporter_FrameDropReason reason_{};
@@ -161981,12 +164022,14 @@ class PERFETTO_EXPORT_COMPONENT ChromeFrameReporter : public ::protozero::CppMes
   bool has_high_latency_{};
   ChromeFrameReporter_FrameType frame_type_{};
   std::vector<std::string> high_latency_contribution_stage_;
+  bool checkerboarded_needs_raster_{};
+  bool checkerboarded_needs_record_{};
 
   // Allows to preserve unknown protobuf fields for compatibility
   // with future versions of .proto files.
   std::string unknown_fields_;
 
-  std::bitset<15> _has_field_{};
+  std::bitset<17> _has_field_{};
 };
 
 }  // namespace perfetto