Add TimeToScrollUpdateSwapBegin2 in RAPPOR

content/browser/renderer_host/input/render_widget_host_latency_tracker.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/renderer_host/input/render_widget_host_latency_tracker.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "build/build_config.h"
-#include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "components/rappor/public/rappor_utils.h"
+#include "content/browser/renderer_host/render_widget_host_delegate.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/common/content_client.h"
 #include "ui/events/blink/web_input_event_traits.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using ui::LatencyInfo;
 
 namespace content {
@@ skipping 208 matching lines @@
   UMA_HISTOGRAM_SCROLL_LATENCY_LONG(
       "Event.Latency.ScrollUpdate.BrowserNotifiedToBeforeGpuSwap",
       browser_received_swap_component, gpu_swap_begin_component);
 
   UMA_HISTOGRAM_SCROLL_LATENCY_SHORT("Event.Latency.ScrollUpdate.GpuSwap",
                                      gpu_swap_begin_component,
                                      gpu_swap_end_component);
 }
 
 void ComputeTouchAndWheelScrollLatencyHistograms(
+    RenderWidgetHostDelegate* render_widget_host_delegate,
     const ui::LatencyInfo::LatencyComponent& gpu_swap_begin_component,
     const ui::LatencyInfo::LatencyComponent& gpu_swap_end_component,
     int64_t latency_component_id,
     const ui::LatencyInfo& latency,
     const std::string event_type_name) {
   DCHECK(!latency.coalesced());
   if (latency.coalesced())
     return;
 
   LatencyInfo::LatencyComponent original_component;
@@ skipping 21 matching lines @@
                  ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
                  latency_component_id, &original_component)) {
     // This UMA metric tracks the time from when the original touch event is
     // created to when the scroll gesture results in final frame swap.
     // First scroll events are excluded from this metric.
     if (event_type_name == "Touch") {
       UMA_HISTOGRAM_TOUCH_WHEEL_TO_SCROLL_LATENCY(
           "Event.Latency.ScrollUpdate." + event_type_name +
               ".TimeToScrollUpdateSwapBegin2",
           original_component, gpu_swap_begin_component);
+
+      rappor::RapporService* rappor_service =
+          GetContentClient()->browser()->GetRapporService();
+      if (rappor_service && render_widget_host_delegate) {
+        std::unique_ptr<rappor::Sample> sample =
+            rappor_service->CreateSample(rappor::UMA_RAPPOR_TYPE);
+        render_widget_host_delegate->AddDomainInfoToRapporSample(sample.get());
+        sample->SetUInt64Field("Latency",
+                               (gpu_swap_begin_component.last_event_time -
+                                original_component.first_event_time)
+                                   .InMicroseconds(),
+                               rappor::NO_NOISE);
+        rappor_service->RecordSample(
+            "Event.Latency.ScrollUpdate.Touch.TimeToScrollUpdateSwapBegin2",
+            std::move(sample));
+      }
     }
   } else {
     // No original component found.
     return;
   }
 
   LatencyInfo::LatencyComponent rendering_scheduled_component;
   bool rendering_scheduled_on_main = latency.FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT, 0,
       &rendering_scheduled_component);
@@ skipping 73 matching lines @@
 }
 
 }  // namespace
 
 RenderWidgetHostLatencyTracker::RenderWidgetHostLatencyTracker()
     : last_event_id_(0),
       latency_component_id_(0),
       device_scale_factor_(1),
       has_seen_first_gesture_scroll_update_(false),
       multi_finger_gesture_(false),
-      touch_start_default_prevented_(false) {}
+      touch_start_default_prevented_(false),
+      render_widget_host_delegate_(nullptr) {}
 
 RenderWidgetHostLatencyTracker::~RenderWidgetHostLatencyTracker() {}
 
 void RenderWidgetHostLatencyTracker::Initialize(int routing_id,
                                                 int process_id) {
   DCHECK_EQ(0, last_event_id_);
   DCHECK_EQ(0, latency_component_id_);
   last_event_id_ = static_cast<int64_t>(process_id) << 32;
   latency_component_id_ = routing_id | last_event_id_;
 }
@@ skipping 318 matching lines @@
 
   if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
                            latency_component_id_, nullptr)) {
     return;
   }
 
   ui::SourceEventType source_event_type = latency.source_event_type();
   if (source_event_type == ui::SourceEventType::WHEEL ||
       source_event_type == ui::SourceEventType::TOUCH) {
     ComputeTouchAndWheelScrollLatencyHistograms(
-        gpu_swap_begin_component, gpu_swap_end_component, latency_component_id_,
-        latency,
+        render_widget_host_delegate_, gpu_swap_begin_component,
+        gpu_swap_end_component, latency_component_id_, latency,
         source_event_type == ui::SourceEventType::WHEEL ? "Wheel" : "Touch");
   }
 
   // Compute the old scroll update latency metrics. They are exclusively
   // calculated for touch scrolls, and will be deprecated on M56.
   // (https://crbug.com/649754)
   LatencyInfo::LatencyComponent mouse_wheel_scroll_update_component;
   if (!latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_GENERATE_SCROLL_UPDATE_FROM_MOUSE_WHEEL, 0,
           &mouse_wheel_scroll_update_component)) {
     ComputeScrollLatencyHistograms(
         gpu_swap_begin_component, gpu_swap_end_component, latency_component_id_,
         latency, is_running_navigation_hint_task);
   }
 }
 
+void RenderWidgetHostLatencyTracker::SetDelegate(
+    RenderWidgetHostDelegate* delegate) {
+  render_widget_host_delegate_ = delegate;
+}
+
 }  // namespace content