Add latency measurement system

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 83 matching lines @@
 bool ShouldCoalesceMouseWheelEvents(const WebMouseWheelEvent& last_event,
                                     const WebMouseWheelEvent& new_event) {
   return last_event.modifiers == new_event.modifiers &&
          last_event.scrollByPage == new_event.scrollByPage &&
          last_event.hasPreciseScrollingDeltas
              == new_event.hasPreciseScrollingDeltas &&
          last_event.phase == new_event.phase &&
          last_event.momentumPhase == new_event.momentumPhase;
 }
 
+int64 g_current_input_number;
+
 }  // namespace
 
 
 // static
 void RenderWidgetHost::RemoveAllBackingStores() {
   BackingStoreManager::RemoveAllBackingStores();
 }
 
 // static
 size_t RenderWidgetHost::BackingStoreMemorySize() {
@@ skipping 34 matching lines @@
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
       tick_active_smooth_scroll_gestures_task_posted_(false),
       touch_event_queue_(new TouchEventQueue(this)),
-      gesture_event_filter_(new GestureEventFilter(this)) {
+      gesture_event_filter_(new GestureEventFilter(this)),
+      incremented_input_number_(false),
+      current_input_number_(0) {
   CHECK(delegate_);
   if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
     surface_id_ = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
         process_->GetID(),
         routing_id_);
   } else {
     // TODO(piman): This is a O(N) lookup, where we could forward the
     // information from the RenderWidgetHelper. The problem is that doing so
     // currently leaks outside of content all the way to chrome classes, and
@@ skipping 265 matching lines @@
   // When accelerated compositing is on, we must always repaint, even when
   // the backing store exists.
   bool needs_repainting;
   if (needs_repainting_on_restore_ || !backing_store ||
       is_accelerated_compositing_active()) {
     needs_repainting = true;
     needs_repainting_on_restore_ = false;
   } else {
     needs_repainting = false;
   }
+
+  SendStartFrame();
+
   Send(new ViewMsg_WasShown(routing_id_, needs_repainting));
 
   process_->WidgetRestored();
 
   bool is_visible = true;
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
       Source<RenderWidgetHost>(this),
       Details<bool>(&is_visible));
 
@@ skipping 35 matching lines @@
     return;
 
   if (in_flight_size_ != gfx::Size() && new_size == in_flight_size_ &&
       !fullscreen_changed)
     return;
 
   // We don't expect to receive an ACK when the requested size is empty.
   if (!new_size.IsEmpty() && size_changed)
     resize_ack_pending_ = true;
 
+  SendStartFrame();
   if (!Send(new ViewMsg_Resize(routing_id_, new_size,
           GetRootWindowResizerRect(), is_fullscreen_))) {
     resize_ack_pending_ = false;
   } else {
     in_flight_size_ = new_size;
   }
 }
 
 void RenderWidgetHostImpl::ResizeRectChanged(const gfx::Rect& new_rect) {
   Send(new ViewMsg_ChangeResizeRect(routing_id_, new_rect));
@@ skipping 389 matching lines @@
                "x", mouse_event.x, "y", mouse_event.y);
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSimulateTouchScreenWithMouse)) {
     SimulateTouchGestureWithMouse(mouse_event);
     return;
   }
 
+  IncrementInputNumber();
+
   if (mouse_event.type == WebInputEvent::MouseDown &&
       gesture_event_filter_->GetTapSuppressionController()->
           ShouldDeferMouseDown(mouse_event))
       return;
   if (mouse_event.type == WebInputEvent::MouseUp &&
       gesture_event_filter_->GetTapSuppressionController()->
           ShouldSuppressMouseUp())
       return;
 
   ForwardMouseEventImmediately(mouse_event);
 }
 
 void RenderWidgetHostImpl::OnPointerEventActivate() {
 }
 
 void RenderWidgetHostImpl::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardWheelEvent");
   if (ignore_input_events_ || process_->IgnoreInputEvents())
     return;
 
+  IncrementInputNumber();
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
   // event, as for mouse moves) results in very slow scrolling on the Mac (on
   // which many, very small wheel events are sent).
   if (mouse_wheel_pending_) {
     if (coalesced_mouse_wheel_events_.empty() ||
         !ShouldCoalesceMouseWheelEvents(coalesced_mouse_wheel_events_.back(),
                                         wheel_event)) {
       coalesced_mouse_wheel_events_.push_back(wheel_event);
     } else {
@@ skipping 144 matching lines @@
     HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
     gesture_event_filter_->FlingHasBeenHalted();
 
     // Only forward the non-native portions of our event.
     ForwardInputEvent(key_event, sizeof(WebKeyboardEvent),
                       is_keyboard_shortcut);
   }
 }
 
+void RenderWidgetHostImpl::IncrementInputNumber() {
+  if (incremented_input_number_)
+    return;
+  g_current_input_number++;
+  current_input_number_ = g_current_input_number;
+  incremented_input_number_ = true;
+  TRACE_EVENT_ASYNC_BEGIN1("frame", "Input processing", this,
+                           "input_number", current_input_number_);
+}
+
+void RenderWidgetHostImpl::SendStartFrame() {
+  IncrementInputNumber();
+  TRACE_EVENT_ASYNC_END1("frame", "Input processing", this,
+                         "input_number", current_input_number_);
+  Send(new ViewMsg_StartFrame(routing_id_, current_input_number_));
+  incremented_input_number_ = false;
+}
+
 void RenderWidgetHostImpl::SendInputEvent(const WebInputEvent& input_event,
                                           int event_size,
                                           bool is_keyboard_shortcut) {
+  IncrementInputNumber();
+  incremented_input_number_ = false;
+
+  TRACE_EVENT_ASYNC_END1("frame", "Input processing", this,
+                         "input_number", current_input_number_);
+
   input_event_start_time_ = TimeTicks::Now();
   Send(new ViewMsg_HandleInputEvent(
-      routing_id_, &input_event, is_keyboard_shortcut));
+      routing_id_, current_input_number_, &input_event, is_keyboard_shortcut));
   increment_in_flight_event_count();
 }
 
 void RenderWidgetHostImpl::ForwardInputEvent(const WebInputEvent& input_event,
                                              int event_size,
                                              bool is_keyboard_shortcut) {
   TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::ForwardInputEvent");
 
   if (!process_->HasConnection())
     return;
@@ skipping 416 matching lines @@
         frame.metadata.page_scale_factor,
         frame.metadata.min_page_scale_factor,
         frame.metadata.max_page_scale_factor,
         gfx::ToCeiledSize(content_size));
   }
 #endif
 }
 
 void RenderWidgetHostImpl::OnUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::OnUpdateRect");
+  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::OnUpdateRect",
+               "input_number", params.latency_info.inputNumber,
+               "render_thread_frame_number",
+                   params.latency_info.rendererMainFrameNumber);
   TimeTicks paint_start = TimeTicks::Now();
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
   // Update our knowledge of the RenderWidget's scroll offset.
   last_scroll_offset_ = params.scroll_offset;
 
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
 
@@ skipping 82 matching lines @@
 }
 
 void RenderWidgetHostImpl::OnUpdateIsDelayed() {
   if (in_get_backing_store_)
     abort_get_backing_store_ = true;
 }
 
 void RenderWidgetHostImpl::DidUpdateBackingStore(
     const ViewHostMsg_UpdateRect_Params& params,
     const TimeTicks& paint_start) {
-  TRACE_EVENT0("renderer_host", "RenderWidgetHostImpl::DidUpdateBackingStore");
+  TRACE_EVENT2("renderer_host", "RenderWidgetHostImpl::DidUpdateBackingStore",
+               "input_number", params.latency_info.inputNumber,
+               "render_thread_frame_number",
+                   params.latency_info.rendererMainFrameNumber);
   TimeTicks update_start = TimeTicks::Now();
 
   if (params.needs_ack) {
     // ACK early so we can prefetch the next PaintRect if there is a next one.
     // This must be done AFTER we're done painting with the bitmap supplied by
     // the renderer. This ACK is a signal to the renderer that the backing store
     // can be re-used, so the bitmap may be invalid after this call.
     Send(new ViewMsg_UpdateRect_ACK(routing_id_));
   }
 
@@ skipping 644 matching lines @@
 void RenderWidgetHostImpl::AcknowledgeBufferPresent(
     int32 route_id, int gpu_host_id,
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim) {
     ui_shim->Send(new AcceleratedSurfaceMsg_BufferPresented(route_id,
                                                             params));
   }
 }
 
+void RenderWidgetHostImpl::NotifyFrameDisplayed(
+    int route_id, int gpu_host_id,
+    const cc::LatencyInfo& latency_info) {
+  GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
+  if (ui_shim)
+    ui_shim->Send(new AcceleratedSurfaceMsg_FrameDisplayed(route_id,
+                                                           latency_info));
+}
+
 void RenderWidgetHostImpl::AcknowledgeSwapBuffersToRenderer() {
   if (!is_threaded_compositing_enabled_)
     Send(new ViewMsg_SwapBuffers_ACK(routing_id_));
 }
 
 #if defined(USE_AURA)
 
 void RenderWidgetHostImpl::ParentChanged(gfx::NativeViewId new_parent) {
 #if defined(OS_WIN)
   HWND hwnd = reinterpret_cast<HWND>(new_parent);
@@ skipping 18 matching lines @@
     return;
 
   OnRenderAutoResized(new_size);
 }
 
 void RenderWidgetHostImpl::DetachDelegate() {
   delegate_ = NULL;
 }
 
 }  // namespace content