Change input latency result to depend on start of GPU swap

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 118 matching lines @@
             acked_delta.InMicroseconds(), 1, 1000000, 100);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
 void ComputeScrollLatencyHistograms(
-    const LatencyInfo::LatencyComponent& swap_component,
+    const LatencyInfo::LatencyComponent& gpu_swap_component,
     int64 latency_component_id,
-    const ui::LatencyInfo& latency) {
-  DCHECK(!swap_component.event_time.is_null());
+    const LatencyInfo& latency) {
+  DCHECK(!gpu_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
     // first scroll event in a sequence and the original timestamp of that
     // scroll event's underlying touch event.
     for (size_t i = 0; i < first_original_component.event_count; i++) {
       UMA_HISTOGRAM_CUSTOM_COUNTS(
           "Event.Latency.TouchToFirstScrollUpdateSwap",
-          (swap_component.event_time - first_original_component.event_time)
+          (gpu_swap_component.event_time - first_original_component.event_time)
               .InMicroseconds(),
           1, 1000000, 100);
     }
     original_component = first_original_component;
   } else if (!latency.FindLatency(
                  ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
                  latency_component_id, &original_component)) {
     return;
   }
 
   // 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)
+        (gpu_swap_component.event_time - original_component.event_time)
             .InMicroseconds(),
         1, 1000000, 100);
   }
 }
 
 // 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) {
@@ skipping 124 matching lines @@
     std::vector<LatencyInfo>* latencies) {
   DCHECK(latencies);
   for (LatencyInfo& latency : *latencies) {
     AddLatencyInfoComponentIds(&latency, latency_component_id_);
     latency.AddLatencyNumber(
         ui::INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT, 0, 0);
   }
 }
 
 void RenderWidgetHostLatencyTracker::OnFrameSwapped(
-    const ui::LatencyInfo& latency) {
-  LatencyInfo::LatencyComponent swap_component;
-  if (!latency.FindLatency(
-          ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 0,
-          &swap_component)) {
+    const LatencyInfo& latency) {
+  LatencyInfo::LatencyComponent gpu_swap_component;
+  if (!latency.FindLatency(ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0,
+                           &gpu_swap_component)) {
     return;
   }
 
   LatencyInfo::LatencyComponent tab_switch_component;
   if (latency.FindLatency(ui::TAB_SHOW_COMPONENT, latency_component_id_,
                           &tab_switch_component)) {
     base::TimeDelta delta =
-        swap_component.event_time - tab_switch_component.event_time;
+        gpu_swap_component.event_time - tab_switch_component.event_time;
     for (size_t i = 0; i < tab_switch_component.event_count; i++) {
       UMA_HISTOGRAM_TIMES("MPArch.RWH_TabSwitchPaintDuration", delta);
     }
   }
 
   LatencyInfo::LatencyComponent rwh_component;

[Yufeng Shen (Slow to review), 2015/02/12 21:57:50]

nit: this can be removed, and just pass nullptr to the following FindLatency().

   if (!latency.FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
                            latency_component_id_, &rwh_component)) {
     return;
   }
 
-  ComputeScrollLatencyHistograms(swap_component, latency_component_id_,
+  ComputeScrollLatencyHistograms(gpu_swap_component, latency_component_id_,
                                  latency);
 
-  ui::LatencyInfo::LatencyComponent gpu_swap_component;
-  if (!latency.FindLatency(ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT, 0,
-                           &gpu_swap_component)) {
-    return;
-  }
-
-  ui::LatencyInfo::LatencyComponent browser_swap_component;
+  LatencyInfo::LatencyComponent browser_swap_component;
   if (latency.FindLatency(
           ui::INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT, 0,
           &browser_swap_component)) {
     base::TimeDelta delta =
         gpu_swap_component.event_time - browser_swap_component.event_time;
     browser_composite_latency_history_.InsertSample(delta);
   }
 }
 
 base::TimeDelta
 RenderWidgetHostLatencyTracker::GetEstimatedBrowserCompositeTime() const {
   // TODO(brianderson): Remove lower bound on estimate once we're sure it won't
   // 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