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 288 matching lines @@
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!message_is_ok)
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
 
   return handled;
 }
 
 void ImmediateInputRouter::OnTouchEventAck(
-    const TouchEventWithLatencyInfo& event,
-    InputEventAckState ack_result) {
-  ack_handler_->OnTouchEventAck(event, ack_result);
+    const WebKit::WebTouchEvent& event,
+    InputEventAckState ack_result,
+    ui::LatencyInfo* latency) {
+  ack_handler_->OnTouchEventAck(event, ack_result, latency);
 }
 
 bool ImmediateInputRouter::SendSelectRange(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_SelectRange::ID);
   if (select_range_pending_) {
     next_selection_range_ = message.Pass();
     return true;
   }
 
   select_range_pending_ = true;
@@ skipping 29 matching lines @@
     const WebInputEvent& input_event,
     const ui::LatencyInfo& latency_info,
     bool is_keyboard_shortcut) {
   TRACE_EVENT0("input", "ImmediateInputRouter::FilterAndSendWebInputEvent");
 
   if (!process_->HasConnection())
     return;
 
   DCHECK(!process_->IgnoreInputEvents());
 
+  ui::LatencyInfo renderer_latency;
   // Perform optional, synchronous event handling, sending ACK messages for
   // processed events, or proceeding as usual.
   InputEventAckState filter_ack = client_->FilterInputEvent(input_event,
                                                             latency_info);
   switch (filter_ack) {
     // Send the ACK and early exit.
     case INPUT_EVENT_ACK_STATE_CONSUMED:
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
       next_mouse_move_.reset();
-      ProcessInputEventAck(input_event.type, filter_ack, latency_info);
+      ProcessInputEventAck(input_event.type, filter_ack, &renderer_latency);
       // WARNING: |this| may be deleted at this point.
       return;
 
     case INPUT_EVENT_ACK_STATE_UNKNOWN: {
       if (input_event.type == WebKit::WebInputEvent::MouseMove) {
         // Since this mouse-move event has been consumed, there will be no ACKs.
         // So reset the state here so that future mouse-move events do reach the
         // renderer.
         mouse_move_pending_ = false;
       } else if (input_event.type == WebKit::WebInputEvent::MouseWheel) {
         // Reset the wheel-event state when appropriate.
         mouse_wheel_pending_ = false;
       } else if (WebInputEvent::isGestureEventType(input_event.type) &&
                  gesture_event_filter_->HasQueuedGestureEvents()) {
         // If the gesture-event filter has queued gesture events, that implies
         // it's awaiting an ack for the event. Since the event is being dropped,
         // it is never sent to the renderer, and so it won't receive any ACKs.
         // So send the ACK to the gesture event filter immediately, and mark it
         // as having been processed.
         gesture_event_filter_->ProcessGestureAck(true, input_event.type);
       } else if (WebInputEvent::isTouchEventType(input_event.type)) {
         // During an overscroll gesture initiated by touch-scrolling, the
         // touch-events do not reset or contribute to the overscroll gesture.
         // However, the touch-events are not sent to the renderer. So send an
         // ACK to the touch-event queue immediately. Mark the event as not
         // processed, to make sure that the touch-scroll gesture that initiated
         // the overscroll is updated properly.
         touch_event_queue_->ProcessTouchAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
-                                            latency_info);
+                                            renderer_latency);
       }
       return;
     }
 
     // Proceed as normal.
     case INPUT_EVENT_ACK_STATE_NOT_CONSUMED:
       break;
   }
 
   // Transmit any pending wheel events on a non-wheel event. This ensures that
@@ skipping 10 matching lines @@
 
   SendWebInputEvent(input_event, latency_info, is_keyboard_shortcut);
 
   // Any input event cancels a pending mouse move event.
   next_mouse_move_.reset();
 }
 
 void ImmediateInputRouter::OnInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
-    const ui::LatencyInfo& latency_info) {
+    ui::LatencyInfo latency_info) {

[jdduke (slow), 2013/10/08 16:28:08]

So, we're copying the ui::LatencyInfo here, only to pass a pointer to it... that
would be fine if the modification is done inside the ImmediateInputRouter, but
it looks like the only modifier is |ack_handler_|.  I hate to do this, but could
you please undo all the arg modifications here in the ImmediateInputRouter and
in the InputAckHandler, and go back to the previous model, passing by const ref?
 If you're going to have to make a copy somewhere, I'd prefer it be as close as
possible to the place where the copy is required
(RenderWidgetHostImpl::On*EventAck, and only when it has the necessary
components that warrant a copy). 

[Yufeng Shen (Slow to review), 2013/10/08 19:35:59]

Done.

   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 
   client_->DecrementInFlightEventCount();
 
-  ProcessInputEventAck(event_type, ack_result, latency_info);
+  ProcessInputEventAck(event_type, ack_result, &latency_info);
 }
 
 void ImmediateInputRouter::OnMsgMoveCaretAck() {
   move_caret_pending_ = false;
   if (next_move_caret_)
     SendMoveCaret(next_move_caret_.Pass());
 }
 
 void ImmediateInputRouter::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_)
     SendSelectRange(next_selection_range_.Pass());
 }
 
 void ImmediateInputRouter::OnHasTouchEventHandlers(bool has_handlers) {
  if (has_touch_handler_ == has_handlers)
     return;
   has_touch_handler_ = has_handlers;
   if (!has_handlers)
     touch_event_queue_->FlushQueue();
   client_->OnHasTouchEventHandlers(has_handlers);
 }
 
 void ImmediateInputRouter::ProcessInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
-    const ui::LatencyInfo& latency_info) {
+    ui::LatencyInfo* latency_info) {
   TRACE_EVENT1("input", "ImmediateInputRouter::ProcessInputEventAck",
                "ack", GetEventAckName(ack_result));
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // 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);
+    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) {
+void ImmediateInputRouter::ProcessWheelAck(InputEventAckState ack_result,
+                                           ui::LatencyInfo* latency) {
   mouse_wheel_pending_ = false;
 
+  // TODO(miletus): Add renderer side latency to each uncoalesced mouse
+  // wheel event and add terminal component to each of them.
+  ui::LatencyInfo combined_latency = current_wheel_event_.latency;
+  combined_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_.event,
+                                ack_result,
+                                &combined_latency);
 
   // 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,
+                                             ui::LatencyInfo* latency) {
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
+  // TODO(miletus): Add renderer side latency to each uncoalesced gesture
+  // event event and add terminal component to each of them.
   ack_handler_->OnGestureEventAck(
-      gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
+      gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result, latency);
   gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
 void ImmediateInputRouter::ProcessTouchAck(
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   touch_event_queue_->ProcessTouchAck(ack_result, latency_info);
 }
 
 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