Send input event's LatencyInfo back from renderer to browser when acked

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_router_client.h"
@@ skipping 343 matching lines @@
 
   // 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);
+      ProcessInputEventAck(input_event.type, filter_ack, latency_info);
       // 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);
+        touch_event_queue_->ProcessTouchAck(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
+                                            latency_info);
       }
       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
   // the renderer receives the final PhaseEnded wheel event, which is necessary
   // to terminate rubber-banding, for example.
   if (input_event.type != WebInputEvent::MouseWheel) {
     for (size_t i = 0; i < coalesced_mouse_wheel_events_.size(); ++i) {
       SendWebInputEvent(coalesced_mouse_wheel_events_[i].event,
                        coalesced_mouse_wheel_events_[i].latency,
                       false);
     }
     coalesced_mouse_wheel_events_.clear();
   }
 
   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) {
+void ImmediateInputRouter::OnInputEventAck(
+    WebInputEvent::Type event_type,
+    InputEventAckState ack_result,
+    const ui::LatencyInfo& latency_info) {
   // 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);
+  ProcessInputEventAck(event_type, ack_result, latency_info);
 }
 
 void ImmediateInputRouter::OnMsgMoveCaretAck() {
   move_caret_pending_ = false;
   if (next_move_caret_)
     SendMoveCaret(next_move_caret_.release());
 }
 
 void ImmediateInputRouter::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_)
     SendSelectRange(next_selection_range_.release());
 }
 
 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) {
+void ImmediateInputRouter::ProcessInputEventAck(
+    WebInputEvent::Type event_type,
+    InputEventAckState ack_result,
+    const ui::LatencyInfo& latency_info) {
   TRACE_EVENT1("input", "ImmediateInputRouter::ProcessInputEventAck",
                "ack", GetEventAckName(ack_result));
 
   int type = static_cast<int>(event_type);
   if (type < WebInputEvent::Undefined) {
     client_->OnUnexpectedEventAck(true);
   } 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);
   } else if (WebInputEvent::isTouchEventType(type)) {
-    ProcessTouchAck(ack_result);
+    ProcessTouchAck(ack_result, latency_info);
   } else if (WebInputEvent::isGestureEventType(type)) {
     ProcessGestureAck(type, ack_result);
   }
 
   // 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
@@ skipping 51 matching lines @@
 }
 
 void ImmediateInputRouter::ProcessGestureAck(int type,
                                              InputEventAckState ack_result) {
   const bool processed = (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result);
   client_->OnGestureEventAck(
       gesture_event_filter_->GetGestureEventAwaitingAck(), ack_result);
   gesture_event_filter_->ProcessGestureAck(processed, type);
 }
 
-void ImmediateInputRouter::ProcessTouchAck(InputEventAckState ack_result) {
+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);
+  touch_event_queue_->ProcessTouchAck(ack_result, latency_info);
 }
 
 }  // namespace content