[tracing] Add ChromeLatencyInfo2 to ChromeTrackEvent

This CL adds a copy of ChromeLatencyInfo from the perfetto repository
to ChromeTrackEvent and updates the corresponding code to use the new
proto.
This is the first step in moving this proto to
the chromium repository.

PERFETTO_TESTS=`autoninja -C out/Default perfetto_diff_tests && out/Default/bin/run_perfetto_diff_tests`

Bug: b:359558038
Change-Id: Ib3352e78721af30e8228c91b8d776bb7c4aac32e
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/5786797
Reviewed-by: Alexander Timin <altimin@chromium.org>
Reviewed-by: Robert Flack <flackr@chromium.org>
Commit-Queue: Oksana Zhuravlova <oksamyt@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1352843}

base/tracing/protos/chrome_track_event.proto

@@ -1980,9 +1980,91 @@ message MainFramePipeline {
   optional BeginFrameId last_begin_frame_id_during_first_draw = 5;
 }
 
+message ChromeLatencyInfo2 {
+  optional int64 trace_id = 1;
+
+  // NEXT ID: 12
+  // All step are optional but the enum is ordered (not by number) below in the
+  // order we expect them to appear if they are emitted in trace in a blocking
+  // fashion.
+  enum Step {
+    STEP_UNSPECIFIED = 0;
+    // Emitted on the browser main thread.
+    STEP_SEND_INPUT_EVENT_UI = 3;
+    // Happens on the renderer's compositor.
+    STEP_HANDLE_INPUT_EVENT_IMPL = 5;
+    STEP_DID_HANDLE_INPUT_AND_OVERSCROLL = 8;
+    // Occurs on the Renderer's main thread.
+    STEP_HANDLE_INPUT_EVENT_MAIN = 4;
+    STEP_MAIN_THREAD_SCROLL_UPDATE = 2;
+    STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT = 1;
+    // Could be emitted on both the renderer's main OR compositor.
+    STEP_HANDLED_INPUT_EVENT_MAIN_OR_IMPL = 9;
+    // Optionally sometimes HANDLED_INPUT_EVENT_MAIN_OR_IMPL will proxy to the
+    // renderer's compositor and this will be emitted.
+    STEP_HANDLED_INPUT_EVENT_IMPL = 10;
+    // Renderer's compositor.
+    STEP_SWAP_BUFFERS = 6;
+    // Happens on the VizCompositor in the GPU process.
+    STEP_DRAW_AND_SWAP = 7 [deprecated = true];
+    // Happens on the GPU main thread after the swap has completed.
+    STEP_FINISHED_SWAP_BUFFERS = 11 [deprecated = true];
+    // See above for NEXT ID, enum steps are not ordered by tag number.
+  };
+
+  optional Step step = 2;
+  optional int32 frame_tree_node_id = 3;
+
+  // This enum is a copy of LatencyComponentType enum in Chrome, located in
+  // ui/latency/latency_info.h, modulo added UNKNOWN value per protobuf
+  // practices.
+  enum LatencyComponentType {
+    COMPONENT_UNSPECIFIED = 0;
+    COMPONENT_INPUT_EVENT_LATENCY_BEGIN_RWH = 1;
+    COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL = 2;
+    COMPONENT_INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL = 3;
+    COMPONENT_INPUT_EVENT_LATENCY_ORIGINAL = 4;
+    COMPONENT_INPUT_EVENT_LATENCY_UI = 5;
+    COMPONENT_INPUT_EVENT_LATENCY_RENDERER_MAIN = 6;
+    COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN = 7;
+    COMPONENT_INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL = 8;
+    COMPONENT_INPUT_EVENT_LATENCY_SCROLL_UPDATE_LAST_EVENT = 9;
+    COMPONENT_INPUT_EVENT_LATENCY_ACK_RWH = 10;
+    COMPONENT_INPUT_EVENT_LATENCY_RENDERER_SWAP = 11;
+    COMPONENT_DISPLAY_COMPOSITOR_RECEIVED_FRAME = 12;
+    COMPONENT_INPUT_EVENT_GPU_SWAP_BUFFER = 13;
+    COMPONENT_INPUT_EVENT_LATENCY_FRAME_SWAP = 14;
+  }
+
+  message ComponentInfo {
+    optional LatencyComponentType component_type = 1;
+
+    // Microsecond timestamp in CLOCK_MONOTONIC domain
+    optional uint64 time_us = 2;
+  };
+
+  repeated ComponentInfo component_info = 4;
+  optional bool is_coalesced = 5;
+  optional int64 gesture_scroll_id = 6;
+  optional int64 touch_id = 7;
+
+  enum InputType {
+    UNSPECIFIED_OR_OTHER = 0;
+    TOUCH_MOVED = 1;
+    GESTURE_SCROLL_BEGIN = 2;
+    GESTURE_SCROLL_UPDATE = 3;
+    GESTURE_SCROLL_END = 4;
+    GESTURE_TAP = 5;
+    GESTURE_TAP_CANCEL = 6;
+  }
+
+  // The type of input corresponding to this `ChromeLatencyInfo`.
+  optional InputType input_type = 8;
+}
+
 message ChromeTrackEvent {
   // Extension range for Chrome: 1000-1999
-  // Next ID: 1068
+  // Next ID: 1069
   extend TrackEvent {
     optional ChromeAppState chrome_app_state = 1000;
 
@@ -2126,5 +2208,7 @@ message ChromeTrackEvent {
     optional ScrollMetrics scroll_metrics = 1066;
 
     optional MainFramePipeline main_frame_pipeline = 1067;
+
+    optional ChromeLatencyInfo2 chrome_latency_info = 1068;
   }
 }

cc/trees/latency_info_swap_promise.cc

@@ -42,19 +42,20 @@ int64_t LatencyInfoSwapPromise::GetTraceId() const {
 
 // Trace the original LatencyInfo of a LatencyInfoSwapPromise
 void LatencyInfoSwapPromise::OnCommit() {
-  using perfetto::protos::pbzero::ChromeLatencyInfo;
   using perfetto::protos::pbzero::TrackEvent;
 
-  TRACE_EVENT("input,benchmark,latencyInfo", "LatencyInfo.Flow",
-              [this](perfetto::EventContext ctx) {
-                ChromeLatencyInfo* latency_info =
-                    ctx.event()->set_chrome_latency_info();
-                latency_info->set_trace_id(GetTraceId());
-                latency_info->set_step(
-                    ChromeLatencyInfo::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT);
-                tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
-                                       GetTraceId());
-              });
+  TRACE_EVENT(
+      "input,benchmark,latencyInfo", "LatencyInfo.Flow",
+      [this](perfetto::EventContext ctx) {
+        auto* latency_info =
+            ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                ->set_chrome_latency_info();
+        latency_info->set_trace_id(GetTraceId());
+        latency_info->set_step(perfetto::protos::pbzero::ChromeLatencyInfo2::
+                                   Step::STEP_HANDLE_INPUT_EVENT_MAIN_COMMIT);
+        tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
+                               GetTraceId());
+      });
 }
 
 }  // namespace cc

cc/trees/layer_tree_host.cc

@@ -1147,16 +1147,17 @@ void LayerTreeHost::ApplyCompositorChanges(CompositorCommitData* commit_data) {
   DCHECK(!in_apply_compositor_changes_);
   base::AutoReset<bool> in_apply_changes(&in_apply_compositor_changes_, true);
 
-  using perfetto::protos::pbzero::ChromeLatencyInfo;
   using perfetto::protos::pbzero::TrackEvent;
 
   for (auto& swap_promise : commit_data->swap_promises) {
     TRACE_EVENT(
         "input,benchmark", "LatencyInfo.Flow",
         [&swap_promise](perfetto::EventContext ctx) {
-          ChromeLatencyInfo* info = ctx.event()->set_chrome_latency_info();
+          auto* info = ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                           ->set_chrome_latency_info();
           info->set_trace_id(swap_promise->GetTraceId());
-          info->set_step(ChromeLatencyInfo::STEP_MAIN_THREAD_SCROLL_UPDATE);
+          info->set_step(perfetto::protos::pbzero::ChromeLatencyInfo2::Step::
+                             STEP_MAIN_THREAD_SCROLL_UPDATE);
           tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
                                  swap_promise->GetTraceId());
         });

components/input/input_router_impl.cc

@@ -40,6 +40,7 @@ using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using perfetto::protos::pbzero::ChromeLatencyInfo;
+using perfetto::protos::pbzero::ChromeLatencyInfo2;
 using perfetto::protos::pbzero::TrackEvent;
 using ui::WebInputEventTraits;
 
@@ -68,23 +69,23 @@ std::unique_ptr<blink::WebCoalescedInputEvent> ScaleEvent(
       std::vector<std::unique_ptr<WebInputEvent>>(), latency_info);
 }
 
-ChromeLatencyInfo::InputType GetInputTypeForLatencyInfo(
+ChromeLatencyInfo2::InputType GetInputTypeForLatencyInfo(
     const WebInputEvent& input_event) {
   switch (input_event.GetType()) {
     case WebInputEvent::Type::kGestureScrollBegin:
-      return ChromeLatencyInfo::InputType::GESTURE_SCROLL_BEGIN;
+      return ChromeLatencyInfo2::InputType::GESTURE_SCROLL_BEGIN;
     case WebInputEvent::Type::kGestureScrollEnd:
-      return ChromeLatencyInfo::InputType::GESTURE_SCROLL_END;
+      return ChromeLatencyInfo2::InputType::GESTURE_SCROLL_END;
     case WebInputEvent::Type::kGestureScrollUpdate:
-      return ChromeLatencyInfo::InputType::GESTURE_SCROLL_UPDATE;
+      return ChromeLatencyInfo2::InputType::GESTURE_SCROLL_UPDATE;
     case WebInputEvent::Type::kGestureTap:
-      return ChromeLatencyInfo::InputType::GESTURE_TAP;
+      return ChromeLatencyInfo2::InputType::GESTURE_TAP;
     case WebInputEvent::Type::kGestureTapCancel:
-      return ChromeLatencyInfo::InputType::GESTURE_TAP_CANCEL;
+      return ChromeLatencyInfo2::InputType::GESTURE_TAP_CANCEL;
     case WebInputEvent::Type::kTouchMove:
-      return ChromeLatencyInfo::InputType::TOUCH_MOVED;
+      return ChromeLatencyInfo2::InputType::TOUCH_MOVED;
     default:
-      return ChromeLatencyInfo::InputType::UNSPECIFIED_OR_OTHER;
+      return ChromeLatencyInfo2::InputType::UNSPECIFIED_OR_OTHER;
   }
 }
 
@@ -594,20 +595,21 @@ void InputRouterImpl::FilterAndSendWebInputEvent(
     blink::mojom::WidgetInputHandler::DispatchEventCallback callback) {
   TRACE_EVENT1("input", "InputRouterImpl::FilterAndSendWebInputEvent", "type",
                WebInputEvent::GetName(input_event.GetType()));
-  TRACE_EVENT("input,benchmark,devtools.timeline,latencyInfo",
-              "LatencyInfo.Flow",
-              [&latency_info, &input_event](perfetto::EventContext ctx) {
-                ChromeLatencyInfo* info =
-                    ctx.event()->set_chrome_latency_info();
-                info->set_trace_id(latency_info.trace_id());
-                info->set_step(ChromeLatencyInfo::STEP_SEND_INPUT_EVENT_UI);
-                info->set_input_type(GetInputTypeForLatencyInfo(input_event));
+  TRACE_EVENT(
+      "input,benchmark,devtools.timeline,latencyInfo", "LatencyInfo.Flow",
+      [&latency_info, &input_event](perfetto::EventContext ctx) {
+        auto* info = ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                         ->set_chrome_latency_info();
+        info->set_trace_id(latency_info.trace_id());
+        info->set_step(
+            perfetto::protos::pbzero::perfetto_pbzero_enum_ChromeLatencyInfo2::
+                Step::STEP_SEND_INPUT_EVENT_UI);
+        info->set_input_type(GetInputTypeForLatencyInfo(input_event));
 
-                tracing::FillFlowEvent(ctx,
-                                       perfetto::protos::pbzero::TrackEvent::
-                                           LegacyEvent::FLOW_INOUT,
-                                       latency_info.trace_id());
-              });
+        tracing::FillFlowEvent(
+            ctx, perfetto::protos::pbzero::TrackEvent::LegacyEvent::FLOW_INOUT,
+            latency_info.trace_id());
+      });
 
   output_stream_validator_.Validate(input_event);
   blink::mojom::InputEventResultState filtered_state =

third_party/blink/renderer/platform/widget/input/input_handler_proxy.cc

@@ -46,7 +46,6 @@
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/latency/latency_info.h"
 
-using perfetto::protos::pbzero::ChromeLatencyInfo;
 using perfetto::protos::pbzero::TrackEvent;
 
 using ScrollThread = cc::InputHandler::ScrollThread;
@@ -276,10 +275,12 @@ void InputHandlerProxy::HandleInputEventWithLatencyInfo(
   int64_t trace_id = event->latency_info().trace_id();
   TRACE_EVENT("input,benchmark,latencyInfo", "LatencyInfo.Flow",
               [trace_id](perfetto::EventContext ctx) {
-                ChromeLatencyInfo* info =
-                    ctx.event()->set_chrome_latency_info();
+                auto* info =
+                    ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                        ->set_chrome_latency_info();
                 info->set_trace_id(trace_id);
-                info->set_step(ChromeLatencyInfo::STEP_HANDLE_INPUT_EVENT_IMPL);
+                info->set_step(perfetto::protos::pbzero::ChromeLatencyInfo2::
+                                   Step::STEP_HANDLE_INPUT_EVENT_IMPL);
                 tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
                                        trace_id);
               });
@@ -570,10 +571,12 @@ void InputHandlerProxy::GenerateAndDispatchSytheticScrollPrediction(
   int64_t trace_id = event_with_callback->latency_info().trace_id();
   TRACE_EVENT("input,benchmark,latencyInfo", "LatencyInfo.Flow",
               [trace_id](perfetto::EventContext ctx) {
-                ChromeLatencyInfo* info =
-                    ctx.event()->set_chrome_latency_info();
+                auto* info =
+                    ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                        ->set_chrome_latency_info();
                 info->set_trace_id(trace_id);
-                info->set_step(ChromeLatencyInfo::STEP_HANDLE_INPUT_EVENT_IMPL);
+                info->set_step(perfetto::protos::pbzero::ChromeLatencyInfo2::
+                                   Step::STEP_HANDLE_INPUT_EVENT_IMPL);
                 tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
                                        trace_id);
               });

third_party/blink/renderer/platform/widget/input/widget_base_input_handler.cc

@@ -38,7 +38,6 @@
 #include <android/keycodes.h>
 #endif
 
-using perfetto::protos::pbzero::ChromeLatencyInfo;
 using perfetto::protos::pbzero::TrackEvent;
 
 namespace blink {
@@ -310,10 +309,12 @@ void WidgetBaseInputHandler::HandleInputEvent(
   int64_t trace_id = coalesced_event.latency_info().trace_id();
   TRACE_EVENT("input,benchmark,latencyInfo", "LatencyInfo.Flow",
               [trace_id](perfetto::EventContext ctx) {
-                ChromeLatencyInfo* info =
-                    ctx.event()->set_chrome_latency_info();
+                auto* info =
+                    ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                        ->set_chrome_latency_info();
                 info->set_trace_id(trace_id);
-                info->set_step(ChromeLatencyInfo::STEP_HANDLE_INPUT_EVENT_MAIN);
+                info->set_step(perfetto::protos::pbzero::ChromeLatencyInfo2::
+                                   Step::STEP_HANDLE_INPUT_EVENT_MAIN);
                 tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
                                        trace_id);
               });

ui/latency/latency_info.cc

@@ -15,22 +15,22 @@
 #include "base/logging.h"
 #include "base/memory/raw_ptr.h"
 #include "base/trace_event/trace_event.h"
+#include "base/tracing/protos/chrome_track_event.pbzero.h"
 #include "services/tracing/public/cpp/perfetto/flow_event_utils.h"
 #include "services/tracing/public/cpp/perfetto/macros.h"
-#include "third_party/perfetto/protos/perfetto/trace/track_event/chrome_latency_info.pbzero.h"
 
 namespace {
 
-using perfetto::protos::pbzero::ChromeLatencyInfo;
 using perfetto::protos::pbzero::TrackEvent;
 
 const size_t kMaxLatencyInfoNumber = 100;
 
-ChromeLatencyInfo::LatencyComponentType GetComponentProtoEnum(
-    ui::LatencyComponentType type) {
-#define CASE_TYPE(t)      \
-  case ui::t##_COMPONENT: \
-    return ChromeLatencyInfo::COMPONENT_##t
+perfetto::protos::pbzero::ChromeLatencyInfo2::LatencyComponentType
+GetComponentProtoEnum(ui::LatencyComponentType type) {
+#define CASE_TYPE(t)                                      \
+  case ui::t##_COMPONENT:                                 \
+    return perfetto::protos::pbzero::ChromeLatencyInfo2:: \
+        LatencyComponentType::COMPONENT_##t
   switch (type) {
     CASE_TYPE(INPUT_EVENT_LATENCY_BEGIN_RWH);
     CASE_TYPE(INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL);
@@ -46,7 +46,8 @@ ChromeLatencyInfo::LatencyComponentType GetComponentProtoEnum(
     CASE_TYPE(INPUT_EVENT_LATENCY_FRAME_SWAP);
     default:
       NOTREACHED_IN_MIGRATION() << "Unhandled LatencyComponentType: " << type;
-      return ChromeLatencyInfo::COMPONENT_UNSPECIFIED;
+      return perfetto::protos::pbzero::ChromeLatencyInfo2::
+          LatencyComponentType::COMPONENT_UNSPECIFIED;
   }
 #undef CASE_TYPE
 }
@@ -109,8 +110,11 @@ void LatencyInfo::TraceIntermediateFlowEvents(
     TRACE_EVENT(
         "input,benchmark,latencyInfo", "LatencyInfo.Flow",
         [&latency, &step](perfetto::EventContext ctx) {
-          ChromeLatencyInfo* info = ctx.event()->set_chrome_latency_info();
-          info->set_step(step);
+          auto* info = ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                           ->set_chrome_latency_info();
+          info->set_step(
+              (perfetto::protos::pbzero::
+                   perfetto_pbzero_enum_ChromeLatencyInfo2::Step)step);
           info->set_trace_id(latency.trace_id());
           tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_INOUT,
                                  latency.trace_id());
@@ -191,8 +195,9 @@ void LatencyInfo::AddLatencyNumberWithTimestampImpl(
 
     TRACE_EVENT("input,benchmark,latencyInfo", "LatencyInfo.Flow",
                 [this](perfetto::EventContext ctx) {
-                  ChromeLatencyInfo* info =
-                      ctx.event()->set_chrome_latency_info();
+                  auto* info =
+                      ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                          ->set_chrome_latency_info();
                   info->set_trace_id(trace_id_);
                   tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_OUT,
                                          trace_id_);
@@ -224,10 +229,10 @@ void LatencyInfo::Terminate() {
     TRACE_EVENT_END(
         kTraceCategoriesForAsyncEvents, perfetto::Track::Global(trace_id_),
         gpu_swap_end_timestamp, [this](perfetto::EventContext ctx) {
-          ChromeLatencyInfo* info = ctx.event()->set_chrome_latency_info();
+          auto* info = ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                           ->set_chrome_latency_info();
           for (const auto& lc : latency_components_) {
-            ChromeLatencyInfo::ComponentInfo* component =
-                info->add_component_info();
+            auto* component = info->add_component_info();
 
             component->set_component_type(GetComponentProtoEnum(lc.first));
             component->set_time_us(lc.second.since_origin().InMicroseconds());
@@ -247,8 +252,9 @@ void LatencyInfo::Terminate() {
 
   TRACE_EVENT("input,benchmark,latencyInfo", "LatencyInfo.Flow",
               [this](perfetto::EventContext ctx) {
-                ChromeLatencyInfo* info =
-                    ctx.event()->set_chrome_latency_info();
+                auto* info =
+                    ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>()
+                        ->set_chrome_latency_info();
                 info->set_trace_id(trace_id_);
                 tracing::FillFlowEvent(ctx, TrackEvent::LegacyEvent::FLOW_IN,
                                        trace_id_);