Reland "Add new latency_info for tracking browser composite time."

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"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebTouchEvent;
 using ui::LatencyInfo;
 
 namespace content {
 namespace {
 
 const uint32 kMaxInputCoordinates = LatencyInfo::kMaxInputCoordinates;
+const size_t kBrowserCompositeLatencyHistorySize = 60;
+const double kBrowserCompositeLatencyEstimationPercentile = 90.0;
+const double kBrowserCompositeLatencyEstimationSlack = 1.1;
 
 void UpdateLatencyCoordinatesImpl(const blink::WebTouchEvent& touch,
                                   LatencyInfo* latency) {
   latency->input_coordinates_size =
       std::min(kMaxInputCoordinates, touch.touchesLength);
   for (uint32 i = 0; i < latency->input_coordinates_size; ++i) {
     latency->input_coordinates[i] = LatencyInfo::InputCoordinate(
         touch.touches[i].position.x, touch.touches[i].position.y);
   }
 }
@@ skipping 124 matching lines @@
 
   // Add newly generated components into the latency info
   for (lc = new_components.begin(); lc != new_components.end(); ++lc) {
     latency->latency_components[lc->first] = lc->second;
   }
 }
 
 }  // namespace
 
 RenderWidgetHostLatencyTracker::RenderWidgetHostLatencyTracker()
-    : last_event_id_(0), latency_component_id_(0), device_scale_factor_(1) {
+    : last_event_id_(0),
+      latency_component_id_(0),
+      device_scale_factor_(1),
+      browser_composite_latency_history_(kBrowserCompositeLatencyHistorySize) {
 }
 
 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>(process_id) << 32;
@@ skipping 73 matching lines @@
     return;
   }
 
   // TODO(jdduke): Determine if mouse and keyboard events are worth hooking
   // into LatencyInfo.
 }
 
 void RenderWidgetHostLatencyTracker::OnSwapCompositorFrame(
     std::vector<LatencyInfo>* latencies) {
   DCHECK(latencies);
-  for (LatencyInfo& latency : *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)) {
     return;
   }
@@ skipping 24 matching lines @@
     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);
     }
   }
+
+  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;
+  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