Bundle DidOverscrollParams with the InputEventAck

content/browser/renderer_host/input/input_router_impl.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/input_router_impl.h"
 
 #include <math.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 253 matching lines @@
 
   // A fixed page scale or mobile viewport should disable the touch ack timeout.
   UpdateTouchAckTimeoutEnabled();
 }
 
 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   bool message_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(InputRouterImpl, message, message_is_ok)
     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
+    IPC_MESSAGE_HANDLER(InputHostMsg_DidOverscroll, OnDidOverscroll)
     IPC_MESSAGE_HANDLER(ViewHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_SelectRange_ACK, OnSelectRangeAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
                         OnSetTouchAction)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!message_is_ok)
@@ skipping 199 matching lines @@
   wheelEvent.deltaY = 100.0f * log(pinch_event.event.data.pinchUpdate.scale);
   wheelEvent.hasPreciseScrollingDeltas = true;
   wheelEvent.wheelTicksX = 0;
   wheelEvent.wheelTicksY =
       pinch_event.event.data.pinchUpdate.scale > 1 ? 1 : -1;
 
   SendWheelEvent(QueuedWheelEvent(
       MouseWheelEventWithLatencyInfo(wheelEvent, pinch_event.latency), true));
 }
 
-void InputRouterImpl::OnInputEventAck(WebInputEvent::Type event_type,
-                                      InputEventAckState ack_result,
-                                      const ui::LatencyInfo& latency_info) {
+void InputRouterImpl::OnInputEventAck(const InputEventAck& ack) {
   client_->DecrementInFlightEventCount();
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 
-  ProcessInputEventAck(event_type, ack_result, latency_info, RENDERER);
+  if (ack.overscroll)

[tdresser, 2014/05/14 18:20:08]

Although its redundant, I think it would be clearer to test if the event is a
GestureScrollUpdate before checking if it overscrolled.

[jdduke (slow), 2014/05/19 20:48:02]

Done.

+    OnDidOverscroll(*ack.overscroll);
+
+  ProcessInputEventAck(ack.type, ack.state, ack.latency, RENDERER);
   // 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
   // is not actually typesafe) and avoids this error.
-  int type = static_cast<int>(event_type);
+  int type = static_cast<int>(ack.type);
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       Source<void>(this),
       Details<int>(&type));
 }
 
+void InputRouterImpl::OnDidOverscroll(const DidOverscrollParams& params) {
+  client_->DidOverscroll(params);
+}
+
 void InputRouterImpl::OnMsgMoveCaretAck() {
   move_caret_pending_ = false;
   if (next_move_caret_)
     SendMoveCaret(next_move_caret_.Pass());
 }
 
 void InputRouterImpl::OnSelectRangeAck() {
   select_range_pending_ = false;
   if (next_selection_range_)
     SendSelectRange(next_selection_range_.Pass());
@@ skipping 211 matching lines @@
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent(
     const MouseWheelEventWithLatencyInfo& event,
     bool synthesized_from_pinch)
     : event(event), synthesized_from_pinch(synthesized_from_pinch) {
 }
 
 InputRouterImpl::QueuedWheelEvent::~QueuedWheelEvent() {
 }
 
 }  // namespace content