Coalesce async touch move events until the ack back from render

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 239 matching lines @@
          mouse_move_pending_ ||
          mouse_wheel_pending_ ||
          select_message_pending_ ||
          move_caret_pending_;
 }
 
 bool InputRouterImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(InputRouterImpl, message)
     IPC_MESSAGE_HANDLER(InputHostMsg_HandleInputEvent_ACK, OnInputEventAck)
+    IPC_MESSAGE_HANDLER(InputHostMsg_HandleUncancelableTouchMoveEvent_ACK,
+                        OnUncancelableTouchMoveAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_DidOverscroll, OnDidOverscroll)
     IPC_MESSAGE_HANDLER(InputHostMsg_MoveCaret_ACK, OnMsgMoveCaretAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_SelectRange_ACK, OnSelectMessageAck)
     IPC_MESSAGE_HANDLER(InputHostMsg_MoveRangeSelectionExtent_ACK,
                         OnSelectMessageAck)
     IPC_MESSAGE_HANDLER(ViewHostMsg_HasTouchEventHandlers,
                         OnHasTouchEventHandlers)
     IPC_MESSAGE_HANDLER(InputHostMsg_SetTouchAction,
                         OnSetTouchAction)
     IPC_MESSAGE_HANDLER(InputHostMsg_DidStopFlinging, OnDidStopFlinging)
@@ skipping 79 matching lines @@
                                       bool is_keyboard_shortcut) {
   output_stream_validator_.Validate(input_event);
 
   if (OfferToClient(input_event, latency_info))
     return;
 
   OfferToRenderer(input_event, latency_info, is_keyboard_shortcut);
 
   // Touch events should always indicate in the event whether they are
   // cancelable (respect ACK disposition) or not.
-  bool ignores_ack = WebInputEventTraits::IgnoresAckDisposition(input_event);
-  if (WebInputEvent::isTouchEventType(input_event.type)) {
+  bool ignores_ack =

[jdduke (slow), 2015/04/15 17:14:53]

Let's change this to read:

|bool needs_synthetic_ack =
WebInputEventTraits::WillReceiveAckFromRenderer(input_event);|

Might be worth adding a brief router test to make sure we get balanced ack
counts for both a cancelable and uncancelable touchmove?

[lanwei, 2015/04/17 20:49:00]

Done.

+      !WebInputEventTraits::WillReceiveAckFromRenderer(input_event);
+  if (WebInputEvent::isTouchEventType(input_event.type) &&
+      input_event.type != WebInputEvent::TouchMove) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
-    DCHECK_NE(ignores_ack, !!touch.cancelable);
+    DCHECK_NE(ignores_ack, touch.cancelable);
   }
 
   // If we don't care about the ack disposition, send the ack immediately.
   if (ignores_ack) {
     ProcessInputEventAck(input_event.type,
                          INPUT_EVENT_ACK_STATE_IGNORED,
                          latency_info,
                          IGNORING_DISPOSITION);
   }
 }
@@ skipping 25 matching lines @@
 }
 
 bool InputRouterImpl::OfferToRenderer(const WebInputEvent& input_event,
                                       const ui::LatencyInfo& latency_info,
                                       bool is_keyboard_shortcut) {
   if (Send(new InputMsg_HandleInputEvent(
           routing_id(), &input_event, latency_info, is_keyboard_shortcut))) {
     // Ack messages for ignored ack event types should never be sent by the
     // renderer. Consequently, such event types should not affect event time
     // or in-flight event count metrics.
-    if (!WebInputEventTraits::IgnoresAckDisposition(input_event)) {
+    if (WebInputEventTraits::WillReceiveAckFromRenderer(input_event)) {
       input_event_start_time_ = TimeTicks::Now();
       client_->IncrementInFlightEventCount();
     }
     return true;
   }
   return false;
 }
 
 void InputRouterImpl::OnInputEventAck(
     const InputHostMsg_HandleInputEvent_ACK_Params& 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);
 
   if (ack.overscroll) {
     DCHECK(ack.type == WebInputEvent::MouseWheel ||
            ack.type == WebInputEvent::GestureScrollUpdate);
     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

[jdduke (slow), 2015/04/15 17:14:53]

Let's kill all of this NotificationService code, I don't think it's used any
longer even for testing.

[lanwei, 2015/04/17 20:49:00]

Done.

   // 'void' instead is just as safe (since NotificationSource
   // is not actually typesafe) and avoids this error.
   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::OnUncancelableTouchMoveAck() {
+  touch_event_queue_.ProcessUncancelableTouchMoveAck();

[jdduke (slow), 2015/04/15 17:14:53]

We also need:

client_->DecrementInFlightEventCount();
UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", TimeTicks::Now() -
input_event_start_time_);

[lanwei, 2015/04/17 20:49:00]

Done.

+}
+
 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());
 }
 
@@ skipping 178 matching lines @@
     return;
 
   if (HasPendingEvents())
     return;
 
   flush_requested_ = false;
   client_->DidFlush();
 }
 
 }  // namespace content