Add more input metrics to 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"
@@ skipping 83 matching lines @@
     name,                                                          \
     (end.event_time - start.event_time).InMicroseconds(),          \
     1, 50000, 50)
 
 // Check valid timing for start and end latency components.
 #define CONFIRM_VALID_TIMING(start, end)     \
   DCHECK(!start.first_event_time.is_null()); \
   DCHECK(!end.last_event_time.is_null());    \
   DCHECK_GE(end.last_event_time, start.first_event_time);
 
+// Touch/wheel to scroll latency using Rappor.
+#define RAPPOR_TOUCH_WHEEL_TO_SCROLL_LATENCY(delegate, name, start, end) \
+  CONFIRM_VALID_TIMING(start, end)                                       \
+  rappor::RapporService* rappor_service =                                \
+      GetContentClient()->browser()->GetRapporService();                 \
+  if (rappor_service && delegate) {                                      \
+    std::unique_ptr<rappor::Sample> sample =                             \
+        rappor_service->CreateSample(rappor::UMA_RAPPOR_TYPE);           \
+    delegate->AddDomainInfoToRapporSample(sample.get());                 \
+    sample->SetUInt64Field(                                              \
+        "Latency",                                                       \
+        (end.last_event_time - start.first_event_time).InMicroseconds(), \
+        rappor::NO_NOISE);                                               \
+    rappor_service->RecordSample(name, std::move(sample));               \
+  }
+
 // Touch/wheel to scroll latency that is mostly under 1 second.
 #define UMA_HISTOGRAM_TOUCH_WHEEL_TO_SCROLL_LATENCY(name, start, end)         \
   CONFIRM_VALID_TIMING(start, end)                                            \
   base::Histogram::FactoryGet(name, 1, 1000000, 100,                          \
                               base::HistogramBase::kUmaTargetedHistogramFlag) \
       ->Add((end.last_event_time - start.first_event_time).InMicroseconds());
 
 // Long touch/wheel scroll latency component that is mostly under 200ms.
 #define UMA_HISTOGRAM_SCROLL_LATENCY_LONG_2(name, start, end)                 \
   CONFIRM_VALID_TIMING(start, end)                                            \
@@ skipping 127 matching lines @@
 }
 
 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());
+  DCHECK(event_type_name == "Touch" || event_type_name == "Wheel");
   if (latency.coalesced())
     return;
 
   LatencyInfo::LatencyComponent original_component;
   std::string scroll_name = "ScrollUpdate";
   if (latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT,
           latency_component_id, &original_component)) {
     scroll_name = "ScrollBegin";
     // This UMA metric tracks the time between the final frame swap for the
     // first scroll event in a sequence and the original timestamp of that
     // scroll event's underlying touch/wheel event.
 
     UMA_HISTOGRAM_TOUCH_WHEEL_TO_SCROLL_LATENCY(
         "Event.Latency.ScrollBegin." + event_type_name +
             ".TimeToScrollUpdateSwapBegin2",
         original_component, gpu_swap_begin_component);
 
+    RAPPOR_TOUCH_WHEEL_TO_SCROLL_LATENCY(
+        render_widget_host_delegate,
+        "Event.Latency.ScrollBegin." + event_type_name +
+            ".TimeToScrollUpdateSwapBegin2",
+        original_component, gpu_swap_begin_component);
+
     // TODO(lanwei): Will remove them when M56 is stable, see
     // https://crbug.com/669618.
     UMA_HISTOGRAM_TOUCH_WHEEL_TO_SCROLL_LATENCY(
         "Event.Latency.ScrollUpdate." + event_type_name +
             ".TimeToFirstScrollUpdateSwapBegin2",
         original_component, gpu_swap_begin_component);
   } else if (latency.FindLatency(
                  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));
-      }
+      RAPPOR_TOUCH_WHEEL_TO_SCROLL_LATENCY(
+          render_widget_host_delegate,
+          "Event.Latency.ScrollUpdate.Touch.TimeToScrollUpdateSwapBegin2",
+          original_component, gpu_swap_begin_component);
     }
   } 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 437 matching lines @@
         latency, is_running_navigation_hint_task);
   }
 }
 
 void RenderWidgetHostLatencyTracker::SetDelegate(
     RenderWidgetHostDelegate* delegate) {
   render_widget_host_delegate_ = delegate;
 }
 
 }  // namespace content