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 329 matching lines @@
   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);
+  bool touch_move_aysnc = false;
   if (WebInputEvent::isTouchEventType(input_event.type)) {
     const WebTouchEvent& touch = static_cast<const WebTouchEvent&>(input_event);
-    DCHECK_NE(ignores_ack, !!touch.cancelable);
+    touch_move_aysnc = !touch.cancelable;
+    if(touch.type !=  WebInputEvent::TouchMove)
+      DCHECK_NE(ignores_ack, touch.cancelable);
   }
 
-  // If we don't care about the ack disposition, send the ack immediately.
-  if (ignores_ack) {
+  // If we don't care about the ack disposition, or it is an async touchmove
+  // event, send the ack immediately.
+  if (ignores_ack || touch_move_aysnc) {
     ProcessInputEventAck(input_event.type,
                          INPUT_EVENT_ACK_STATE_IGNORED,
                          latency_info,
                          IGNORING_DISPOSITION);
   }
 }
 
 bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
                                     const ui::LatencyInfo& latency_info) {
   bool consumed = false;
@@ skipping 44 matching lines @@
   // 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);
   }
 
+  // When we receive ACK from render for async touchmove events, we tell
+  // touch_event_queue right away so it will send out the next touch move in
+  // the queue.
+  if (ack.type == WebInputEvent::TouchMove &&

[jdduke (slow), 2015/03/11 22:37:10]

This seems like it could be racy. When a scroll sequence transitions from being
consumed to unconsumed (changing the value of IsSendingTouchEventsAsync()), it
seems like we could incorrectly mark a touchmove ack as sync/async when that may
not have been the case?

+      touch_event_queue_.IsSendingTouchEventsAsync()) {
+    touch_event_queue_.ReceiveAsyncTouchMoveAck();

[jdduke (slow), 2015/03/11 22:37:10]

I'm a little concerned about the special interaction here between the
TouchEventQueue and the InputRouter.

I wonder if there's any way we could achieve the same result without changing
the InputRouter at all? This would probably mean that, whenever we forward the
async event, we put it in a special async queue separate from the regular queue
(in the TouchEventQueue). That way, it doesn't block the regular queue, and we
can use the async queue to filter out acks as they arrive.  The downside there
is that we'll need a way to map between acks and touches, as it's possible to
get out-of-order acks. Sadly, I think we may need something like that anyway if
we're to achieve nonblocking behavior.

+  }
+
   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.
@@ skipping 199 matching lines @@
   return !touch_event_queue_.empty() ||
          !gesture_event_queue_.empty() ||
          !key_queue_.empty() ||
          mouse_move_pending_ ||
          mouse_wheel_pending_ ||
          select_message_pending_ ||
          move_caret_pending_;
 }
 
 }  // namespace content