Break down end-to-end scroll update latency UMA metrics

content/browser/renderer_host/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/render_widget_host_latency_tracker.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 
@@ skipping 117 matching lines @@
             "Event.Latency.Browser.TouchAcked",
             acked_delta.InMicroseconds(), 1, 1000000, 100);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
+// Long scroll latency component that is mostly under 200ms.
+#define UMA_HISTOGRAM_SCROLL_LATENCY_LONG(name, start, end)        \
+  UMA_HISTOGRAM_CUSTOM_COUNTS(                                     \
+    name,                                                          \
+    (end.event_time - start.event_time).InMicroseconds(),          \
+    1000, 200000, 50)
+
+// Short scroll latency component that is mostly under 50ms.
+#define UMA_HISTOGRAM_SCROLL_LATENCY_SHORT(name, start, end)       \
+  UMA_HISTOGRAM_CUSTOM_COUNTS(                                     \
+    name,                                                          \
+    (end.event_time - start.event_time).InMicroseconds(),          \
+    1, 50000, 50)
+
 void ComputeScrollLatencyHistograms(
     const LatencyInfo::LatencyComponent& swap_component,
     int64 latency_component_id,
     const ui::LatencyInfo& latency) {
   DCHECK(!swap_component.event_time.is_null());
   LatencyInfo::LatencyComponent first_original_component, original_component;
   if (latency.FindLatency(
           ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT,
           latency_component_id, &first_original_component)) {
     // This UMA metric tracks the time between the final frame swap for the
@@ skipping 16 matching lines @@
   // This UMA metric tracks the time from when the original touch event is
   // created (averaged if there are multiple) to when the scroll gesture
   // results in final frame swap.
   for (size_t i = 0; i < original_component.event_count; i++) {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Event.Latency.TouchToScrollUpdateSwap",
         (swap_component.event_time - original_component.event_time)
             .InMicroseconds(),
         1, 1000000, 100);
   }
+
+  LatencyInfo::LatencyComponent rendering_scheduled_component;
+  bool ret = false;
+  bool rendering_scheduled_on_main = latency.FindLatency(
+      ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT,
+      0, &rendering_scheduled_component);
+
+  if (!rendering_scheduled_on_main) {
+    ret = latency.FindLatency(
+        ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT,
+        0, &rendering_scheduled_component);
+    DCHECK(ret);
+    if (!ret) return;
+  }
+
+  DCHECK(rendering_scheduled_component.event_time >=
+         original_component.event_time);
+
+  if (rendering_scheduled_on_main) {
+    UMA_HISTOGRAM_SCROLL_LATENCY_LONG(
+        "Event.Latency.ScrollUpdate.TouchToHandled_Main",
+        original_component, rendering_scheduled_component);
+  } else {
+    UMA_HISTOGRAM_SCROLL_LATENCY_LONG(
+        "Event.Latency.ScrollUpdate.TouchToHandled_Impl",
+        original_component, rendering_scheduled_component);
+  }
+
+  LatencyInfo::LatencyComponent renderer_swap_component;
+  ret = latency.FindLatency(ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT,
+                            0, &renderer_swap_component);
+  DCHECK(ret && renderer_swap_component.event_time >=
+         rendering_scheduled_component.event_time);
+  if (!ret) return;
+
+  if (rendering_scheduled_on_main) {
+    UMA_HISTOGRAM_SCROLL_LATENCY_LONG(
+        "Event.Latency.ScrollUpdate.HandledToRendererSwap_Main",
+        rendering_scheduled_component, renderer_swap_component);
+  } else {
+    UMA_HISTOGRAM_SCROLL_LATENCY_LONG(
+        "Event.Latency.ScrollUpdate.HandledToRendererSwap_Impl",
+        rendering_scheduled_component, renderer_swap_component);
+  }
+
+  LatencyInfo::LatencyComponent browser_received_swap_component;
+  ret = latency.FindLatency(
+          ui::INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT,
+          0, &browser_received_swap_component);
+  DCHECK(ret && browser_received_swap_component.event_time >=
+         renderer_swap_component.event_time);
+  if (!ret) return;
+
+  UMA_HISTOGRAM_SCROLL_LATENCY_SHORT(
+      "Event.Latency.ScrollUpdate.RendererSwapToBrowserNotified",
+      renderer_swap_component, browser_received_swap_component);
+
+  LatencyInfo::LatencyComponent gpu_swap_component;
+  ret = latency.FindLatency(ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT,
+                            0, &gpu_swap_component);
+  DCHECK(ret && gpu_swap_component.event_time >=

[jdduke (slow), 2015/02/18 00:00:16]

Hmm, these combined DCHECK conditions will be difficult to debug in practice.
Maybe let's leave them for a follow-up (back to patchset #6), just add a TODO?

Otherwise, I would use a NOTREACHED() + return for the find failure, and perhaps
add a DCHECK to the UMA macro. Regardless, let's add the validation in a
separate patch.

+         browser_received_swap_component.event_time &&
+         swap_component.event_time >= gpu_swap_component.event_time);
+  if (!ret) return;
+
+  UMA_HISTOGRAM_SCROLL_LATENCY_LONG(
+      "Event.Latency.ScrollUpdate.BrowserNotifiedToBeforeGpuSwap",
+      browser_received_swap_component, gpu_swap_component);
+
+  UMA_HISTOGRAM_SCROLL_LATENCY_SHORT("Event.Latency.ScrollUpdate.GpuSwap",
+                                     gpu_swap_component, swap_component);
 }
 
 // LatencyComponents generated in the renderer must have component IDs
 // provided to them by the browser process. This function adds the correct
 // component ID where necessary.
 void AddLatencyInfoComponentIds(LatencyInfo* latency,
                                 int64 latency_component_id) {
   LatencyInfo::LatencyMap new_components;
   auto lc = latency->latency_components.begin();
   while (lc != latency->latency_components.end()) {
@@ skipping 73 matching lines @@
   }
 }
 
 void RenderWidgetHostLatencyTracker::OnInputEventAck(
     const blink::WebInputEvent& event,
     LatencyInfo* latency) {
   DCHECK(latency);
 
   // Latency ends when it is acked but does not cause render scheduling.
   bool rendering_scheduled = latency->FindLatency(
-      ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 0, NULL);
+      ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT, 0, nullptr);
+  rendering_scheduled |= latency->FindLatency(
+      ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT, 0, nullptr);
 
   if (WebInputEvent::isGestureEventType(event.type)) {
     if (!rendering_scheduled) {
       latency->AddLatencyNumber(
           ui::INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT, 0, 0);
       // TODO(jdduke): Consider exposing histograms for gesture event types.
     }
     return;
   }
 
@@ skipping 83 matching lines @@
   // cause regressions.
   return std::max(
       browser_composite_latency_history_.Percentile(
           kBrowserCompositeLatencyEstimationPercentile) *
           kBrowserCompositeLatencyEstimationSlack,
       base::TimeDelta::FromMicroseconds(
           (1.0f * base::Time::kMicrosecondsPerSecond) / (3.0f * 60)));
 }
 
 }  // namespace content