Report LatencyInfo through trace buffer

content/browser/renderer_host/input/immediate_input_router.cc

 // Copyright 2013 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/input/immediate_input_router.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
@@ skipping 463 matching lines @@
     // now, we can send the next mouse move event
     if (next_mouse_move_) {
       DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
       scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move
           = next_mouse_move_.Pass();
       SendMouseEvent(*next_mouse_move);
     }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     ProcessKeyboardAck(type, ack_result);
   } else if (type == WebInputEvent::MouseWheel) {
-    ProcessWheelAck(ack_result);
+    ProcessWheelAck(ack_result, latency_info);
   } else if (WebInputEvent::isTouchEventType(type)) {
     ProcessTouchAck(ack_result, latency_info);
   } else if (WebInputEvent::isGestureEventType(type)) {
-    ProcessGestureAck(type, ack_result);
+    ProcessGestureAck(type, ack_result, latency_info);
   }
 
   // WARNING: |this| may be deleted at this point.
 
   // This is used only for testing, and the other end does not use the
   // source object.  On linux, specifying
   // Source<RenderWidgetHost> results in a very strange
   // runtime error in the epilogue of the enclosing
   // (ProcessInputEventAck) method, but not on other platforms; using
   // 'void' instead is just as safe (since NotificationSource
@@ skipping 18 matching lines @@
     NativeWebKeyboardEvent front_item = key_queue_.front();
     key_queue_.pop_front();
 
     ack_handler_->OnKeyboardEventAck(front_item, ack_result);
     // WARNING: This ImmediateInputRouter can be deallocated at this point
     // (i.e.  in the case of Ctrl+W, where the call to
     // HandleKeyboardEvent destroys this ImmediateInputRouter).
   }
 }
 
-void ImmediateInputRouter::ProcessWheelAck(InputEventAckState ack_result) {
-  mouse_wheel_pending_ = false;
-
+void ImmediateInputRouter::ProcessWheelAck(InputEventAckState ack_result,
+                                           const ui::LatencyInfo& latency) {
+  // TODO(miletus): Add renderer side latency to each uncoalesced mouse
+  // wheel event and add terminal component to each of them.
+  current_wheel_event_.latency.AddNewLatencyFrom(latency);
   // Process the unhandled wheel event here before calling
   // ForwardWheelEventWithLatencyInfo() since it will mutate
   // current_wheel_event_.
-  ack_handler_->OnWheelEventAck(current_wheel_event_.event, ack_result);
+  ack_handler_->OnWheelEventAck(current_wheel_event_, ack_result);
+  mouse_wheel_pending_ = false;
 
   // Now send the next (coalesced) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     MouseWheelEventWithLatencyInfo next_wheel_event =
         coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     SendWheelEvent(next_wheel_event);
   }
 }
 
 void ImmediateInputRouter::ProcessGestureAck(int type,
-                                             InputEventAckState ack_result) {
+                                             InputEventAckState ack_result,
+                                             const ui::LatencyInfo& latency) {
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
-  ack_handler_->OnGestureEventAck(
-      gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
+  // TODO(miletus): Add renderer side latency to each uncoalesced gesture
+  // event event and add terminal component to each of them.
+  GestureEventWithLatencyInfo event(
+      gesture_event_filter_->GetGestureEventAwaitingAck(), latency);
+  ack_handler_->OnGestureEventAck(event, ack_result);
   gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
 void ImmediateInputRouter::ProcessTouchAck(
     InputEventAckState ack_result,
-    const ui::LatencyInfo& latency_info) {
+    const ui::LatencyInfo& latency) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
-  touch_event_queue_->ProcessTouchAck(ack_result, latency_info);
+  touch_event_queue_->ProcessTouchAck(ack_result, latency);
 }
 
 void ImmediateInputRouter::HandleGestureScroll(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (!enable_no_touch_to_renderer_while_scrolling_)
     return;
 
   // Once scrolling is started stop forwarding touch move events to renderer.
   if (gesture_event.event.type == WebInputEvent::GestureScrollBegin)
     touch_event_queue_->set_no_touch_move_to_renderer(true);
 
   if (gesture_event.event.type == WebInputEvent::GestureScrollEnd ||
       gesture_event.event.type == WebInputEvent::GestureFlingStart) {
     touch_event_queue_->set_no_touch_move_to_renderer(false);
   }
 }
 
 }  // namespace content