Add telemetry to track the time an event spent waiting for the main thread.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 2082 matching lines @@
     InputEventAckState ack_result) {
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
   if (overscroll_controller_)
     overscroll_controller_->ReceivedEventACK(wheel_event, processed);
 
   if (!processed && !is_hidden() && view_)
     view_->UnhandledWheelEvent(wheel_event);
 }
 
 void RenderWidgetHostImpl::OnGestureEventAck(
-    const WebKit::WebGestureEvent& event,
+    const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
   if (overscroll_controller_)
-    overscroll_controller_->ReceivedEventACK(event, processed);
+    overscroll_controller_->ReceivedEventACK(event.event, processed);
 
   if (view_)
-    view_->GestureEventAck(event.type, ack_result);
+    view_->GestureEventAck(event.event.type, ack_result);
+
+  UpdateRenderingStatsForImplThreadLatency(event.event.type, event.latency);
 }
 
 void RenderWidgetHostImpl::OnTouchEventAck(
     const TouchEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   ComputeTouchLatency(event.latency);
   if (view_)
     view_->ProcessAckedTouchEvent(event, ack_result);
 }
 
@@ skipping 236 matching lines @@
   // Clear the new_auto_size_ since the empty value is used as a flag to
   // indicate that no callback is in progress (i.e. without this line
   // DelayedAutoResized will not get called again).
   new_auto_size_.SetSize(0, 0);
   if (!should_auto_resize_)
     return;
 
   OnRenderAutoResized(new_size);
 }
 
+void RenderWidgetHostImpl::UpdateRenderingStatsForImplThreadLatency(

[nduca, 2013/08/15 01:41:04]

I'd like to see you modify enough of the input router etc so that InputRouter is
able to track stats. E.g. every input event that you give to the input router
comes back with latency info. Can you think of a way to change the host side
interfaces to permit this?

+    WebKit::WebInputEvent::Type type,
+    const ui::LatencyInfo& latency_info) {
+  ui::LatencyInfo::LatencyComponent dispatch_component;
+  ui::LatencyInfo::LatencyComponent receive_component;
+  if (!latency_info.FindLatency(
+          ui::INPUT_EVENT_LATENCY_EVENT_SENT_FROM_IMPL_THREAD_COMPONENT,
+          routing_id_, &dispatch_component) ||
+      !latency_info.FindLatency(
+          ui::INPUT_EVENT_LATENCY_EVENT_RECEIVED_ON_MAIN_THREAD_COMPONENT,
+          routing_id_, &receive_component))
+    return;
+
+  bool stats_changed = false;
+  if (WebKit::WebInputEvent::isTouchEventType(type)) {
+    rendering_stats_.total_impl_to_main_touch_event_latency +=
+        (receive_component.event_time - dispatch_component.event_time);
+    rendering_stats_.impl_to_main_touch_event_count++;
+    stats_changed = true;
+  } else if (type == WebKit::WebInputEvent::GestureScrollBegin ||
+      type == WebKit::WebInputEvent::GestureScrollUpdate ||
+      type == WebKit::WebInputEvent::GestureScrollUpdateWithoutPropagation) {
+    rendering_stats_.total_impl_to_main_gesture_scroll_event_latency +=
+        (receive_component.event_time - dispatch_component.event_time);
+    rendering_stats_.impl_to_main_gesture_scroll_event_count++;
+    stats_changed = true;
+  }
+
+  if (stats_changed && CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableGpuBenchmarking))
+    Send(new ViewMsg_SetBrowserRenderingStats(routing_id_, rendering_stats_));
+}
+
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 void RenderWidgetHostImpl::ComputeTouchLatency(
     const ui::LatencyInfo& latency_info) {
   ui::LatencyInfo::LatencyComponent ui_component;
   ui::LatencyInfo::LatencyComponent rwh_component;
   ui::LatencyInfo::LatencyComponent acked_component;
 
@@ skipping 99 matching lines @@
     int process_id = (b->first.second >> 32) & 0xffffffff;
     RenderWidgetHost* rwh =
         RenderWidgetHost::FromID(process_id, routing_id);
     if (!rwh)
       continue;
     RenderWidgetHostImpl::From(rwh)->FrameSwapped(latency_info);
   }
 }
 
 }  // namespace content