diff --git a/generate_perfetto_binaries.py b/generate_perfetto_binaries.py
index aedf9f8..b55243f 100755
--- a/generate_perfetto_binaries.py
+++ b/generate_perfetto_binaries.py
@@ -37,12 +37,20 @@
 # List of each arch, with a tuple of:
 # - perfetto-name (arg in perfetto build)
 # - android-tag (used in final output path, used for binary disambig at apk build time)
-# - associated ndk subdir for stripping (This includes a %s for host OS)
 ARCH_LIST = (
-    ('arm', 'arm', 'arm-%s-androideabi'),
-    ('arm64', 'aarch64', 'aarch64-%s-android'),
-    ('x64', 'x86_64', 'x86_64-%s-android'),
-    ('x86', 'x86', 'x86_64-%s-android'),
+    ('arm', 'arm'),
+    ('arm64', 'aarch64'),
+    ('x64', 'x86_64'),
+    ('x86', 'x86'), # Broken, see b/328101283
+)
+
+# List of each proto to copy / check in. As imports in the top level
+# protos are changed, this list will need to be updated.
+PROTO_LIST = (
+    'protos/perfetto/trace_processor/trace_processor.proto',
+    'protos/perfetto/common/descriptor.proto',
+    'protos/perfetto/metrics/perfetto_merged_metrics.proto',
+    'protos/perfetto/trace_processor/metatrace_categories.proto',
 )
 
 ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -60,7 +68,24 @@
 
   gn = os.path.join(perfetto_dir, 'tools', 'gn')
 
-  for arch, arch_tag, ndk_dir_pattern in ARCH_LIST: #ARCH_TABLE.items():
+  ### Protos
+  print('\n\033[32mCopying Protos\033[0m')
+  # use root as proto dir, as all protos have 'protos' prefix, so will be in protos dir
+  out_proto_dir = ROOT_DIR
+  # cleanup old protos
+  subprocess.check_call(['rm', '-rf', 'protos'], cwd=ROOT_DIR)
+  for src_path in PROTO_LIST:
+    print(src_path)
+    split_path_in_repo = src_path.split('/')
+    src = os.path.join(perfetto_dir, *split_path_in_repo)
+    dst = os.path.join(out_proto_dir, *split_path_in_repo)
+
+    # Preserve tree when copying to support import paths
+    os.makedirs(os.path.dirname(dst), exist_ok=True)
+    copyfile(src, dst)
+
+  ### Binaries
+  for arch, arch_tag in ARCH_LIST:
     config_name ='android_%s' % (arch)
     gn_args = ANDROID_ARGS + ('target_cpu="%s"' % arch,)
 
@@ -100,9 +125,8 @@
           "llvm",
           "prebuilt",
           platform_folder,
-          ndk_dir_pattern % ("linux"), # TODO: support macos
           "bin",
-          "strip")
+          "llvm-strip")
       subprocess.check_call((strip_path, out_file))
 
 if __name__ == '__main__':
diff --git a/protos/perfetto/common/descriptor.proto b/protos/perfetto/common/descriptor.proto
new file mode 100644
index 0000000..6684a70
--- /dev/null
+++ b/protos/perfetto/common/descriptor.proto
@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This is a subset of descriptor.proto from the Protobuf library.
+syntax = "proto2";
+
+package perfetto.protos;
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+message FileDescriptorSet {
+  repeated FileDescriptorProto file = 1;
+}
+
+// Describes a complete .proto file.
+message FileDescriptorProto {
+  // file name, relative to root of source tree
+  optional string name = 1;
+  // e.g. "foo", "foo.bar", etc.
+  optional string package = 2;
+
+  // Names of files imported by this file.
+  repeated string dependency = 3;
+  // Indexes of the public imported files in the dependency list above.
+  repeated int32 public_dependency = 10;
+  // Indexes of the weak imported files in the dependency list.
+  // For Google-internal migration only. Do not use.
+  repeated int32 weak_dependency = 11;
+
+  // All top-level definitions in this file.
+  repeated DescriptorProto message_type = 4;
+  repeated EnumDescriptorProto enum_type = 5;
+  repeated FieldDescriptorProto extension = 7;
+
+  reserved 6;
+  reserved 8;
+  reserved 9;
+  reserved 12;
+}
+
+// Describes a message type.
+message DescriptorProto {
+  optional string name = 1;
+
+  repeated FieldDescriptorProto field = 2;
+  repeated FieldDescriptorProto extension = 6;
+
+  repeated DescriptorProto nested_type = 3;
+  repeated EnumDescriptorProto enum_type = 4;
+
+  reserved 5;
+
+  repeated OneofDescriptorProto oneof_decl = 8;
+
+  reserved 7;
+
+  // Range of reserved tag numbers. Reserved tag numbers may not be used by
+  // fields or extension ranges in the same message. Reserved ranges may
+  // not overlap.
+  message ReservedRange {
+    // Inclusive.
+    optional int32 start = 1;
+    // Exclusive.
+    optional int32 end = 2;
+  }
+  repeated ReservedRange reserved_range = 9;
+  // Reserved field names, which may not be used by fields in the same message.
+  // A given name may only be reserved once.
+  repeated string reserved_name = 10;
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+message UninterpretedOption {
+  // The name of the uninterpreted option.  Each string represents a segment in
+  // a dot-separated name.  is_extension is true iff a segment represents an
+  // extension (denoted with parentheses in options specs in .proto files).
+  // E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
+  // "foo.(bar.baz).moo".
+  message NamePart {
+    optional string name_part = 1;
+    optional bool is_extension = 2;
+  }
+  repeated NamePart name = 2;
+
+  // The value of the uninterpreted option, in whatever type the tokenizer
+  // identified it as during parsing. Exactly one of these should be set.
+  optional string identifier_value = 3;
+  optional uint64 positive_int_value = 4;
+  optional int64 negative_int_value = 5;
+  optional double double_value = 6;
+  optional bytes string_value = 7;
+  optional string aggregate_value = 8;
+}
+
+message FieldOptions {
+  // The packed option can be enabled for repeated primitive fields to enable
+  // a more efficient representation on the wire. Rather than repeatedly
+  // writing the tag and type for each element, the entire array is encoded as
+  // a single length-delimited blob. In proto3, only explicit setting it to
+  // false will avoid using packed encoding.
+  optional bool packed = 2;
+
+  // The parser stores options it doesn't recognize here. See above.
+  repeated UninterpretedOption uninterpreted_option = 999;
+}
+
+// Describes a field within a message.
+message FieldDescriptorProto {
+  enum Type {
+    // 0 is reserved for errors.
+    // Order is weird for historical reasons.
+    TYPE_DOUBLE = 1;
+    TYPE_FLOAT = 2;
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+    // negative values are likely.
+    TYPE_INT64 = 3;
+    TYPE_UINT64 = 4;
+    // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+    // negative values are likely.
+    TYPE_INT32 = 5;
+    TYPE_FIXED64 = 6;
+    TYPE_FIXED32 = 7;
+    TYPE_BOOL = 8;
+    TYPE_STRING = 9;
+    // Tag-delimited aggregate.
+    // Group type is deprecated and not supported in proto3. However, Proto3
+    // implementations should still be able to parse the group wire format and
+    // treat group fields as unknown fields.
+    TYPE_GROUP = 10;
+    // Length-delimited aggregate.
+    TYPE_MESSAGE = 11;
+
+    // New in version 2.
+    TYPE_BYTES = 12;
+    TYPE_UINT32 = 13;
+    TYPE_ENUM = 14;
+    TYPE_SFIXED32 = 15;
+    TYPE_SFIXED64 = 16;
+    // Uses ZigZag encoding.
+    TYPE_SINT32 = 17;
+    // Uses ZigZag encoding.
+    TYPE_SINT64 = 18;
+  };
+
+  enum Label {
+    // 0 is reserved for errors
+    LABEL_OPTIONAL = 1;
+    LABEL_REQUIRED = 2;
+    LABEL_REPEATED = 3;
+  };
+
+  optional string name = 1;
+  optional int32 number = 3;
+  optional Label label = 4;
+
+  // If type_name is set, this need not be set.  If both this and type_name
+  // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+  optional Type type = 5;
+
+  // For message and enum types, this is the name of the type.  If the name
+  // starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
+  // rules are used to find the type (i.e. first the nested types within this
+  // message are searched, then within the parent, on up to the root
+  // namespace).
+  optional string type_name = 6;
+
+  // For extensions, this is the name of the type being extended.  It is
+  // resolved in the same manner as type_name.
+  optional string extendee = 2;
+
+  // For numeric types, contains the original text representation of the value.
+  // For booleans, "true" or "false".
+  // For strings, contains the default text contents (not escaped in any way).
+  // For bytes, contains the C escaped value.  All bytes >= 128 are escaped.
+  // TODO(kenton):  Base-64 encode?
+  optional string default_value = 7;
+
+  optional FieldOptions options = 8;
+
+  // If set, gives the index of a oneof in the containing type's oneof_decl
+  // list.  This field is a member of that oneof.
+  optional int32 oneof_index = 9;
+
+  reserved 10;
+}
+
+// Describes a oneof.
+message OneofDescriptorProto {
+  optional string name = 1;
+  optional OneofOptions options = 2;
+}
+
+// Describes an enum type.
+message EnumDescriptorProto {
+  optional string name = 1;
+
+  repeated EnumValueDescriptorProto value = 2;
+
+  reserved 3;
+  reserved 4;
+
+  // Reserved enum value names, which may not be reused. A given name may only
+  // be reserved once.
+  repeated string reserved_name = 5;
+}
+
+// Describes a value within an enum.
+message EnumValueDescriptorProto {
+  optional string name = 1;
+  optional int32 number = 2;
+
+  reserved 3;
+}
+
+message OneofOptions {
+  reserved 999;
+
+  // Clients can define custom options in extensions of this message. See above.
+  extensions 1000 to max;
+}
diff --git a/protos/perfetto/metrics/perfetto_merged_metrics.proto b/protos/perfetto/metrics/perfetto_merged_metrics.proto
new file mode 100644
index 0000000..eb9ab74
--- /dev/null
+++ b/protos/perfetto/metrics/perfetto_merged_metrics.proto
@@ -0,0 +1,2710 @@
+// AUTOGENERATED - DO NOT EDIT
+// ---------------------------
+// This file has been generated by
+// AOSP://external/perfetto/tools/gen_merged_protos
+// merging the perfetto config protos.
+// This fused proto is intended to be copied in:
+//  - Android tree, for statsd.
+//  - Google internal repos.
+
+syntax = "proto2";
+
+package perfetto.protos;
+
+option go_package = "github.com/google/perfetto/perfetto_proto";
+
+// Begin of protos/perfetto/metrics/android/ad_services_metric.proto
+
+// Next: 8
+message AdServicesUiMetric {
+  optional double common_service_initialization_latency = 1;
+  optional double common_service_permission_check_latency = 2;
+  optional double common_service_ux_engine_flow_latency = 3;
+  optional double main_activity_creation_latency = 4;
+  optional double consent_manager_initialization_latency = 5;
+  optional double consent_manager_read_latency = 6;
+  optional double consent_manager_write_latency = 7;
+}
+
+// Next: 2
+message AdServicesAdIdMetric {
+  optional double latency = 1;
+}
+
+// Next: 2
+message AdServicesAppSetIdMetric {
+  optional double latency = 1;
+}
+
+// Next: 5
+message OnDevicePersonalizationMetric {
+  optional double managing_service_initialization_latency = 1;
+  optional double service_delegate_execute_flow_latency = 2;
+  optional double service_delegate_request_surface_package_latency = 3;
+  optional double service_delegate_register_web_trigger_latency = 4;
+}
+
+// Next: 5
+message AdServicesMetric {
+  repeated AdServicesUiMetric ui_metric = 1;
+  repeated AdServicesAdIdMetric ad_id_metric = 2;
+  repeated AdServicesAppSetIdMetric app_set_id_metric = 3;
+  repeated OnDevicePersonalizationMetric odp_metric = 4;
+}
+// End of protos/perfetto/metrics/android/ad_services_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_blocking_call.proto
+
+// Blocking call on the main thread.
+message AndroidBlockingCall {
+    // Name of the blocking call
+    optional string name = 1;
+    // Number of times it happened within the CUJ
+    optional int64 cnt = 2;
+    // Total duration within the CUJ
+    optional int64 total_dur_ms = 3;
+    // Maximal duration within the CUJ
+    optional int64 max_dur_ms = 4;
+    // Minimal duration within the CUJ
+    optional int64 min_dur_ms = 5;
+    // Total duration within the CUJ in nanoseconds
+    optional int64 total_dur_ns = 6;
+    // Maximal duration within the CUJ in nanoseconds
+    optional int64 max_dur_ns = 7;
+    // Minimal duration within the CUJ in nanoseconds
+    optional int64 min_dur_ns = 8;
+}
+
+// End of protos/perfetto/metrics/android/android_blocking_call.proto
+
+// Begin of protos/perfetto/metrics/android/process_metadata.proto
+
+message AndroidProcessMetadata {
+  // Process name. Usually, cmdline or <package_name>(:<custom_name>)?.
+  optional string name = 1;
+
+  // User id under which this process runs.
+  optional int64 uid = 2;
+
+  // Package metadata from Android package list.
+  message Package {
+    optional string package_name = 1;
+    optional int64 apk_version_code = 2;
+    optional bool debuggable = 3;
+  }
+
+  // Package that this process belongs to.
+  //
+  // If this process shares its uid (see `packages_for_uid` field), the package
+  // is determined based on the process name and package name. If there is no
+  // match this field is empty.
+  optional Package package = 7;
+
+  // All packages using this uid.
+  //
+  // Shared uid documentation:
+  // https://developer.android.com/guide/topics/manifest/manifest-element#uid
+  repeated Package packages_for_uid = 8;
+
+  // Pid of the process name.
+  optional int64 pid = 9;
+
+  reserved 3, 4, 5, 6;
+}
+
+// End of protos/perfetto/metrics/android/process_metadata.proto
+
+// Begin of protos/perfetto/metrics/android/android_blocking_calls_cuj_metric.proto
+
+// Blocking calls inside Android CUJs. Shows count and total duration for each.
+message AndroidBlockingCallsCujMetric {
+  repeated Cuj cuj = 1;
+
+  // Next id: 7
+  message Cuj {
+    // ID of the CUJ that is unique within the trace.
+    optional int32 id = 1;
+
+    // Name of the CUJ, extracted from the CUJ jank or latency trace marker.
+    // For example SHADE_EXPAND_COLLAPSE from J<SHADE_EXPAND_COLLAPSE>.
+    optional string name = 2;
+
+    // Details about the process (uid, version, etc)
+    optional AndroidProcessMetadata process = 3;
+
+    // ts of the CUJ trace marker slice, in ns.
+    optional int64 ts = 4;
+
+    // dur of the CUJ trace marker slice, in ns.
+    optional int64 dur = 5;
+
+    // List of blocking calls on the process main thread.
+    repeated AndroidBlockingCall blocking_calls = 6;
+  }
+}
+
+// End of protos/perfetto/metrics/android/android_blocking_calls_cuj_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_boot.proto
+
+// This metric computes how much time processes spend in UNINTERRUPTIBLE_SLEEP
+// state
+message ProcessStateDurations {
+  optional int64 total_dur = 2;
+  optional int64 uninterruptible_sleep_dur = 3;
+}
+
+message AndroidBootMetric {
+  optional ProcessStateDurations system_server_durations = 1;
+  optional ProcessStateDurations systemui_durations = 2;
+  optional ProcessStateDurations launcher_durations = 3;
+  optional ProcessStateDurations gms_durations = 4;
+  // Launcher related boot metrics
+  message LauncherBreakdown {
+    //  reports cold start time of NexusLauncher
+    optional int64 cold_start_dur = 1;
+  }
+  optional LauncherBreakdown launcher_breakdown = 5;
+
+  message ProcessStartAggregation {
+    optional int64 total_start_sum = 1;
+    optional int64 num_of_processes = 2;
+    optional double average_start_time = 3;
+  }
+  message GarbageCollectionAggregation {
+    optional int64 total_gc_count = 1;
+    optional int64 num_of_processes_with_gc = 2;
+    optional int64 num_of_threads_with_gc = 3;
+    optional double avg_gc_duration = 4;
+    optional double avg_running_gc_duration = 5;
+    optional int64 full_gc_count = 6;
+    optional int64 collector_transition_gc_count = 7;
+    optional int64 young_gc_count = 8;
+    optional int64 native_alloc_gc_count = 9;
+    optional int64 explicit_gc_count = 10;
+    optional int64 alloc_gc_count = 11;
+    optional double mb_per_ms_of_gc = 12;
+  }
+  optional ProcessStartAggregation full_trace_process_start_aggregation = 6;
+  optional ProcessStartAggregation post_boot_process_start_aggregation = 7;
+  optional GarbageCollectionAggregation full_trace_gc_aggregation = 8;
+  optional GarbageCollectionAggregation post_boot_gc_aggregation = 9;
+}
+
+// End of protos/perfetto/metrics/android/android_boot.proto
+
+// Begin of protos/perfetto/metrics/android/android_garbage_collection_unagg_metric.proto
+
+message AndroidGarbageCollectionUnaggMetric {
+  message GarbageCollectionEvent {
+    // Name of thread running garbage collection.
+    optional string thread_name = 1;
+    // Name of process running garbage collection.
+    optional string process_name = 2;
+    // Type of garbage collection.
+    optional string gc_type = 3;
+    // Whether gargage collection is mark compact or copying.
+    optional int64 is_mark_compact = 4;
+    // MB reclaimed after garbage collection.
+    optional double reclaimed_mb = 5;
+    // Minimum heap size in MB during garbage collection.
+    optional double min_heap_mb = 6;
+    // Maximum heap size in MB during garbage collection.
+    optional double max_heap_mb = 7;
+    // Memory reclaimed per ms of running time.
+    optional double mb_per_ms_of_running_gc = 8;
+    // Memory reclaimed per ms of wall time.
+    optional double mb_per_ms_of_wall_gc = 9;
+    // Garbage collection wall duration.
+    optional int64 gc_dur = 10;
+    // Garbage collection duration spent executing on CPU.
+    optional int64 gc_running_dur = 11;
+    // Garbage collection duration spent waiting for CPU.
+    optional int64 gc_runnable_dur = 12;
+    // Garbage collection duration spent waiting in the Linux kernel on IO.
+    optional int64 gc_unint_io_dur = 13;
+    // Garbage collection duration spent waiting in the Linux kernel without IO.
+    optional int64 gc_unint_non_io_dur = 14;
+    // Garbage collection duration spent waiting in interruptible sleep.
+    optional int64 gc_int_dur = 15;
+    // ts of the event in trace.
+    optional int64 gc_ts = 16;
+    // pid of the event in trace.
+    optional int64 pid = 17;
+    // tid of the event in trace.
+    optional int64 tid = 18;
+    // monotonic duration of event.
+    optional int64 gc_monotonic_dur = 19;
+  }
+  repeated GarbageCollectionEvent gc_events = 1;
+}
+// End of protos/perfetto/metrics/android/android_garbage_collection_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/app_process_starts_metric.proto
+
+message AndroidAppProcessStartsMetric {
+  // Next id : 4
+  message ProcessStart {
+    optional string process_name = 1;
+    optional string intent = 2;
+    optional string reason = 3;
+    optional int64 proc_start_dur = 4;
+    optional int64 bind_app_dur = 5;
+    optional int64 intent_dur = 6;
+    optional int64 total_dur = 7;
+  }
+  // Provides java process startup information for
+  // all processes starting after Boot completed broadcast in a trace.
+  repeated ProcessStart all_apps = 1;
+  // Provides java process startup information for all
+  // processes started from a broadcast after Boot Complete broadcasts.
+  repeated ProcessStart started_by_broadcast = 2;
+  // Provides java process startup information for all
+  // processes started from a service after Boot Complete broadcasts.
+  repeated ProcessStart started_by_service = 3;
+}
+
+// End of protos/perfetto/metrics/android/app_process_starts_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_boot_unagg.proto
+
+message AndroidBootUnagg {
+  // Looks at all apps started after boot complete broadcast.
+  optional AndroidAppProcessStartsMetric android_app_process_start_metric = 1;
+  // Looks at all GC that occurs after boot complete broadcast.
+  optional AndroidGarbageCollectionUnaggMetric android_post_boot_gc_metric = 2;
+}
+
+// End of protos/perfetto/metrics/android/android_boot_unagg.proto
+
+// Begin of protos/perfetto/metrics/android/android_frame_timeline_metric.proto
+
+message AndroidFrameTimelineMetric {
+  message JankTypeMetric {
+    // The jank type
+    optional string type = 1;
+
+    // The count of frames with this jank type
+    optional int64 total_count = 2;
+
+    // The count of frames with this jank type and present type = PRESENT_UNSPECIFIED
+    optional int64 present_unspecified_count = 3;
+
+    // The count of frames with this jank type and present type = PRESENT_ON_TIME
+    optional int64 present_on_time_count = 4;
+
+    // The count of frames with this jank type and present type = PRESENT_LATE
+    optional int64 present_late_count = 5;
+
+    // The count of frames with this jank type and present type = PRESENT_EARLY
+    optional int64 present_early_count = 6;
+
+    // The count of frames with this jank type and present type = PRESENT_DROPPED
+    optional int64 present_dropped_count = 7;
+
+    // The count of frames with this jank type and present type = PRESENT_UNKNOWN
+    optional int64 present_unknown_count = 8;
+  }
+
+  message ProcessBreakdown {
+    optional AndroidProcessMetadata process = 3;
+
+    optional int64 total_frames = 4;
+    optional int64 missed_frames = 5;
+    optional int64 missed_app_frames = 6;
+    optional int64 missed_sf_frames = 7;
+
+    optional int64 frame_dur_max = 8;
+    optional int64 frame_dur_avg = 9;
+    optional int64 frame_dur_p50 = 10;
+    optional int64 frame_dur_p90 = 11;
+    optional int64 frame_dur_p95 = 12;
+    optional int64 frame_dur_p99 = 13;
+    optional double frame_dur_ms_p50 = 14;
+    optional double frame_dur_ms_p90 = 15;
+    optional double frame_dur_ms_p95 = 16;
+    optional double frame_dur_ms_p99 = 17;
+    optional int64 dropped_frames = 18;
+
+    // Metrics for each jank type in this process
+    repeated JankTypeMetric jank_types = 19;
+
+    reserved 1, 2;
+  }
+
+  optional int64 total_frames = 4;
+  optional int64 missed_app_frames = 5;
+  optional int64 dropped_frames = 6;
+
+  repeated ProcessBreakdown process = 2;
+
+  // Metrics for each jank type globally
+  repeated JankTypeMetric jank_types = 7;
+
+  reserved 1;
+}
+
+
+// End of protos/perfetto/metrics/android/android_frame_timeline_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_sysui_notifications_blocking_calls_metric.proto
+
+// Blocking calls inside System UI Notifications. Shows count and total duration for each.
+message AndroidSysUINotificationsBlockingCallsMetric {
+  repeated AndroidBlockingCall blocking_calls = 1;
+}
+
+// End of protos/perfetto/metrics/android/android_sysui_notifications_blocking_calls_metric.proto
+
+// Begin of protos/perfetto/metrics/android/android_trusty_workqueues.proto
+
+// Metric used to generate a simplified view of the Trusty kworker events.
+message AndroidTrustyWorkqueues {}
+
+// End of protos/perfetto/metrics/android/android_trusty_workqueues.proto
+
+// Begin of protos/perfetto/metrics/android/anr_metric.proto
+
+ message AndroidAnrMetric {
+  repeated Anr anr = 1;
+
+  // Next id: 12
+  message Anr {
+    // UUID that identifies the ANR.
+    optional string error_id = 1;
+
+    // Name of the process that ANRed.
+    optional string process_name = 2;
+
+    // PID of the ANRing process.
+    optional int32 pid = 3;
+
+    // ANR subject line.
+    optional string subject = 4;
+
+    // Timestamp of the ANR in the trace.
+    optional int64 ts = 5;
+  }
+}
+// End of protos/perfetto/metrics/android/anr_metric.proto
+
+// Begin of protos/perfetto/metrics/android/batt_metric.proto
+
+message AndroidBatteryMetric {
+  message BatteryCounters {
+    // Timestamp measured from boot time [ns].
+    optional int64 timestamp_ns = 1;
+    // Fields 2-5 are the same as in BatteryCounters proto in TracePacket.
+    optional double charge_counter_uah = 2;
+    optional float capacity_percent = 3;
+    optional double current_ua = 4;
+    optional double current_avg_ua = 5;
+  }
+
+  message BatteryAggregates {
+    // Field numbers for these 3 == the int values from Android
+    optional int64 total_screen_off_ns = 1;
+    optional int64 total_screen_on_ns = 2;
+    optional int64 total_screen_doze_ns = 3;
+    // Total time a wakelock was held
+    optional int64 total_wakelock_ns = 4;
+    // Amount of time the device was suspended. Depends on the ftrace source
+    // "power/suspend_resume".
+    optional int64 sleep_ns = 5;
+    optional int64 sleep_screen_off_ns = 6;
+    optional int64 sleep_screen_on_ns = 7;
+    optional int64 sleep_screen_doze_ns = 8;
+  }
+
+  // Period of time during the trace that the device went to sleep completely.
+  message SuspendPeriod {
+    optional int64 timestamp_ns = 1;
+    optional int64 duration_ns = 2;
+  }
+
+  // Battery counters info for each ts of the trace. This should only be
+  // extracted for short traces.
+  repeated BatteryCounters battery_counters = 1;
+
+  optional BatteryAggregates battery_aggregates = 2;
+
+  repeated SuspendPeriod suspend_period = 3;
+}
+
+// End of protos/perfetto/metrics/android/batt_metric.proto
+
+// Begin of protos/perfetto/metrics/android/binder_metric.proto
+
+// This metric provides the following:
+// 1. Per-process Binder statistics for traces with binder_driver enabled.
+//    Specifically, transactions are categorized and counted
+// 2. Unaggregated binder txn durations with per-txn aggregated thread state and
+// blocked function
+//    durations
+message AndroidBinderMetric {
+  message PerProcessBreakdown {
+    optional string process_name = 1;
+    optional uint32 pid = 2;
+    optional string slice_name = 3;
+    optional uint32 count = 4;
+  }
+
+  // Next field id: 30
+  message UnaggregatedTxnBreakdown {
+    // General
+    optional string aidl_name = 1;
+    optional int64 aidl_ts = 22;
+    optional int64 aidl_dur = 23;
+    optional bool is_sync = 21;
+    // Client
+    // Removed: was binder_txn_id
+    reserved 2;
+    optional string client_process = 3;
+    optional string client_thread = 4;
+    optional bool is_main_thread = 5;
+    optional int64 client_ts = 6;
+    optional int64 client_dur = 7;
+    optional int64 client_monotonic_dur = 28;
+    optional int64 client_oom_score = 19;
+    optional int64 client_package_version_code = 24;
+    optional bool is_client_package_debuggable = 25;
+    // Server
+    // Removed: was binder_reply_id
+    reserved 8;
+    optional string server_process = 9;
+    optional string server_thread = 10;
+    optional int64 server_ts = 11;
+    optional int64 server_dur = 12;
+    optional int64 server_monotonic_dur = 29;
+    optional int64 server_oom_score = 20;
+    optional int64 server_package_version_code = 26;
+    optional bool is_server_package_debuggable = 27;
+    // Aggregations
+    repeated ThreadStateBreakdown thread_states = 13;
+    repeated BlockedFunctionBreakdown blocked_functions = 14;
+
+    optional uint32 client_tid = 15;
+    optional uint32 server_tid = 16;
+
+    optional uint32 client_pid = 17;
+    optional uint32 server_pid = 18;
+  }
+
+  message ThreadStateBreakdown {
+    optional string thread_state_type = 1;
+    optional string thread_state = 2;
+    optional int64 thread_state_dur = 3;
+    optional int64 thread_state_count = 4;
+  }
+
+  message BlockedFunctionBreakdown {
+    optional string thread_state_type = 1;
+    optional string blocked_function = 2;
+    optional int64 blocked_function_dur = 3;
+    optional int64 blocked_function_count = 4;
+  }
+
+  repeated PerProcessBreakdown process_breakdown = 1;
+  repeated UnaggregatedTxnBreakdown unaggregated_txn_breakdown = 2;
+}
+
+// End of protos/perfetto/metrics/android/binder_metric.proto
+
+// Begin of protos/perfetto/metrics/android/camera_metric.proto
+
+message AndroidCameraMetric {
+  message Counter {
+    optional double min = 1;
+    optional double max = 2;
+    optional double avg = 3;
+  }
+
+  // Counter for the sum of DMA and RSS across GCA, cameraserver
+  // and HAL. This provides a single number for the memory
+  // pressure using the camera is putting on the rest of the
+  // system.
+  //
+  // Note: this number assumes that all DMA pressure is coming
+  // from the camera as this is usually a pretty good
+  // approximation. Being more accurate here would increase the
+  // complexity of the metric significantly.
+  //
+  // Note: if there are multiple GCA/cameraserver/HAL processes
+  // in the trace, this metric will simply take the latest
+  // one in the trace and ignore the others.
+  optional Counter gc_rss_and_dma = 1;
+}
+
+// End of protos/perfetto/metrics/android/camera_metric.proto
+
+// Begin of protos/perfetto/metrics/android/camera_unagg_metric.proto
+
+message AndroidCameraUnaggregatedMetric {
+  message Value {
+    optional int64 ts = 1;
+    optional double gca_rss_val = 2;
+    optional double hal_rss_val = 3;
+    optional double cameraserver_rss_val = 4;
+    optional double dma_val = 5;
+    optional double value = 6;
+  }
+
+  // Timeseries for the sum of DMA and RSS across GCA, cameraserver
+  // and HAL. This provides a single number for the memory
+  // pressure using the camera is putting on the rest of the
+  // system.
+  //
+  // Note: this number assumes that all DMA pressure is coming
+  // from the camera as this is usually a pretty good
+  // approximation. Being more accurate here would increase the
+  // complexity of the metric significantly.
+  //
+  // Note: if there are multiple GCA/cameraserver/HAL processes
+  // in the trace, this metric will simply take the latest
+  // one in the trace and ignore the others.
+  repeated Value gc_rss_and_dma = 1;
+}
+
+// End of protos/perfetto/metrics/android/camera_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/cpu_metric.proto
+
+message AndroidCpuMetric {
+  // Next id: 6
+  message Metrics {
+    // CPU megacycles (i.e. cycles divided by 1e6).
+    optional int64 mcycles = 1;
+
+    // Total time the thread was running for this breakdown in
+    // nanoseconds.
+    optional int64 runtime_ns = 2;
+
+    // Min/max/average CPU frequency weighted by the time the CPU was
+    // running at each frequency in this breakdown.
+    optional int64 min_freq_khz = 3;
+    optional int64 max_freq_khz = 4;
+    optional int64 avg_freq_khz = 5;
+  }
+
+  // Next id: 7
+  message CoreData {
+    optional uint32 id = 1;
+    optional Metrics metrics = 6;
+
+    reserved 2 to 5;
+  }
+
+  // Next id: 3
+  message CoreTypeData {
+    optional string type = 1;
+    optional Metrics metrics = 2;
+  }
+
+  // Next id: 7
+  message Thread {
+    optional string name = 1;
+    optional Metrics metrics = 4;
+
+    // Breakdowns of above metrics.
+    repeated CoreData core = 2;
+    repeated CoreTypeData core_type = 5;
+
+    reserved 3;
+  }
+
+  // Next id: 8
+  message Process {
+    optional string name = 1;
+    optional AndroidProcessMetadata process = 8;
+    optional Metrics metrics = 4;
+
+    // Breakdowns of above metrics.
+    repeated Thread threads = 6;
+    repeated CoreData core = 7;
+    repeated CoreTypeData core_type = 5;
+
+    reserved 3;
+  }
+
+  repeated Process process_info = 1;
+}
+
+// End of protos/perfetto/metrics/android/cpu_metric.proto
+
+// Begin of protos/perfetto/metrics/android/codec_metrics.proto
+
+// These metrices collects various function and thread
+// usage within androd's codec framework. This can give an
+// idea about performance and cpu usage when using codec
+// framework
+message AndroidCodecMetrics {
+
+  // profile details in messages
+  message Detail {
+    // function thread
+    optional string thread_name = 1;
+    // total time
+    optional int64 total_cpu_ns = 2;
+    // CPU time ( time 'Running' on cpu)
+    optional int64 running_cpu_ns = 3;
+  }
+
+  // These are traces and could indicate framework queue latency
+  // buffer-packing, buffer-preprocess, buffer post-process
+  // latency etc. These metrics are monitored to track quality.
+  // Same message can come from different
+  // processes.
+  message CodecFunction {
+    // codec string
+    optional string codec_string = 1;
+    // process_name
+    optional string process_name = 2;
+    // details
+    optional Detail detail = 3;
+  }
+
+  // This message can indicate overall cpu
+  // utilization of codec framework threads.
+  message CpuUsage {
+    // name of process using codec framework
+    optional string process_name = 1;
+    // name of the codec thread
+    optional string thread_name = 2;
+    // was thread_cpu_us
+    reserved 3;
+    // total cpu usage of the codec thread
+    optional int64 thread_cpu_ns = 6;
+    // can be number of codec framework thread
+    optional uint32 num_threads = 4;
+    // core type data info used by codec thread
+    repeated AndroidCpuMetric.CoreTypeData core_data = 5;
+  }
+
+  repeated CpuUsage cpu_usage = 1;
+  repeated CodecFunction codec_function = 2;
+
+}
+
+// End of protos/perfetto/metrics/android/codec_metrics.proto
+
+// Begin of protos/perfetto/metrics/android/display_metrics.proto
+
+message AndroidDisplayMetrics {
+  // Stat that reports the number of duplicate frames submitted
+  // to the display for rendering. That is frames that have the same
+  // pixels values but where still submitted. It is tracked based on
+  // comparing the MISR of the current frame vs previous frame.
+  optional uint32 total_duplicate_frames = 1;
+
+  // Stat reports whether there is any duplicate_frames tracked
+  optional uint32 duplicate_frames_logged = 2;
+
+  // Stat that reports the number of dpu underrrun occurs count.
+  optional uint32 total_dpu_underrun_count = 3;
+
+
+  message RefreshRateStat {
+    // The refresh rate value (the number of frames per second)
+    optional uint32 refresh_rate_fps = 1;
+
+    // Calculate the number of refresh rate switches to this fps
+    optional uint32 count = 2;
+
+    // Calculate the total duration of refresh rate stays at this fps
+    optional double total_dur_ms = 3;
+
+    // Calculate the average duration of refresh rate stays at this fps
+    optional double avg_dur_ms = 4;
+  }
+
+  // Calculate the total number of refresh rate changes
+  optional uint32 refresh_rate_switches = 4;
+
+  // The statistics for each refresh rate value
+  repeated RefreshRateStat refresh_rate_stats = 5;
+
+  // Stats to measure the runtime of updating the power state in
+  // DisplayPowerController
+  message UpdatePowerState {
+    optional uint32 avg_runtime_micro_secs = 2;
+
+    // Removed: avg_runtime_ms
+    reserved 1;
+  }
+
+  optional UpdatePowerState update_power_state = 6;
+}
+
+// End of protos/perfetto/metrics/android/display_metrics.proto
+
+// Begin of protos/perfetto/metrics/android/dma_heap_metric.proto
+
+// dma-buf heap memory stats on Android.
+message AndroidDmaHeapMetric {
+    optional double avg_size_bytes = 1;
+    optional double min_size_bytes = 2;
+    optional double max_size_bytes = 3;
+
+    // Total allocation size.
+    // Essentially the sum of positive allocs.
+    optional double total_alloc_size_bytes = 4;
+}
+
+// End of protos/perfetto/metrics/android/dma_heap_metric.proto
+
+// Begin of protos/perfetto/metrics/android/dvfs_metric.proto
+
+message AndroidDvfsMetric {
+
+  message BandStat {
+    // Operating frequency
+    optional int32 freq_value = 1;
+
+    // Percentage of duration in this operating frequency compared to all frequencies
+    optional double percentage = 2;
+
+    // Total duration in ns when the state was in this operating frequency
+    optional int64 duration_ns = 3;
+  }
+
+  message FrequencyResidency {
+    // Frequency representative name
+    optional string freq_name = 1;
+    // Each band statistics meta
+    repeated BandStat band_stat = 2;
+  }
+
+  // Frequency residency metrics from clock_set_rate ftrace event.
+  repeated FrequencyResidency freq_residencies = 1;
+}
+
+// End of protos/perfetto/metrics/android/dvfs_metric.proto
+
+// Begin of protos/perfetto/metrics/android/fastrpc_metric.proto
+
+// fastrpc memory stats on Android.
+message AndroidFastrpcMetric {
+  message Subsystem {
+    optional string name = 1;
+    optional double avg_size_bytes = 2;
+    optional double min_size_bytes = 3;
+    optional double max_size_bytes = 4;
+
+    // Total allocation size.
+    // Essentially the sum of positive allocs.
+    optional double total_alloc_size_bytes = 5;
+  }
+
+  repeated Subsystem subsystem = 1;
+}
+
+// End of protos/perfetto/metrics/android/fastrpc_metric.proto
+
+// Begin of protos/perfetto/metrics/android/g2d_metric.proto
+
+message G2dMetrics {
+  message G2dInstance {
+    // G2d name.
+    optional string name = 1;
+
+    optional uint32 frame_count = 5;
+    optional uint32 error_count = 6;
+
+    optional double max_dur_ms = 7;
+    optional double min_dur_ms = 8;
+    optional double avg_dur_ms = 9;
+
+    // Removed: was int64 versions of max_dur_ns, min_dur_ns and avg_dur_ns.
+    reserved 2 to 4;
+  }
+  message G2dMetric {
+    // G2D Metric for each G2D Instance.
+    repeated G2dInstance instances = 1;
+
+    // the number of frames processed by G2D
+    optional uint32 frame_count = 5;
+    // the number of error events
+    optional uint32 error_count = 6;
+
+    // max/min/avg G2d frame durations for all instances.
+    optional double max_dur_ms = 7;
+    optional double min_dur_ms = 8;
+    optional double avg_dur_ms = 9;
+
+    // Removed: was int64 versions of max_dur_ns, min_dur_ns and avg_dur_ns.
+    reserved 2 to 4;
+  }
+
+  optional G2dMetric g2d_hw = 1;
+  optional G2dMetric g2d_sw = 2;
+}
+
+// End of protos/perfetto/metrics/android/g2d_metric.proto
+
+// Begin of protos/perfetto/metrics/android/gpu_metric.proto
+
+message AndroidGpuMetric {
+  message Process {
+    // Process name.
+    optional string name = 1;
+
+    // max/min/avg GPU memory used by this process.
+    optional int64 mem_max = 2;
+    optional int64 mem_min = 3;
+    optional int64 mem_avg = 4;
+  }
+
+  // GPU metric for processes using GPU.
+  repeated Process processes = 1;
+
+  // max/min/avg GPU memory used by the entire system.
+  optional int64 mem_max = 2;
+  optional int64 mem_min = 3;
+  optional int64 mem_avg = 4;
+
+  message FrequencyMetric {
+    // Identifier for GPU in a multi-gpu device.
+    optional uint32 gpu_id = 1;
+
+    // max/min/avg GPU frequency for this gpu_id
+    // the calculation of avg is weighted by the duration of each frequency
+    optional int64 freq_max = 2;
+    optional int64 freq_min = 3;
+    optional double freq_avg = 4;
+
+    message MetricsPerFrequency {
+      // Used frequency
+      optional int64 freq = 1;
+
+      // Total duration in ms when the state of GPU was in this frequency
+      optional double dur_ms = 2;
+
+      // Percentage of duration in this frequency compared to all frequencies
+      // in this gpu_id
+      optional double percentage = 3;
+    }
+
+    // Metrics for each used GPU frequency
+    repeated MetricsPerFrequency used_freqs = 5;
+  }
+
+  // GPU frequency metric for each gpu_id
+  repeated FrequencyMetric freq_metrics = 5;
+}
+
+// End of protos/perfetto/metrics/android/gpu_metric.proto
+
+// Begin of protos/perfetto/metrics/android/hwcomposer.proto
+
+message AndroidHwcomposerMetrics {
+  // Counts the number of composition total layers in the trace. (non-weighted average)
+  optional double composition_total_layers = 1;
+
+  // Counts the number of composition dpu layers in the trace. (non-weighted average)
+  optional double composition_dpu_layers = 2;
+
+  // Counts the number of composition gpu layers in the trace. (non-weighted average)
+  optional double composition_gpu_layers = 3;
+
+  // Counts the number of composition dpu cached layers in the trace. (non-weighted average)
+  optional double composition_dpu_cached_layers = 4;
+
+  // Counts the number of composition surfaceflinger cached layers in the trace.
+  // (non-weighted average)
+  optional double composition_sf_cached_layers = 5;
+
+  // Counts the number of composition rounded corner decoration layers in the trace.
+  // (non-weighted average)
+  optional double composition_rcd_layers = 15;
+
+  // Counts how many times validateDisplay is skipped.
+  optional int32 skipped_validation_count = 6;
+
+  // Counts how many times validateDisplay cannot be skipped.
+  optional int32 unskipped_validation_count = 7;
+
+  // Counts how many times validateDisplay is already separated from presentDisplay
+  // since the beginning.
+  optional int32 separated_validation_count = 8;
+
+  // Counts how many unhandled validation cases which might be caused by errors.
+  optional int32 unknown_validation_count = 9;
+
+  // the average of overall hwcomposer execution time.
+  optional double avg_all_execution_time_ms = 10;
+
+  // the average of hwcomposer execution time for skipped validation cases.
+  optional double avg_skipped_execution_time_ms = 11;
+
+  // the average of hwcomposer execution time for unskipped validation cases.
+  optional double avg_unskipped_execution_time_ms = 12;
+
+  // the average of hwcomposer execution time for separated validation cases.
+  optional double avg_separated_execution_time_ms = 13;
+
+  message DpuVoteMetrics {
+    // the thread ID that handles this track
+    optional uint32 tid = 1;
+
+    // the weighted average of DPU Vote Clock
+    optional double avg_dpu_vote_clock = 2;
+
+    // the weighted average of DPU Vote Avg Bandwidth
+    optional double avg_dpu_vote_avg_bw = 3;
+
+    // the weighted average of DPU Vote Peak Bandwidth
+    optional double avg_dpu_vote_peak_bw = 4;
+
+    // the weighted average of DPU Vote RT (Real Time) Bandwidth
+    optional double avg_dpu_vote_rt_bw = 5;
+  }
+
+  // DPU Vote Metrics for each thread track
+  repeated DpuVoteMetrics dpu_vote_metrics = 14;
+
+  message MetricsPerDisplay {
+    // Display ID in HWC
+    optional string display_id = 1;
+
+    // Counts the number of composition total layers in the trace. (non-weighted average)
+    optional double composition_total_layers = 2;
+
+    // Counts the number of composition dpu layers in the trace. (non-weighted average)
+    optional double composition_dpu_layers = 3;
+
+    // Counts the number of composition gpu layers in the trace. (non-weighted average)
+    optional double composition_gpu_layers = 4;
+
+    // Counts the number of composition dpu cached layers in the trace. (non-weighted average)
+    optional double composition_dpu_cached_layers = 5;
+
+    // Counts the number of composition surfaceflinger cached layers in the trace.
+    // (non-weighted average)
+    optional double composition_sf_cached_layers = 6;
+
+    // Counts the number of composition rounded corner decoration layers in the trace.
+    // (non-weighted average)
+    optional double composition_rcd_layers = 7;
+
+    // Counts how many times validateDisplay is skipped.
+    optional int32 skipped_validation_count = 8;
+
+    // Counts how many times validateDisplay cannot be skipped.
+    optional int32 unskipped_validation_count = 9;
+
+    // Counts how many times validateDisplay is already separated from presentDisplay
+    // since the beginning.
+    optional int32 separated_validation_count = 10;
+
+    // Counts how many unhandled validation cases which might be caused by errors.
+    optional int32 unknown_validation_count = 11;
+
+    // the average of overall hwcomposer execution time.
+    optional double avg_all_execution_time_ms = 12;
+
+    // the average of hwcomposer execution time for skipped validation cases.
+    optional double avg_skipped_execution_time_ms = 13;
+
+    // the average of hwcomposer execution time for unskipped validation cases.
+    optional double avg_unskipped_execution_time_ms = 14;
+
+    // the average of hwcomposer execution time for separated validation cases.
+    optional double avg_separated_execution_time_ms = 15;
+  }
+
+  repeated MetricsPerDisplay metrics_per_display = 16;
+}
+
+// End of protos/perfetto/metrics/android/hwcomposer.proto
+
+// Begin of protos/perfetto/metrics/android/hwui_metric.proto
+
+// Android HWUI graphics performance and graphics memory usage metrics.
+message ProcessRenderInfo {
+  // Name of the package launched
+  optional string process_name = 1;
+
+  // CPU time spent on RenderThread in milliseconds.
+  optional int64 rt_cpu_time_ms = 2;
+
+  // Number of frames drawn on RenderThread, followed by max/min/avg CPU time to draw a frame
+  // in nanoseconds.
+  optional uint32 draw_frame_count = 3;
+  optional int64 draw_frame_max = 4;
+  optional int64 draw_frame_min = 5;
+  optional double draw_frame_avg = 6;
+
+  // Number of GPU commands flushes and max/min/avg time per flush in nanoseconds.
+  optional uint32 flush_count = 7;
+  optional int64 flush_max = 8;
+  optional int64 flush_min = 9;
+  optional double flush_avg = 10;
+
+  // Number of View tree preparation counts and max/min/avg time to traverse the tree in
+  // nanoseconds.
+  optional uint32 prepare_tree_count = 11;
+  optional int64 prepare_tree_max = 12;
+  optional int64 prepare_tree_min = 13;
+  optional double prepare_tree_avg = 14;
+
+  // Number of times the GPU rendered a frame and max/min/avg time for GPU to finish rendering in
+  // in nanoseconds.
+  optional uint32 gpu_completion_count = 15;
+  optional int64 gpu_completion_max = 16;
+  optional int64 gpu_completion_min = 17;
+  optional double gpu_completion_avg = 18;
+
+  // Number of times a frame was recorded/serialized in a display list on the UI thread with
+  // max/min/avg time in nanoseconds.
+  optional uint32 ui_record_count = 19;
+  optional int64 ui_record_max = 20;
+  optional int64 ui_record_min = 21;
+  optional double ui_record_avg = 22;
+
+  // number of unique shader programs that were used to render frames, followed by total and average
+  // times to prepare a shader in nanoseconds.
+  optional uint32 shader_compile_count = 23;
+  optional int64 shader_compile_time = 24;
+  optional double shader_compile_avg = 25;
+  // number of shader programs loaded from the disk cache, followed by total time and average time
+  // to prepare a shader in nanoseconds.
+  optional uint32 cache_hit_count = 26;
+  optional int64 cache_hit_time = 27;
+  optional double cache_hit_avg = 28;
+  // number of shader programs compiled/linked, followed by total time and average time to prepare
+  // a shader in nanoseconds.
+  optional uint32 cache_miss_count = 29;
+  optional int64 cache_miss_time = 30;
+  optional double cache_miss_avg = 31;
+
+  // max/min/avg CPU memory used for graphics by HWUI at the end of a frame.
+  optional int64 graphics_cpu_mem_max = 32;
+  optional int64 graphics_cpu_mem_min = 33;
+  optional double graphics_cpu_mem_avg = 34;
+
+  // max/min/avg GPU memory used by HWUI at the end of a frame excluding textures.
+  optional int64 graphics_gpu_mem_max = 35;
+  optional int64 graphics_gpu_mem_min = 36;
+  optional double graphics_gpu_mem_avg = 37;
+
+  // max/min/avg memory used for GPU textures by HWUI at the end of a frame.
+  optional int64 texture_mem_max = 38;
+  optional int64 texture_mem_min = 39;
+  optional double texture_mem_avg = 40;
+
+  // max/min/avg memory used by HWUI at the end of a frame. This is a sum of previous 3 categories.
+  optional int64 all_mem_max = 41;
+  optional int64 all_mem_min = 42;
+  optional double all_mem_avg = 43;
+}
+
+message AndroidHwuiMetric {
+  //  HWUI metrics for processes that have a RenderThread.
+  repeated ProcessRenderInfo process_info = 1;
+}
+
+// End of protos/perfetto/metrics/android/hwui_metric.proto
+
+// Begin of protos/perfetto/metrics/android/io_metric.proto
+
+// Measure Android IO stats in a trace.
+// Note: This is an aggregated metric, for unaggregated metrics look at AndroidIoUnaggregated
+// in io_unagg_metric.proto.
+message AndroidIo {
+  // Next id: 3
+  // Stats for Counters in an f2fs file system.
+  // Counters are available for various operations.
+  message F2fsCounterStats {
+    optional string name = 1;
+    optional double max = 2;
+    optional double sum = 3;
+    optional double min = 5;
+    optional int64 dur = 6;
+    optional int64 count = 7;
+    optional double avg = 8;
+  }
+  // Aggregated stats for write operations in an f2fs file system.
+  message F2fsWriteStats {
+    optional int64 total_write_count = 1;
+    optional int64 distinct_processes = 2;
+    optional int64 total_bytes_written = 3;
+    optional int64 distinct_device_count = 4;
+    optional int64 distict_inode_count = 5;
+    optional int64 distinct_thread_count = 6;
+  }
+  repeated F2fsCounterStats f2fs_counter_stats = 1;
+  repeated F2fsWriteStats f2fs_write_stats = 2;
+}
+
+// End of protos/perfetto/metrics/android/io_metric.proto
+
+// Begin of protos/perfetto/metrics/android/io_unagg_metric.proto
+
+// IO metrics on Android in unaggregated form.
+// Note: this generates a lot of data so should not be requested unless it
+// is clear that this data is necessary.
+message AndroidIoUnaggregated {
+    // Next id: 2
+    message F2fsWriteUnaggreagatedStat {
+      optional uint32 tid = 1;
+      optional string thread_name = 2;
+      optional uint32 pid = 3;
+      optional string process_name = 4;
+      optional int64 ino = 5;
+      optional int64 dev = 6;
+    }
+    // F2fs write stats which are grouped by thread and inode.
+    repeated F2fsWriteUnaggreagatedStat f2fs_write_unaggregated_stats = 1;
+}
+// End of protos/perfetto/metrics/android/io_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/ion_metric.proto
+
+// ion memory stats on Android.
+message AndroidIonMetric {
+  message Buffer {
+    optional string name = 1;
+    optional double avg_size_bytes = 2;
+    optional double min_size_bytes = 3;
+    optional double max_size_bytes = 4;
+
+    // Total allocation size.
+    // Essentially the sum of positive allocs (-> new buffers).
+    optional double total_alloc_size_bytes = 5;
+  }
+
+  repeated Buffer buffer = 1;
+}
+
+// End of protos/perfetto/metrics/android/ion_metric.proto
+
+// Begin of protos/perfetto/metrics/android/irq_runtime_metric.proto
+
+// measure max IRQ runtime and IRQ tasks running over threshold.
+message AndroidIrqRuntimeMetric {
+  message IrqSlice {
+    // IRQ name
+    optional string irq_name = 1;
+    // timestamp
+    optional int64 ts = 2;
+    // runtime of IRQ task
+    optional int64 dur = 3;
+  }
+  message ThresholdMetric {
+    // Threshold value
+    optional string threshold = 1;
+    // over threshold count
+    optional int64 over_threshold_count = 2;
+    // anomaly ratio (over threshold count / total count)
+    optional double anomaly_ratio= 3;
+  }
+  message IrqRuntimeMetric {
+    // max runtime of IRQ tasks
+    optional int64 max_runtime = 1;
+    // total IRQ tasks
+    optional int64 total_count = 2;
+    // over threshold metric
+    optional ThresholdMetric threshold_metric = 3;
+    // information for top 10 IRQ tasks
+    repeated IrqSlice longest_irq_slices = 4;
+  }
+
+  // metrics for hardirq and softirq
+  optional IrqRuntimeMetric hw_irq = 1;
+  optional IrqRuntimeMetric sw_irq = 2;
+}
+
+
+// End of protos/perfetto/metrics/android/irq_runtime_metric.proto
+
+// Begin of protos/perfetto/metrics/android/jank_cuj_metric.proto
+
+message AndroidJankCujMetric {
+  repeated Cuj cuj = 1;
+
+  // Next id: 12
+  message Cuj {
+    // ID of the CUJ that is unique within the trace.
+    optional int32 id = 1;
+
+    // Name of the CUJ, extracted from the CUJ trace marker.
+    // For example SHADE_EXPAND_COLLAPSE from J<SHADE_EXPAND_COLLAPSE>.
+    optional string name = 2;
+
+    // Details about the process (uid, version, etc)
+    optional AndroidProcessMetadata process = 3;
+
+    // ts of the CUJ trace marker slice.
+    optional int64 ts = 4;
+
+    // dur of the CUJ trace marker slice.
+    optional int64 dur = 5;
+
+    // Details about each of the frames within the CUJ.
+    repeated Frame frame = 6;
+
+    // Details about each of the SF frames within the CUJ.
+    repeated Frame sf_frame = 10;
+
+    // Metrics extracted from the counters output by FrameTracker
+    // Does not contain the frame_dur percentile information.
+    optional Metrics counter_metrics = 7;
+
+    // Metrics extracted from the frame timeline.
+    optional Metrics timeline_metrics = 8;
+
+    // Metrics extracted from the trace slices.
+    optional Metrics trace_metrics = 9;
+
+    // Layer name of the surface where the cuj is drawn.
+    optional string layer_name = 11;
+  }
+
+  // Next id: 10
+  message Frame {
+    // Index of the frame within the single user journey.
+    optional int64 frame_number = 1;
+
+    // VSYNC ID of the frame.
+    optional int64 vsync = 2;
+
+    optional int64 ts = 3;
+    optional int64 dur = 4;
+    optional int64 dur_expected = 7;
+
+    // Whether the app process missed the frame deadline.
+    // Only set for the App frames. Always left unset for SF frames.
+    optional bool app_missed = 5;
+
+    // Whether SF missed the frame deadline.
+    optional bool sf_missed = 6;
+
+    // Whether the SF callback missed before emitting jank metrics.
+    // SF callback is used to get the jank classification.
+    optional bool sf_callback_missed = 8;
+
+    // Whether the HWUI callback missed before emitting jank metrics.
+    // HWUI callback is used to get the frame duration.
+    optional bool hwui_callback_missed = 9;
+  }
+
+  // Next id: 18
+  message Metrics {
+    // Overall number of frames within the CUJ.
+    optional int64 total_frames = 1;
+
+    // Number of missed frames.
+    optional int64 missed_frames = 2;
+
+    // Number of frames missed due to the app missing the deadline.
+    optional int64 missed_app_frames = 3;
+
+    // Number of frames missed due to SF.
+    optional int64 missed_sf_frames = 4;
+
+    // Number of successive frames missed.
+    // Not available in timeline_metrics and trace_metrics.
+    optional int64 missed_frames_max_successive = 5;
+
+    // Max frame duration in nanoseconds.
+    optional int64 frame_dur_max = 6;
+
+    // Average frame duration in nanoseconds.
+    // Not available in counter_metrics.
+    optional int64 frame_dur_avg = 7;
+
+    // Median frame duration in nanoseconds.
+    // Not available in counter_metrics.
+    optional int64 frame_dur_p50 = 8;
+
+    // P90 frame duration in nanoseconds.
+    // Not available in counter_metrics.
+    optional int64 frame_dur_p90 = 9;
+
+    // P95 frame duration in nanoseconds.
+    // Not available in counter_metrics.
+    optional int64 frame_dur_p95 = 10;
+
+    // P99 frame duration in nanoseconds.
+    // Not available in counter_metrics.
+    optional int64 frame_dur_p99 = 11;
+
+    // Median frame duration in milliseconds.
+    // Not available in counter_metrics.
+    optional double frame_dur_ms_p50 = 12;
+
+    // P90 frame duration in milliseconds.
+    // Not available in counter_metrics.
+    optional double frame_dur_ms_p90 = 13;
+
+    // P95 frame duration in milliseconds.
+    // Not available in counter_metrics.
+    optional double frame_dur_ms_p95 = 14;
+
+    // P99 frame duration in milliseconds.
+    // Not available in counter_metrics.
+    optional double frame_dur_ms_p99 = 15;
+
+    // Number of frames with missed SF callback.
+    optional int64 sf_callback_missed_frames = 16;
+
+    // Number of frames with missed HWUI callback.
+    optional int64 hwui_callback_missed_frames = 17;
+  }
+}
+
+// End of protos/perfetto/metrics/android/jank_cuj_metric.proto
+
+// Begin of protos/perfetto/metrics/android/java_heap_histogram.proto
+
+message JavaHeapHistogram {
+  // Next id: 9
+  message TypeCount {
+    optional string type_name = 1;
+    optional string category = 4;
+
+    optional uint32 obj_count = 2;
+    optional uint32 reachable_obj_count = 3;
+
+    optional uint32 size_kb = 5;
+    optional uint32 reachable_size_kb = 6;
+    optional uint32 native_size_kb = 7;
+    optional uint32 reachable_native_size_kb = 8;
+  }
+
+  message Sample {
+    optional int64 ts = 1;
+    repeated TypeCount type_count = 2;
+  }
+
+  // Heap stats per process. One sample per dump (with continuous dump you can
+  // have more samples differentiated by ts).
+  message InstanceStats {
+    optional uint32 upid = 1;
+    optional AndroidProcessMetadata process = 2;
+    repeated Sample samples = 3;
+  }
+
+  repeated InstanceStats instance_stats = 1;
+}
+
+// End of protos/perfetto/metrics/android/java_heap_histogram.proto
+
+// Begin of protos/perfetto/metrics/android/java_heap_stats.proto
+
+message JavaHeapStats {
+  message HeapRoots {
+    optional string root_type = 1;
+    optional string type_name = 2;
+    optional int64 obj_count = 3;
+  }
+
+  // Next id: 11
+  message Sample {
+    optional int64 ts = 1;
+    // Size of the Java heap in bytes
+    optional int64 heap_size = 2;
+    // Native size of all the objects (not included in heap_size)
+    optional int64 heap_native_size = 8;
+    optional int64 obj_count = 4;
+    // Size of the reachable objects in bytes.
+    optional int64 reachable_heap_size = 3;
+    // Native size of all the reachable objects (not included in
+    // reachable_heap_size)
+    optional int64 reachable_heap_native_size = 9;
+    optional int64 reachable_obj_count = 5;
+    // Sum of anonymous RSS + swap pages in bytes.
+    optional int64 anon_rss_and_swap_size = 6;
+
+    // ART root objects
+    repeated HeapRoots roots = 7;
+    // OOM adjustment score
+    optional int64 oom_score_adj = 10;
+  }
+
+  // Heap stats per process. One sample per dump (can be > 1 if continuous
+  // dump is enabled).
+  message InstanceStats {
+    optional uint32 upid = 1;
+    optional AndroidProcessMetadata process = 2;
+    repeated Sample samples = 3;
+  }
+
+  repeated InstanceStats instance_stats = 1;
+}
+
+// End of protos/perfetto/metrics/android/java_heap_stats.proto
+
+// Begin of protos/perfetto/metrics/android/lmk_metric.proto
+
+// LMK stats on Android.
+message AndroidLmkMetric {
+  message ByOomScore {
+    optional int32 oom_score_adj = 1;
+    optional int32 count = 2;
+  }
+
+  // Total count of LMK events observed in the trace.
+  optional int32 total_count = 1;
+  repeated ByOomScore by_oom_score = 2;
+
+  // OOM reaper kills. Enabled via the oom/mark_victim point. Should never
+  // happen.
+  optional int32 oom_victim_count = 3;
+}
+
+// End of protos/perfetto/metrics/android/lmk_metric.proto
+
+// Begin of protos/perfetto/metrics/android/lmk_reason_metric.proto
+
+// Global process state at LMK time, used to identify potential culprits.
+// TODO: rename to AndroidLmkProcessState
+message AndroidLmkReasonMetric {
+  message Process {
+    optional AndroidProcessMetadata process = 1;
+
+    // OOM score adj of the process.
+    optional int32 oom_score_adj = 2;
+
+    // RSS + swap.
+    optional int64 size = 3;
+
+    optional int64 file_rss_bytes = 4;
+    optional int64 anon_rss_bytes = 5;
+    optional int64 shmem_rss_bytes = 6;
+    optional int64 swap_bytes = 7;
+  }
+  message Lmk {
+    // OOM score adj of the LMK'ed process.
+    optional int32 oom_score_adj = 1;
+
+    // Total size of the ION heap in bytes during this LMK.
+    optional int64 ion_heaps_bytes = 4;
+    // Deprecated. Prefer ion_heaps_bytes.
+    optional int64 system_ion_heap_size = 2;
+
+    // Processes present during this LMK.
+    repeated Process processes = 3;
+  }
+
+  // LMKs present in the trace, ordered on their timestamp.
+  repeated Lmk lmks = 1;
+}
+
+// End of protos/perfetto/metrics/android/lmk_reason_metric.proto
+
+// Begin of protos/perfetto/metrics/android/mem_metric.proto
+
+// Memory metrics on Android.
+message AndroidMemoryMetric {
+  message ProcessMetrics {
+    optional string process_name = 1;
+    optional ProcessMemoryCounters total_counters = 2;
+    repeated PriorityBreakdown priority_breakdown = 3;
+  }
+
+  message PriorityBreakdown {
+    optional string priority = 1;
+    optional ProcessMemoryCounters counters = 2;
+  }
+
+  message ProcessMemoryCounters {
+    optional Counter anon_rss = 1;
+    optional Counter file_rss = 2;
+    optional Counter swap = 3;
+    optional Counter anon_and_swap = 4;
+
+    // Available when ART trace events are available.
+    optional Counter java_heap = 5;
+  }
+
+  message Counter {
+    optional double min = 1;
+    optional double max = 2;
+    optional double avg = 3;
+
+    // Memory growth observed in the counter sequence. In case of multiple
+    // processes with the same name, break ties using max.
+    optional double delta = 4;
+  }
+
+  // Process metrics, grouped by process name
+  repeated ProcessMetrics process_metrics = 1;
+}
+
+// End of protos/perfetto/metrics/android/mem_metric.proto
+
+// Begin of protos/perfetto/metrics/android/mem_unagg_metric.proto
+
+// Unaggregated memory metrics on Android.
+message AndroidMemoryUnaggregatedMetric {
+  message ProcessValues {
+    optional string process_name = 1;
+    optional ProcessMemoryValues mem_values = 2;
+  }
+
+  message ProcessMemoryValues {
+    repeated Value anon_rss = 1;
+    repeated Value file_rss = 2;
+    repeated Value swap = 3;
+    repeated Value anon_and_swap = 4;
+  }
+
+  message Value {
+    optional int64 ts = 1;
+    optional int32 oom_score = 2;
+    optional double value = 3;
+  }
+
+  // Process metrics for every process instance in trace.
+  repeated ProcessValues process_values = 1;
+}
+
+// End of protos/perfetto/metrics/android/mem_unagg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/monitor_contention_agg_metric.proto
+
+ // This metric provides aggregated information about monitor contention graph
+ // in a trace
+message AndroidMonitorContentionAggMetric {
+  // Next id: 2
+  // Stats for Monitor contention aggregated by process.
+  message ProcessAggregation {
+    optional string name = 1;
+    optional int64 total_contention_count = 2;
+    optional int64 total_contention_dur = 3;
+    optional int64 main_thread_contention_count = 4;
+    optional int64 main_thread_contention_dur = 5;
+  }
+  repeated ProcessAggregation process_aggregation = 1;
+}
+
+// End of protos/perfetto/metrics/android/monitor_contention_agg_metric.proto
+
+// Begin of protos/perfetto/metrics/android/monitor_contention_metric.proto
+
+// This metric provides information about the monitor contention graph in a
+// trace
+message AndroidMonitorContentionMetric {
+  // Next field id: 26
+  message Node {
+    // Global context
+    optional int64 node_parent_id = 1;
+    optional int64 node_child_id = 24;
+    optional int64 node_id = 2;
+    optional int64 ts = 3;
+    optional int64 dur = 4;
+    optional int64 monotonic_dur = 25;
+    optional string process_name = 14;
+    optional uint32 pid = 23;
+    optional uint32 waiter_count = 11;
+    repeated ThreadStateBreakdown thread_states = 19;
+    repeated BlockedFunctionBreakdown blocked_functions = 20;
+
+    // Blocking context
+    optional string blocking_method = 5;
+    optional string short_blocking_method = 7;
+    optional string blocking_src = 9;
+    optional string blocking_thread_name = 13;
+    optional bool is_blocking_thread_main = 16;
+    optional uint32 blocking_thread_tid = 22;
+
+    // Blocked context
+    optional string blocked_method = 6;
+    optional string short_blocked_method = 8;
+    optional string blocked_src = 10;
+    optional string blocked_thread_name = 12;
+    optional bool is_blocked_thread_main = 15;
+    optional uint32 blocked_thread_tid = 21;
+
+    // Binder context
+    optional int64 binder_reply_ts = 17;
+    optional uint32 binder_reply_tid = 18;
+  }
+
+  message ThreadStateBreakdown {
+    optional string thread_state = 1;
+    optional int64 thread_state_dur = 2;
+    optional int64 thread_state_count = 3;
+  }
+
+  message BlockedFunctionBreakdown {
+    optional string blocked_function = 1;
+    optional int64 blocked_function_dur = 2;
+    optional int64 blocked_function_count = 3;
+  }
+
+  repeated Node node = 1;
+}
+
+// End of protos/perfetto/metrics/android/monitor_contention_metric.proto
+
+// Begin of protos/perfetto/metrics/android/multiuser_metric.proto
+
+// Metrics for Multiuser events, such as switching users.
+message AndroidMultiuserMetric {
+
+  // Holds the data for a Multiuser event.
+  message EventData {
+    // Duration of the event (in milliseconds).
+    optional int32 duration_ms = 1;
+
+    // CPU usage of each process during the event.
+    message CpuUsage {
+      // The userId of the process (e.g. 0 or 10).
+      optional int32 user_id = 1;
+      // The name of the process.
+      optional string process_name = 2;
+      // The number of CPU cycles (in megacycles) spent by that process during the event.
+      optional int32 cpu_mcycles = 3;
+      // The ratio of this process's cycles to the total for all processes, expressed as a percentage.
+      optional float cpu_percentage = 4;
+      // General identifier for this usage source: determined from the process name, user, etc.
+      // Should be stable across multiple runs (i.e. does not print the user_id directly).
+      optional string identifier = 5;
+    }
+    repeated CpuUsage cpu_usage = 2;
+  }
+
+  // Metrics for a user switch.
+  optional EventData user_switch = 1;
+}
+// End of protos/perfetto/metrics/android/multiuser_metric.proto
+
+// Begin of protos/perfetto/metrics/android/network_metric.proto
+
+message AndroidNetworkMetric {
+  message PacketStatistic {
+    // Packet count.
+    optional int64 packets = 1;
+
+    // Packet Bytes.
+    optional int64 bytes = 2;
+
+    // Timestamp when first packet received or transmitted.
+    optional int64 first_packet_timestamp_ns = 3;
+
+    // Timestamp when last packet received or transmitted.
+    optional int64 last_packet_timestamp_ns = 4;
+
+    // Interval between first & last packet. The minimum interval is 10ms.
+    optional int64 interval_ns = 5;
+
+    // Data Speed.
+    optional double data_rate_kbps = 6;
+  }
+
+  message CorePacketStatistic {
+    optional uint32 id = 1;
+    optional PacketStatistic packet_statistic = 2;
+  }
+
+  message Rx {
+    // Total packets statistic.
+    optional PacketStatistic total = 1;
+
+    // Per core packets statistic.
+    repeated CorePacketStatistic core = 2;
+
+    // GRO aggregation ratio.
+    optional string gro_aggregation_ratio = 3;
+  }
+
+  message Tx {
+    // Total packets statistic.
+    optional PacketStatistic total = 1;
+
+    // Per core packets statistic.
+    repeated CorePacketStatistic core = 2;
+  }
+
+  message NetDevice {
+    // Network device name.
+    optional string name = 1;
+
+    // Ingress traffic statistic.
+    optional Rx rx = 2;
+
+    // Egress traffic statistic
+    optional Tx tx = 3;
+  }
+
+  message NetRxActionStatistic {
+    // SoftIrq NET_RX action count.
+    optional int64 count = 1;
+
+    // SoftIrq NET_RX action was running in millisecond.
+    optional double runtime_ms = 2;
+
+    // SoftIrq NET_RX action average running time.
+    optional double avg_runtime_ms = 3;
+
+    // CPU megacycles (i.e. cycles divided by 1e6).
+    optional int64 mcycles = 4;
+
+    // Average weighted CPU frequency by the time the NET_RX Action
+    // running at each frequency.
+    optional int64 avg_freq_khz = 5;
+  }
+
+  message NetTxActionStatistic {
+    // SoftIrq NET_TX action count.
+    optional int64 count = 1;
+
+    // SoftIrq NET_TX action was running in millisecond.
+    optional double runtime_ms = 2;
+
+    // SoftIrq NET_TX action average running time.
+    optional double avg_runtime_ms = 3;
+
+    // CPU megacycles (i.e. cycles divided by 1e6).
+    optional int64 mcycles = 4;
+
+    // Average weighted CPU frequency by the time the NET_TX Action
+    // running at each frequency.
+    optional int64 avg_freq_khz = 5;
+  }
+
+  message IpiActionStatistic {
+    // SoftIrq IPI action count.
+    optional int64 count = 1;
+
+    // SoftIrq IPI action was running in millisecond.
+    optional double runtime_ms = 2;
+
+    // SoftIrq IPI action average running time.
+    optional double avg_runtime_ms = 3;
+  }
+
+  message CoreNetRxActionStatistic {
+    optional uint32 id = 1;
+    optional NetRxActionStatistic net_rx_action_statistic = 2;
+  }
+
+  message CoreNetTxActionStatistic {
+    optional uint32 id = 1;
+    optional NetTxActionStatistic net_tx_action_statistic = 2;
+  }
+
+  message NetRxAction {
+    // Total NET_RX action statistics.
+    optional NetRxActionStatistic total = 1;
+
+    // Per core NET_RX action statistics.
+    repeated CoreNetRxActionStatistic core = 2;
+
+    // The average packet time moves through the kernel stack.
+    optional double avg_interstack_latency_ms = 3;
+  }
+
+  message NetTxAction {
+    // Total NET_TX action statistics.
+    optional NetTxActionStatistic total = 1;
+
+    // Per core NET_TX action statistics.
+    repeated CoreNetTxActionStatistic core = 2;
+  }
+
+  message IpiAction {
+    // Total IPI action statistics.
+    optional IpiActionStatistic total = 1;
+  }
+
+  // Network device metrics.
+  repeated NetDevice net_devices = 1;
+
+  // SoftIrq NET_RX action metrics.
+  optional NetRxAction net_rx_action = 2;
+
+  // Packet retransmission rate.
+  optional double retransmission_rate = 3;
+
+  // Kfree Skb rate (i.e. kfree_skb count divided by the packet count from all
+  // net devices).
+  optional double kfree_skb_rate = 4;
+
+  // SoftIrq NET_TX action metrics.
+  optional NetTxAction net_tx_action = 5;
+
+  // SoftIrq IPI action metrics.
+  optional IpiAction ipi_action = 6;
+}
+
+// End of protos/perfetto/metrics/android/network_metric.proto
+
+// Begin of protos/perfetto/metrics/android/other_traces.proto
+
+message AndroidOtherTracesMetric {
+  // Uuids of other traces being finalized while the current trace was being
+  // recorded.
+  repeated string finalized_traces_uuid = 1;
+}
+
+// End of protos/perfetto/metrics/android/other_traces.proto
+
+// Begin of protos/perfetto/metrics/android/package_list.proto
+
+message AndroidPackageList {
+  message Package {
+    optional string package_name = 1;
+    optional int64 uid = 2;
+    optional int64 version_code = 3;
+  }
+
+  repeated Package packages = 1;
+}
+
+// End of protos/perfetto/metrics/android/package_list.proto
+
+// Begin of protos/perfetto/metrics/android/powrails_metric.proto
+
+message AndroidPowerRails {
+  // Energy data per Power Rail at given ts.
+  message EnergyData {
+    // Time since device boot(CLOCK_BOTTOMTIME) in milli-seconds.
+    optional int64 timestamp_ms = 1;
+    // Accumulated energy since device boot in microwatt-seconds(uws).
+    optional double energy_uws = 2;
+  }
+
+  message PowerRails {
+    // Name of the rail.
+    optional string name = 1;
+    // Energy data for given rail and for all samples in the trace.
+    repeated EnergyData energy_data = 2;
+    // The average used power between the first and the last sampled
+    // energy data in miliwatt (mw)
+    optional double avg_used_power_mw = 3;
+  }
+
+  // Energy data per Power Rail.
+  repeated PowerRails power_rails = 1;
+
+  // The average used power between the first and last sampled rail across all
+  // the rails in milliwatts (mw).
+  optional double avg_total_used_power_mw = 2;
+}
+// End of protos/perfetto/metrics/android/powrails_metric.proto
+
+// Begin of protos/perfetto/metrics/android/profiler_smaps.proto
+
+message ProfilerSmaps {
+  message Mapping {
+    optional string path = 1;
+    optional int32 size_kb = 2;
+    optional int32 private_dirty_kb = 3;
+    optional int32 swap_kb = 4;
+  }
+
+  message Instance {
+    optional AndroidProcessMetadata process = 1;
+    repeated Mapping mappings = 2;
+  }
+
+  repeated Instance instance = 1;
+}
+
+// End of protos/perfetto/metrics/android/profiler_smaps.proto
+
+// Begin of protos/perfetto/metrics/android/rt_runtime_metric.proto
+
+// measure max RT runtime and RT tasks running over 5ms.
+message AndroidRtRuntimeMetric {
+  message RtSlice {
+    // thread name
+    optional string tname = 1;
+    // timestamp
+    optional int64 ts = 2;
+    // runtime of RT task
+    optional int64 dur = 3;
+  }
+
+  // max runtime of RT tasks
+  optional int64 max_runtime = 1;
+  // how many RT tasks are over 5ms.
+  optional int64 over_5ms_count = 2;
+  // information for top 10 RT tasks
+  repeated RtSlice longest_rt_slices = 3;
+}
+
+
+// End of protos/perfetto/metrics/android/rt_runtime_metric.proto
+
+// Begin of protos/perfetto/metrics/android/simpleperf.proto
+
+// Metric that stores information related to atrace events generated by
+// simpleperf tool
+message AndroidSimpleperfMetric {
+  optional double urgent_ratio = 1;
+
+  message PerfEventMetric {
+    // Simpleperf event name
+    optional string name = 1;
+
+    message Thread {
+      // Thread ID
+      optional int32 tid = 1;
+      // Thread name
+      optional string name = 2;
+      // CPU ID
+      optional int32 cpu = 3;
+      // Total counter value
+      optional double total = 4;
+    }
+
+    message Process {
+      // Process ID
+      optional int32 pid = 1;
+      // Process name
+      optional string name = 2;
+      // Metrics for each thread in this process.
+      repeated Thread threads = 3;
+      // Total counter value over all threads in this process
+      optional double total = 4;
+    }
+
+    // Metrics for each process
+    repeated Process processes = 2;
+
+    // Total counter value over all processes and threads
+    optional double total = 3;
+  }
+
+  repeated PerfEventMetric events = 2;
+}
+
+// End of protos/perfetto/metrics/android/simpleperf.proto
+
+// Begin of protos/perfetto/metrics/android/startup_metric.proto
+
+// Android app startup metrics.
+message AndroidStartupMetric {
+  // A simplified view of the task state durations for a thread
+  // and a span of time.
+  message TaskStateBreakdown {
+    optional int64 running_dur_ns = 1;
+    optional int64 runnable_dur_ns = 2;
+    optional int64 uninterruptible_sleep_dur_ns = 3;
+    optional int64 interruptible_sleep_dur_ns = 4;
+    optional int64 uninterruptible_io_sleep_dur_ns = 5;
+    optional int64 uninterruptible_non_io_sleep_dur_ns = 6;
+  }
+
+  message McyclesByCoreType {
+    optional int64 little = 1;
+    optional int64 big = 2;
+    optional int64 bigger = 3;
+    optional int64 unknown = 4;
+  }
+
+  message Slice {
+    optional int64 dur_ns = 1;
+    optional double dur_ms = 2;
+  }
+
+  // Timing information spanning the intent received by the
+  // activity manager to the first frame drawn.
+  // Next id: 36.
+  message ToFirstFrame {
+    // The duration between the intent received and first frame.
+    optional int64 dur_ns = 1;
+    optional double dur_ms = 17;
+
+    // Breakdown of time to first frame by task state for the main thread of
+    // the process starting up.
+    optional TaskStateBreakdown main_thread_by_task_state = 2;
+
+    // The mcycles taken by this startup across all CPUs (broken down by core
+    // type).
+    optional McyclesByCoreType mcycles_by_core_type = 26;
+
+    // In this timespan, how many processes (apart from the main activity) were
+    // spawned.
+    optional uint32 other_processes_spawned_count = 3;
+
+    // Total time spent in activity manager between the initial intent
+    // and the end of the activity starter.
+    optional Slice time_activity_manager = 4;
+
+    // The following slices follow the typical steps post-fork.
+    optional Slice time_activity_thread_main = 5;
+    optional Slice time_bind_application = 6;
+    optional Slice time_activity_start = 7;
+    optional Slice time_activity_resume = 8;
+    optional Slice time_activity_restart = 21;
+    optional Slice time_choreographer = 9;
+    optional Slice time_inflate = 22;
+    optional Slice time_get_resources = 23;
+
+    // If we are starting a new process, record the duration from the
+    // intent being received to the time we call the zygote.
+    optional Slice time_before_start_process = 10;
+
+    // The actual duration of the process start (based on the zygote slice).
+    optional Slice time_during_start_process = 11;
+
+    // The duration from launch to first running state thread of startup process.
+    optional Slice time_to_running_state = 35;
+
+    optional Slice to_post_fork = 18;
+    optional Slice to_activity_thread_main = 19;
+    optional Slice to_bind_application = 20;
+
+    optional Slice time_post_fork = 16;
+
+    // The total time spent on opening dex files.
+    optional Slice time_dex_open = 24;
+    // Total time spent verifying classes during app startup.
+    optional Slice time_verify_class = 25;
+
+    // Number of methods that were compiled by JIT during app startup.
+    optional uint32 jit_compiled_methods = 27;
+
+    // Time spent running CPU on jit thread pool.
+    optional Slice time_jit_thread_pool_on_cpu = 28;
+
+    // Time spent on garbage collection.
+    optional Slice time_gc_total = 29;
+    optional Slice time_gc_on_cpu = 30;
+
+    // Time spent in lock contention on the main thread of the process being
+    // started up. This includes *all* types of lock contention not just monitor
+    // contention.
+    optional Slice time_lock_contention_thread_main = 31;
+
+    // Time spent in monitor lock contention on the main thread of the
+    // process being started up. This will be a subset of the time counted by
+    // |time_lock_contention_thread_main|.
+    optional Slice time_monitor_contention_thread_main = 32;
+
+    // Time spent in opening dex files on the main thread of the process
+    // being started up.
+    optional Slice time_dex_open_thread_main = 33;
+
+    // Time spent in dlopening .so files on the main thread of the process
+    // being started up.
+    optional Slice time_dlopen_thread_main = 34;
+
+    // Removed: was other_process_to_activity_cpu_ratio.
+    reserved 12;
+
+    // Removed: was uint32 versions of to_post_fork, to_activity_thread_main and
+    // to_bind_application.
+    reserved 13, 14, 15;
+  }
+
+  // Metrics about startup which were developed by looking at experiments using
+  // high-speed cameras (HSC).
+  message HscMetrics {
+    // The duration of the full "startup" as defined by HSC tests.
+    optional Slice full_startup = 1;
+  }
+
+  message Activity {
+    optional string name = 1;
+    optional string method = 2;
+    optional int64 ts_method_start = 4;
+
+    // Field 3 contained Slice with a sum of durations for matching slices.
+    reserved 3;
+  }
+
+  message BinderTransaction {
+    optional Slice duration = 1;
+    optional string thread = 2;
+    optional string destination_thread = 3;
+    optional string destination_process = 4;
+    // From
+    // https://cs.android.com/android/platform/superproject/+/main:external/perfetto/protos/perfetto/trace/ftrace/binder.proto;l=15;drc=7b6a788162a30802f4c9d8d7a30a54e25edd30f1
+    optional string flags = 5;
+    // From
+    // https://cs.android.com/android/platform/superproject/+/main:external/perfetto/protos/perfetto/trace/ftrace/binder.proto;l=14;drc=7b6a788162a30802f4c9d8d7a30a54e25edd30f1
+    optional string code = 6;
+    // From
+    // https://cs.android.com/android/platform/superproject/+/main:external/perfetto/protos/perfetto/trace/ftrace/binder.proto;l=37;drc=7b6a788162a30802f4c9d8d7a30a54e25edd30f1
+    optional int64 data_size = 7;
+  }
+
+  // Metrics with information about the status of odex files and the outcome
+  // of the loading process.
+  // Multiple files might be loaded for a single startup. Platform might also
+  // decide to discard an odex file and instead load a fallback, for example
+  // in case the OS or apk were updated.
+  message OptimizationStatus {
+    optional string odex_status = 1;
+    optional string compilation_filter = 2;
+    optional string compilation_reason = 3;
+    optional string location = 4;
+    optional string summary = 5;
+  }
+
+  // Contains the name and duration of class verification occurred during
+  // the startup.
+  message VerifyClass {
+    optional string name = 1;
+    optional int64 dur_ns = 2;
+  }
+
+  // Contains timestamps of important events which occurred during the
+  // startup.
+  message EventTimestamps {
+    optional int64 intent_received = 1;
+    optional int64 first_frame = 2;
+  }
+
+  // Contains information about the state of a system during the app startup.
+  // Useful to put the startup in context.
+  message SystemState {
+    // Whether the dex2oat64 process was running concurrent to the startup.
+    // Deprecated as of 10/2022.
+    optional bool dex2oat_running = 1 [deprecated=true];
+
+    // Whether the installd process was running concurrent to the startup.
+    // Deprecated as of 10/2022.
+    optional bool installd_running = 2 [deprecated=true];
+
+    // The number of broadcasts dispatched by the system during the app
+    // launch.
+    optional int64 broadcast_dispatched_count = 3;
+
+    // The number of broadcasts received by an app or the system during the
+    // app launch. Note that multiple packages can be subscribed to the same
+    // broadcast so a single dsipatch can cause multiple packages to receive
+    // and process a broadcast.
+    optional int64 broadcast_received_count = 4;
+
+    // The most active (i.e. consuming the most mcycles) processes during the
+    // app launch excluding the process(es) being launched.
+    // Note: the exact number of returned is an implementation detail and
+    // will likely change over time.
+    repeated string most_active_non_launch_processes = 5;
+
+    // Duration the installd process was running concurrent to the startup.
+    optional int64 installd_dur_ns = 6;
+    // Duration the dex2oat64 process was running concurrent to the startup.
+    optional int64 dex2oat_dur_ns = 7;
+  }
+
+  // Contains detailed information for slow startup causes.
+  message SlowStartReasonDetailed {
+    optional string reason = 1;
+    optional string details = 2;
+  }
+
+  // Next id: 22
+  message Startup {
+    // Random id uniquely identifying an app startup in this trace.
+    optional uint32 startup_id = 1;
+
+    // Startup type (cold / warm / hot)
+    optional string startup_type = 16;
+
+    // Name of the package launched
+    optional string package_name = 2;
+
+    // Name of the process launched
+    optional string process_name = 3;
+
+    // Details about the activities launched
+    repeated Activity activities = 11;
+
+    // Details about slow binder transactions during the startup. The definition
+    // of a slow transaction is an implementation detail.
+    repeated BinderTransaction long_binder_transactions = 14;
+
+    // Did we ask the zygote for a new process
+    optional bool zygote_new_process = 4;
+
+    // Number of processes hosting the activity involved in the launch.
+    // This will usually be 1. If it is 0, it is indicative of a data / process
+    // error. If > 1, the process died during startup and the system respawned
+    // it.
+    optional uint32 activity_hosting_process_count = 6;
+
+    // Contains timestamps of important events which happened during
+    // the startup.
+    optional EventTimestamps event_timestamps = 13;
+
+    // Timing information spanning the intent received by the
+    // activity manager to the first frame drawn.
+    optional ToFirstFrame to_first_frame = 5;
+
+    // Details about the process (uid, version, etc)
+    optional AndroidProcessMetadata process = 7;
+
+    // Metrics about startup which were developed by looking at experiments
+    // using high-speed cameras (HSC).
+    optional HscMetrics hsc = 8;
+
+    // The time taken in the startup from intent received to the start time
+    // of the reportFullyDrawn slice. This should be longer than the time to
+    // first frame as the application decides this after it starts rendering.
+    optional Slice report_fully_drawn = 9;
+
+    // Contains information about the status of odex files.
+    repeated OptimizationStatus optimization_status = 12;
+
+    // Contains information about the class verification.
+    repeated VerifyClass verify_class = 19;
+
+    // Contains the dlopen file names.
+    repeated string dlopen_file = 20;
+
+    // Package name of startups running concurrent to the launch.
+    repeated string startup_concurrent_to_launch = 18;
+
+    // Contains information about the state of the rest of the system during the
+    // startup. This is useful for getting context about why a startup might
+    // be slow beyond just what the app is doing.
+    optional SystemState system_state = 15;
+
+    // A list of identified potential causes for slow startup.
+    // Optional.
+    repeated string slow_start_reason = 17;
+
+    // Same as slow_start_reason, but with more detailed information.
+    repeated SlowStartReasonDetailed slow_start_reason_detailed = 21;
+
+    reserved 10;
+  }
+
+  repeated Startup startup = 1;
+}
+
+// End of protos/perfetto/metrics/android/startup_metric.proto
+
+// Begin of protos/perfetto/metrics/android/surfaceflinger.proto
+
+message AndroidSurfaceflingerMetric {
+  // Counts the number of missed frames in the trace.
+  optional uint32 missed_frames = 1;
+
+  // Counts the number of missed HWC frames in the trace.
+  optional uint32 missed_hwc_frames = 2;
+
+  // Counts the number of missed GPU frames in the trace.
+  optional uint32 missed_gpu_frames = 3;
+
+  // Calculate the number of missed frames divided by
+  // total frames
+  optional double missed_frame_rate = 4;
+
+  // Calculate the number of missed HWC frames divided by
+  // total HWC frames
+  optional double missed_hwc_frame_rate = 5;
+
+  // Calculate the number of missed GPU frames divided by
+  // total GPU frames
+  optional double missed_gpu_frame_rate = 6;
+
+  // Count the number of times SurfaceFlinger needs to invoke GPU
+  // for rendering some layers
+  optional uint32 gpu_invocations = 7;
+
+  // Calculate the average duration of GPU request by SurfaceFlinger
+  // since it enters the FenceMonitor's queue until it gets completed
+  optional double avg_gpu_waiting_dur_ms = 8;
+
+  // Calculate the total duration when there is at least one GPU request
+  // by SurfaceFlinger that is still waiting for GPU to complete the
+  // request.
+  // This also equals to the total duration of
+  // "waiting for GPU completion <fence_num>" in SurfaceFlinger.
+  optional double total_non_empty_gpu_waiting_dur_ms = 9;
+
+  message MetricsPerDisplay {
+    // Display ID in SF
+    optional string display_id = 1;
+
+    // Counts the number of missed frames in the trace.
+    optional uint32 missed_frames = 2;
+
+    // Counts the number of missed HWC frames in the trace.
+    optional uint32 missed_hwc_frames = 3;
+
+    // Counts the number of missed GPU frames in the trace.
+    optional uint32 missed_gpu_frames = 4;
+
+    // Calculate the number of missed frames divided by
+    // total frames
+    optional double missed_frame_rate = 5;
+
+    // Calculate the number of missed HWC frames divided by
+    // total HWC frames
+    optional double missed_hwc_frame_rate = 6;
+
+    // Calculate the number of missed GPU frames divided by
+    // total GPU frames
+    optional double missed_gpu_frame_rate = 7;
+  }
+
+  repeated MetricsPerDisplay metrics_per_display = 10;
+}
+
+// End of protos/perfetto/metrics/android/surfaceflinger.proto
+
+// Begin of protos/perfetto/metrics/android/sysui_slice_performance_statistical_data.proto
+
+// Statistical performance data row for a set of slices
+message SysUiSlicePerformanceStatisticalData {
+  // Name of the Slice
+  optional string name = 1;
+  // Number of times it happened within the CUJ
+  optional int64 cnt = 2;
+  // Average duration within the CUJ
+  optional int64 avg_dur_ms = 3;
+  // Maximal duration within the CUJ
+  optional int64 max_dur_ms = 4;
+  // Average duration within the CUJ in nanoseconds
+  optional int64 avg_dur_ns = 6;
+  // Maximal duration within the CUJ in nanoseconds
+  optional int64 max_dur_ns = 7;
+}
+// End of protos/perfetto/metrics/android/sysui_slice_performance_statistical_data.proto
+
+// Begin of protos/perfetto/metrics/android/sysui_notif_shade_list_builder_metric.proto
+// System UI Notifications ShadeListBuilder.buildList slices.
+// Shows count, average duration, and max duration for each.
+message SysuiNotifShadeListBuilderMetric {
+  optional SysUiSlicePerformanceStatisticalData all_slices_performance = 1;
+  optional SysUiSlicePerformanceStatisticalData slices_with_inflation_performance = 2;
+  optional SysUiSlicePerformanceStatisticalData slices_with_modification_performance = 3;
+
+  // Data row for a single slice
+  message SliceDuration {
+    // Name of the Slice
+    optional string name = 1;
+
+    // Duration in ms
+    optional int64 dur_ms = 2;
+
+    // Duration in ns
+    optional int64 dur_ns = 3;
+  }
+  repeated SliceDuration slice = 4;
+}
+// End of protos/perfetto/metrics/android/sysui_notif_shade_list_builder_metric.proto
+
+// Begin of protos/perfetto/metrics/android/sysui_update_notif_on_ui_mode_changed_metric.proto
+
+// System UI Notifications ShadeListBuilder.buildList slices.
+// Shows count, average duration, and max duration for each.
+message SysuiUpdateNotifOnUiModeChangedMetric {
+  optional SysUiSlicePerformanceStatisticalData all_slices_performance = 1;
+  // Data row for a single slice
+  message SliceDuration {
+    // Name of the Slice
+    optional string name = 1;
+
+    // Duration in ms
+    optional int64 dur_ms = 2;
+
+    // Duration in ns
+    optional int64 dur_ns = 3;
+  }
+  repeated SliceDuration slice = 2;
+}
+// End of protos/perfetto/metrics/android/sysui_update_notif_on_ui_mode_changed_metric.proto
+
+// Begin of protos/perfetto/metrics/android/task_names.proto
+
+message AndroidTaskNames {
+  message Process {
+    optional int64 pid = 1;
+
+    // Process name.
+    optional string process_name = 2;
+
+    // Names of all threads for this process.
+    repeated string thread_name = 3;
+
+    // User id under which this process runs.
+    optional int64 uid = 4;
+
+    // Packages matching the process uid.
+    repeated string uid_package_name = 5;
+
+    // Removed, was short_lived_tasks.
+    reserved 6;
+
+    // Removed, was long_lived_tasks.
+    reserved 7;
+  }
+
+  repeated Process process = 1;
+}
+
+// End of protos/perfetto/metrics/android/task_names.proto
+
+// Begin of protos/perfetto/metrics/android/trace_quality.proto
+
+// Metric which checks the data in the trace processor tables is "reasonble"
+// (i.e. we would expect to see it from a real device).
+//
+// This is useful to reject traces which may be valid (so no stat would be
+// recorded) but a human would find the trace nonsensical.
+message AndroidTraceQualityMetric {
+  message Failure {
+    // The name of the failed check.
+    optional string name = 1;
+  }
+  repeated Failure failures = 1;
+}
+// End of protos/perfetto/metrics/android/trace_quality.proto
+
+// Begin of protos/perfetto/metrics/android/unsymbolized_frames.proto
+
+message UnsymbolizedFrames {
+  message Frame {
+    optional string module = 1;
+    optional string build_id = 2;
+    optional int64 address = 3;
+
+    // In some cases (Chrome/Webview) the ID that should be used to query
+    // symbols in Google's internal tera-scale symbolization service is !=
+    // `build_id` and requires some mangling.
+    // This field is == 'build_id` for non-chromium cases, and is the breakpad
+    // module ID (with lowercase hex digics) for chromium cases.
+    optional string google_lookup_id = 4;
+  }
+
+  repeated Frame frames = 1;
+}
+
+// End of protos/perfetto/metrics/android/unsymbolized_frames.proto
+
+// Begin of protos/perfetto/metrics/metrics.proto
+
+// Trace processor metadata
+message TraceMetadata {
+  reserved 1;
+  optional int64 trace_duration_ns = 2;
+  optional string trace_uuid = 3;
+  optional string android_build_fingerprint = 4;
+  optional int64 statsd_triggering_subscription_id = 5;
+  optional int64 trace_size_bytes = 6;
+  repeated string trace_trigger = 7;
+  optional string unique_session_name = 8;
+  optional string trace_config_pbtxt = 9;
+  optional int64 sched_duration_ns = 10;
+  optional int64 tracing_started_ns = 11;
+}
+
+// Stats counters for the trace.
+// Defined in src/trace_processor/storage/stats.h
+message TraceAnalysisStats {
+  enum Severity {
+    SEVERITY_UNKNOWN = 0;
+    SEVERITY_INFO = 1;
+    SEVERITY_DATA_LOSS = 2;
+    SEVERITY_ERROR = 3;
+  }
+
+  enum Source {
+    SOURCE_UNKNOWN = 0;
+    SOURCE_TRACE = 1;
+    SOURCE_ANALYSIS = 2;
+  }
+
+  message Stat {
+    optional string name = 1;
+    optional uint32 idx = 2;
+    optional Severity severity = 3;
+    optional Source source = 4;
+
+    optional int64 count = 5;
+  }
+
+  repeated Stat stat = 1;
+}
+
+// Root message for all Perfetto-based metrics.
+//
+// Next id: 63
+message TraceMetrics {
+  reserved 4, 10, 13, 14, 16, 19;
+
+  // Battery counters metric on Android.
+  optional AndroidBatteryMetric android_batt = 5;
+
+  // CPU usage per trace, process and thread.
+  optional AndroidCpuMetric android_cpu = 6;
+
+  // Memory metrics on Android (owned by the Android Telemetry team).
+  optional AndroidMemoryMetric android_mem = 1;
+
+  // Memory metrics on Android in unaggregated form. (owned by the Android
+  // Telemetry team).
+  // Note: this generates a lot of data so should not be requested unless it
+  // is clear that this data is necessary.
+  optional AndroidMemoryUnaggregatedMetric android_mem_unagg = 11;
+
+  // Package list.
+  optional AndroidPackageList android_package_list = 12;
+
+  // ion buffer memory metrics.
+  optional AndroidIonMetric android_ion = 9;
+
+  // fastrpc subsystem memory metrics.
+  optional AndroidFastrpcMetric android_fastrpc = 31;
+
+  // Statistics about low memory kills.
+  optional AndroidLmkMetric android_lmk = 8;
+
+  // Power Rails metrics on Android.
+  optional AndroidPowerRails android_powrails = 7;
+
+  // Startup metrics on Android (owned by the Android Telemetry team).
+  optional AndroidStartupMetric android_startup = 2;
+
+  // Trace metadata (applicable to all traces).
+  optional TraceMetadata trace_metadata = 3;
+
+  // Trace stats (applicable to all traces).
+  optional TraceAnalysisStats trace_stats = 33;
+
+  // Returns stack frames missing symbols.
+  optional UnsymbolizedFrames unsymbolized_frames = 15;
+
+  // If the trace contains a heap graph, output allocation statistics.
+  optional JavaHeapStats java_heap_stats = 17;
+
+  // If the trace contains a heap graph, output histogram.
+  optional JavaHeapHistogram java_heap_histogram = 21;
+
+  // Metrics used to find potential culprits of low-memory kills.
+  optional AndroidLmkReasonMetric android_lmk_reason = 18;
+
+  optional AndroidHwuiMetric android_hwui_metric = 20;
+
+  optional AndroidDisplayMetrics display_metrics = 22;
+
+  optional AndroidTaskNames android_task_names = 23;
+
+  // Deprecated was AndroidThreadTimeInStateMetric
+  reserved 24;
+
+  // Metric associated with surfaceflinger.
+  optional AndroidSurfaceflingerMetric android_surfaceflinger = 25;
+
+  // GPU metrics on Android.
+  optional AndroidGpuMetric android_gpu = 26;
+
+  // Deprecated AndroidSysUiCujMetrics.
+  reserved 27;
+
+  // Interaction and frame timings for CUJs (important UI transitions).
+  optional AndroidJankCujMetric android_jank_cuj = 48;
+
+  // Metric associated with hwcomposer.
+  optional AndroidHwcomposerMetrics android_hwcomposer = 28;
+
+  // Deprecated was AndroidJankMetrics;
+  reserved 29;
+
+  // G2D metrics.
+  optional G2dMetrics g2d = 30;
+
+  // Dmabuf heap metrics.
+  optional AndroidDmaHeapMetric android_dma_heap = 32;
+
+  // Metric to verify the quality of the trace.
+  optional AndroidTraceQualityMetric android_trace_quality = 34;
+
+  // Profiler smaps
+  optional ProfilerSmaps profiler_smaps = 35;
+
+  // Multiuser - metrics for switching users.
+  optional AndroidMultiuserMetric android_multiuser = 36;
+
+  // Metrics related to simpleperf tool
+  optional AndroidSimpleperfMetric android_simpleperf = 37;
+
+  // Metrics for the Camera team.
+  optional AndroidCameraMetric android_camera = 38;
+
+  // Metrics for dynamic voltage and frequency scaling.
+  optional AndroidDvfsMetric android_dvfs = 39;
+
+  // Metrics for network performance.
+  optional AndroidNetworkMetric android_netperf = 40;
+
+  // Metrics for the Camera team.
+  // Note: this generates a lot of data so should not be requested unless it
+  // is clear that this data is necessary.
+  optional AndroidCameraUnaggregatedMetric android_camera_unagg = 41;
+
+  // Metrics for RT runtime.
+  optional AndroidRtRuntimeMetric android_rt_runtime = 42;
+
+  // Metrics for IRQ runtime.
+  optional AndroidIrqRuntimeMetric android_irq_runtime = 43;
+
+  // Metrics for the Trusty team.
+  optional AndroidTrustyWorkqueues android_trusty_workqueues = 44;
+
+  // Summary of other concurrent trace recording.
+  optional AndroidOtherTracesMetric android_other_traces = 45;
+
+  // Per-process Binder transaction metrics.
+  optional AndroidBinderMetric android_binder = 46;
+
+  // Metrics for app deadline missed.
+  optional AndroidFrameTimelineMetric android_frame_timeline_metric = 47;
+
+  // Blocking calls (e.g. binder calls) for CUJs (important UI transitions).
+  optional AndroidBlockingCallsCujMetric android_blocking_calls_cuj_metric = 49;
+
+  optional AndroidMonitorContentionMetric android_monitor_contention = 50;
+
+  optional AndroidSysUINotificationsBlockingCallsMetric android_sysui_notifications_blocking_calls_metric = 51;
+
+  // Metrics to track codec framework.
+  optional AndroidCodecMetrics codec_metrics = 52;
+
+  // Metric to track Android IO.
+  optional AndroidIo android_io = 53;
+
+  // IO metrics on Android in unaggregated form.
+  // Note: this generates a lot of data so should not be requested unless it
+  // is clear that this data is necessary.
+  optional AndroidIoUnaggregated android_io_unagg = 54;
+
+  // Metrics for App Not Responding (ANR) errors.
+  optional AndroidAnrMetric android_anr = 55;
+
+  // Aggregated Android Monitor Contention metrics
+  optional AndroidMonitorContentionAggMetric android_monitor_contention_agg = 56;
+
+  optional AndroidBootMetric android_boot = 57;
+
+  // Metric for AdServices module.
+  optional AdServicesMetric ad_services_metric = 58;
+
+  optional SysuiNotifShadeListBuilderMetric sysui_notif_shade_list_builder_metric = 59;
+
+  optional SysuiUpdateNotifOnUiModeChangedMetric sysui_update_notif_on_ui_mode_changed_metric = 60;
+
+  // Metrics for Process starts.
+  optional AndroidAppProcessStartsMetric android_app_process_starts = 61;
+
+  // Android boot unaggregated metrics.
+  optional AndroidBootUnagg android_boot_unagg = 62;
+
+  // Android garbage collection metrics
+  optional AndroidGarbageCollectionUnaggMetric android_garbage_collection_unagg = 63;
+
+  // Demo extensions.
+  extensions 450 to 499;
+
+  // Vendor extensions.
+  extensions 500 to 1000;
+
+  // Chrome metrics.
+  extensions 1001 to 2000;
+
+  // WebView metrics.
+  extensions 2001 to 2500;
+}
+
+// End of protos/perfetto/metrics/metrics.proto
diff --git a/protos/perfetto/trace_processor/metatrace_categories.proto b/protos/perfetto/trace_processor/metatrace_categories.proto
new file mode 100644
index 0000000..6b9ee23
--- /dev/null
+++ b/protos/perfetto/trace_processor/metatrace_categories.proto
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2022 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+syntax = "proto2";
+
+package perfetto.protos;
+
+// Bitmask of metatrace categories which can be enabled.
+// Keep in sync with TraceProcessor::MetatraceCategories.
+enum MetatraceCategories {
+  // 1 << 0.
+  QUERY_TIMELINE = 1;
+  // 1 << 1.
+  QUERY_DETAILED = 2;
+  // 1 << 2.
+  FUNCTION_CALL = 4;
+  // 1 << 3.
+  DB = 8;
+  // 1 << 4.
+  API_TIMELINE = 16;
+
+  // Aliases for common subsets.
+  NONE = 0;
+  ALL = 31;
+}
diff --git a/protos/perfetto/trace_processor/trace_processor.proto b/protos/perfetto/trace_processor/trace_processor.proto
new file mode 100644
index 0000000..1e579ca
--- /dev/null
+++ b/protos/perfetto/trace_processor/trace_processor.proto
@@ -0,0 +1,329 @@
+/*
+ * Copyright (C) 2018 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+syntax = "proto2";
+
+package perfetto.protos;
+
+import "protos/perfetto/common/descriptor.proto";
+import "protos/perfetto/trace_processor/metatrace_categories.proto";
+
+// This file defines the schema for {,un}marshalling arguments and return values
+// when interfacing to the trace processor binary interface.
+
+// The Trace Processor can be used in three modes:
+// 1. Fully native from C++ or directly using trace_processor_shell.
+//    In this case, this file isn't really relevant because no binary
+//    marshalling is involved. Look at include/trace_processor/trace_processor.h
+//    for the public C++ API definition.
+// 2. Using WASM within the HTML ui. In this case these messages are used to
+//    {,un}marshall calls made through the JS<>WASM interop in
+//    src/trace_processor/rpc/wasm_bridge.cc .
+// 3. Using the HTTP+RPC interface, by running trace_processor_shell -D.
+//    In this case these messages are used to {,un}marshall HTTP requests and
+//    response made through src/trace_processor/rpc/httpd.cc .
+
+enum TraceProcessorApiVersion {
+  // This variable has been introduced in v15 and is used to deal with API
+  // mismatches between UI and trace_processor_shell --httpd.
+  //
+  // Prior to API version 11 this was incremented every time a new
+  // feature that the UI depended on was introduced (e.g. new tables,
+  // new SQL operators, metrics that are required by the UI, etc).
+  // This:
+  // a. Tended to be forgotten
+  // b. Still led to issues when the TP dropped *backwards*
+  //    compatibility of a feature (since we checked TP >= UI
+  //    TRACE_PROCESSOR_CURRENT_API_VERSION).
+  // Now the UI attempts to redirect the user to the matched version
+  // of the UI if one exists.
+  // See also StatusResult.api_version (below).
+  // Changes:
+  // 7. Introduce GUESS_CPU_SIZE
+  // 8. Add 'json' option to ComputeMetricArgs
+  // 9. Add get_thread_state_summary_for_interval.
+  // 10. Add 'slice_is_ancestor' to stdlib.
+  // 11. Removal of experimental module from stdlib.
+  // 12. Changed UI to be more aggresive about version matching.
+  //     Added version_code.
+  TRACE_PROCESSOR_CURRENT_API_VERSION = 12;
+}
+
+// At lowest level, the wire-format of the RPC protocol is a linear sequence of
+// TraceProcessorRpc messages on each side of the byte pipe
+// Each message is prefixed by a tag (field = 1, type = length delimited) and a
+// varint encoding its size (this is so the whole stream can also be read /
+// written as if it was a repeated field of TraceProcessorRpcStream).
+
+message TraceProcessorRpcStream {
+  repeated TraceProcessorRpc msg = 1;
+}
+
+message TraceProcessorRpc {
+  // A monotonic counter used only for debugging purposes, to detect if the
+  // underlying stream is missing or duping data. The counter starts at 0 on
+  // each side of the pipe and is incremented on each message.
+  // Do NOT expect that a response has the same |seq| of its corresponding
+  // request: some requests (e.g., a query returning many rows) can yield more
+  // than one response message, bringing the tx and rq seq our of sync.
+  optional int64 seq = 1;
+
+  // This is returned when some unrecoverable error has been detected by the
+  // peer. The typical case is TraceProcessor detecting that the |seq| sequence
+  // is broken (e.g. when having two tabs open with the same --httpd instance).
+  optional string fatal_error = 5;
+
+  enum TraceProcessorMethod {
+    TPM_UNSPECIFIED = 0;
+    TPM_APPEND_TRACE_DATA = 1;
+    TPM_FINALIZE_TRACE_DATA = 2;
+    TPM_QUERY_STREAMING = 3;
+    // Previously: TPM_QUERY_RAW_DEPRECATED
+    reserved 4;
+    reserved "TPM_QUERY_RAW_DEPRECATED";
+    TPM_COMPUTE_METRIC = 5;
+    TPM_GET_METRIC_DESCRIPTORS = 6;
+    TPM_RESTORE_INITIAL_TABLES = 7;
+    TPM_ENABLE_METATRACE = 8;
+    TPM_DISABLE_AND_READ_METATRACE = 9;
+    TPM_GET_STATUS = 10;
+    TPM_RESET_TRACE_PROCESSOR = 11;
+  }
+
+  oneof type {
+    // Client -> TraceProcessor requests.
+    TraceProcessorMethod request = 2;
+
+    // TraceProcessor -> Client responses.
+    TraceProcessorMethod response = 3;
+
+    // This is sent back instead of filling |response| when the client sends a
+    // |request| which is not known by the TraceProcessor service. This can
+    // happen when the client is newer than the service.
+    TraceProcessorMethod invalid_request = 4;
+  }
+
+  // Request/Response arguments.
+  // Not all requests / responses require an argument.
+
+  oneof args {
+    // TraceProcessorMethod request args.
+
+    // For TPM_APPEND_TRACE_DATA.
+    bytes append_trace_data = 101;
+    // For TPM_QUERY_STREAMING.
+    QueryArgs query_args = 103;
+    // For TPM_COMPUTE_METRIC.
+    ComputeMetricArgs compute_metric_args = 105;
+    // For TPM_ENABLE_METATRACE.
+    EnableMetatraceArgs enable_metatrace_args = 106;
+    // For TPM_RESET_TRACE_PROCESSOR.
+    ResetTraceProcessorArgs reset_trace_processor_args = 107;
+
+    // TraceProcessorMethod response args.
+    // For TPM_APPEND_TRACE_DATA.
+    AppendTraceDataResult append_result = 201;
+    // For TPM_QUERY_STREAMING.
+    QueryResult query_result = 203;
+    // For TPM_COMPUTE_METRIC.
+    ComputeMetricResult metric_result = 205;
+    // For TPM_GET_METRIC_DESCRIPTORS.
+    DescriptorSet metric_descriptors = 206;
+    // For TPM_DISABLE_AND_READ_METATRACE.
+    DisableAndReadMetatraceResult metatrace = 209;
+    // For TPM_GET_STATUS.
+    StatusResult status = 210;
+  }
+
+  // Previously: RawQueryArgs for TPM_QUERY_RAW_DEPRECATED
+  reserved 104;
+  // Previously: RawQueryResult for TPM_QUERY_RAW_DEPRECATED
+  reserved 204;
+}
+
+message AppendTraceDataResult {
+  optional int64 total_bytes_parsed = 1;
+  optional string error = 2;
+}
+
+message QueryArgs {
+  optional string sql_query = 1;
+  // Was time_queued_ns
+  reserved 2;
+  // Optional string to tag this query with for performance diagnostic purposes.
+  optional string tag = 3;
+}
+
+// Output for the /query endpoint.
+// Returns a query result set, grouping cells into batches. Batching allows a
+// more efficient encoding of results, at the same time allowing to return
+// O(M) results in a pipelined fashion, without full-memory buffering.
+// Batches are split when either a large number of cells (~thousands) is reached
+// or the string/blob payload becomes too large (~hundreds of KB).
+// Data is batched in cells, scanning results by row -> column. e.g. if a query
+// returns 3 columns and 2 rows, the cells will be emitted in this order:
+// R0C0, R0C1, R0C2, R1C0, R1C1, R1C2.
+message QueryResult {
+  // This determines the number and names of columns.
+  repeated string column_names = 1;
+
+  // If non-emty the query returned an error. Note that some cells might still
+  // be present, if the error happened while iterating.
+  optional string error = 2;
+
+  // A batch contains an array of cell headers, stating the type of each cell.
+  // The payload of each cell is stored in the corresponding xxx_cells field
+  // below (unless the cell is NULL).
+  // So if |cells| contains: [VARINT, FLOAT64, VARINT, STRING], the results will
+  // be available as:
+  // [varint_cells[0], float64_cells[0], varint_cells[1], string_cells[0]].
+  message CellsBatch {
+    enum CellType {
+      CELL_INVALID = 0;
+      CELL_NULL = 1;
+      CELL_VARINT = 2;
+      CELL_FLOAT64 = 3;
+      CELL_STRING = 4;
+      CELL_BLOB = 5;
+    }
+    repeated CellType cells = 1 [packed = true];
+
+    repeated int64 varint_cells = 2 [packed = true];
+    repeated double float64_cells = 3 [packed = true];
+    repeated bytes blob_cells = 4;
+
+    // The string cells are concatenated in a single field. Each cell is
+    // NUL-terminated. This is because JS incurs into a non-negligible overhead
+    // when decoding strings and one decode + split('\0') is measurably faster
+    // than decoding N strings. See goto.google.com/postmessage-benchmark .
+    optional string string_cells = 5;
+
+    // If true this is the last batch for the query result.
+    optional bool is_last_batch = 6;
+
+    // Padding field. Used only to re-align and fill gaps in the binary format.
+    reserved 7;
+  }
+  repeated CellsBatch batch = 3;
+
+  // The number of statements in the provided SQL.
+  optional uint32 statement_count = 4;
+
+  // The number of statements which produced output rows in the provided SQL.
+  optional uint32 statement_with_output_count = 5;
+
+  // The last statement in the provided SQL.
+  optional string last_statement_sql = 6;
+}
+
+// Input for the /status endpoint.
+message StatusArgs {}
+
+// Output for the /status endpoint.
+message StatusResult {
+  // If present and not empty, a trace is already loaded already. This happens
+  // when using the HTTP+RPC mode nad passing a trace file to the shell, via
+  // trace_processor_shell -D trace_file.pftrace .
+  optional string loaded_trace_name = 1;
+
+  // Typically something like "v11.0.123", but could be just "v11" or "unknown",
+  // for binaries built from Bazel or other build configurations. This is for
+  // human presentation only, don't attempt to parse and reason on it.
+  optional string human_readable_version = 2;
+
+  // The API version is incremented every time a change that the UI depends
+  // on is introduced (e.g. adding a new table that the UI queries).
+  optional int32 api_version = 3;
+
+  // Typically something like "v42.1-deadbeef0", but could be just
+  // "v42", "v0.0", or unset for binaries built from Bazel or other
+  // build configurations. This can be compared with equality to other
+  // version codes to detect matched builds (for example to see if
+  // trace_processor_shell and the UI were built at the same revision)
+  // but you should not attempt to parse it as the format may change
+  // without warning.
+  optional string version_code = 4;
+}
+
+// Input for the /compute_metric endpoint.
+message ComputeMetricArgs {
+  enum ResultFormat {
+    BINARY_PROTOBUF = 0;
+    TEXTPROTO = 1;
+    JSON = 2;
+  }
+  repeated string metric_names = 1;
+  optional ResultFormat format = 2;
+}
+
+// Output for the /compute_metric endpoint.
+message ComputeMetricResult {
+  oneof result {
+    // This is meant to contain a perfetto.protos.TraceMetrics. We're using
+    // bytes instead of the actual type because we do not want to generate
+    // protozero code for the metrics protos. We always encode/decode metrics
+    // using a reflection based mechanism that does not require the compiled C++
+    // code. This allows us to read in new protos at runtime.
+    bytes metrics = 1;
+
+    // A perfetto.protos.TraceMetrics formatted as prototext.
+    string metrics_as_prototext = 3;
+
+    // A perfetto.protos.TraceMetrics formatted as json.
+    string metrics_as_json = 4;
+  }
+
+  optional string error = 2;
+}
+
+// Input for the /enable_metatrace endpoint.
+message EnableMetatraceArgs {
+  optional MetatraceCategories categories = 1;
+}
+
+// Output for the /enable_metatrace endpoint.
+message EnableMetatraceResult {}
+
+// Input for the /disable_and_read_metatrace endpoint.
+message DisableAndReadMetatraceArgs {}
+
+// Output for the /disable_and_read_metatrace endpoint.
+message DisableAndReadMetatraceResult {
+  // Bytes of perfetto.protos.Trace message. Stored as bytes
+  // to avoid adding a dependency on trace.proto.
+  optional bytes metatrace = 1;
+  optional string error = 2;
+}
+
+// Convenience wrapper for multiple descriptors, similar to FileDescriptorSet
+// in descriptor.proto.
+message DescriptorSet {
+  repeated DescriptorProto descriptors = 1;
+}
+
+// Input for setting Trace Processor config. This method works only in the WASM
+// mode. trace_processor_shell supports configuration through command line
+// flags.
+message ResetTraceProcessorArgs {
+  enum DropTrackEventDataBefore {
+    NO_DROP = 0;
+    TRACK_EVENT_RANGE_OF_INTEREST = 1;
+  }
+  // Mirror of the corresponding perfetto::trace_processor::Config fields.
+  optional DropTrackEventDataBefore drop_track_event_data_before = 1;
+  optional bool ingest_ftrace_in_raw_table = 2;
+  optional bool analyze_trace_proto_content = 3;
+}
diff --git a/trace_processor_shell/trace_processor_shell_aarch64 b/trace_processor_shell/trace_processor_shell_aarch64
index 6e015c0..6685960 100644
--- a/trace_processor_shell/trace_processor_shell_aarch64
+++ b/trace_processor_shell/trace_processor_shell_aarch64
Binary files differ
diff --git a/trace_processor_shell/trace_processor_shell_arm b/trace_processor_shell/trace_processor_shell_arm
index 7944c31..80bffbc 100644
--- a/trace_processor_shell/trace_processor_shell_arm
+++ b/trace_processor_shell/trace_processor_shell_arm
Binary files differ
diff --git a/trace_processor_shell/trace_processor_shell_x86 b/trace_processor_shell/trace_processor_shell_x86
index fb22a85..a2da3b1 100644
--- a/trace_processor_shell/trace_processor_shell_x86
+++ b/trace_processor_shell/trace_processor_shell_x86
Binary files differ
diff --git a/trace_processor_shell/trace_processor_shell_x86_64 b/trace_processor_shell/trace_processor_shell_x86_64
index daa3c56..a39adae 100644
--- a/trace_processor_shell/trace_processor_shell_x86_64
+++ b/trace_processor_shell/trace_processor_shell_x86_64
Binary files differ
diff --git a/tracebox/tracebox_aarch64 b/tracebox/tracebox_aarch64
index a41d4fa..b78c4b0 100644
--- a/tracebox/tracebox_aarch64
+++ b/tracebox/tracebox_aarch64
Binary files differ
diff --git a/tracebox/tracebox_arm b/tracebox/tracebox_arm
index 3568c02..5e7667c 100644
--- a/tracebox/tracebox_arm
+++ b/tracebox/tracebox_arm
Binary files differ
diff --git a/tracebox/tracebox_x86 b/tracebox/tracebox_x86
index 6381020..078610f 100644
--- a/tracebox/tracebox_x86
+++ b/tracebox/tracebox_x86
Binary files differ
diff --git a/tracebox/tracebox_x86_64 b/tracebox/tracebox_x86_64
index 41c82da..90ecc66 100644
--- a/tracebox/tracebox_x86_64
+++ b/tracebox/tracebox_x86_64
Binary files differ