Coalesce async touch move events until the ack back from render

content/browser/renderer_host/input/touch_event_queue.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/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
@@ skipping 354 matching lines @@
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client,
                                  const Config& config)
     : client_(client),
       dispatching_touch_ack_(false),
       dispatching_touch_(false),
       has_handlers_(true),
       has_handler_for_current_sequence_(false),
       drop_remaining_touches_in_sequence_(false),
       touchmove_slop_suppressor_(new TouchMoveSlopSuppressor),
       send_touch_events_async_(false),
+      pending_uncancelable_event_ack_count_(0),
+      sent_uncancelable_touch_move_count_(0),
       last_sent_touch_timestamp_sec_(0) {
   DCHECK(client);
   if (config.touch_ack_timeout_supported) {
     timeout_handler_.reset(
         new TouchTimeoutHandler(this, config.touch_ack_timeout_delay));
   }
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   TRACE_EVENT0("input", "TouchEventQueue::QueueEvent");

[tdresser, 2015/03/25 14:16:18]

Might as well leave that whitespace there.

[lanwei, 2015/03/26 11:54:38]

Done.

-
   // If the queueing of |event| was triggered by an ack dispatch, defer
   // processing the event until the dispatch has finished.
   if (touch_queue_.empty() && !dispatching_touch_ack_) {
     // Optimization of the case without touch handlers.  Removing this path
     // yields identical results, but this avoids unnecessary allocations.
     PreFilterResult filter_result = FilterBeforeForwarding(event.event);
     if (filter_result != FORWARD_TO_RENDERER) {
       client_->OnTouchEventAck(event,
                                filter_result == ACK_WITH_NO_CONSUMER_EXISTS
                                    ? INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS
@@ skipping 21 matching lines @@
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const LatencyInfo& latency_info) {
   TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
 
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
   if (timeout_handler_ && timeout_handler_->ConfirmTouchEvent(ack_result))
     return;
 
   touchmove_slop_suppressor_->ConfirmTouchEvent(ack_result);

[tdresser, 2015/03/25 14:16:18]

Might as well leave that whitespace there.

[lanwei, 2015/03/26 11:54:38]

Done.

-
   if (touch_queue_.empty())
     return;
 
   PopTouchEventToClient(ack_result, latency_info);
   TryForwardNextEventToRenderer();
 }
 
+void TouchEventQueue::ProcessUncancelableTouchMoveAck() {
+  TRACE_EVENT0("input", "TouchEventQueue::ProcessUncancelableTouchMoveAck");
+
+  DCHECK(!dispatching_touch_ack_);
+  dispatching_touch_ = false;
+
+  // Ignore the acks for uncancelable touchmoves when we have a touch event
+  // rather than uncancelable touchmoves and flush pending async touchmove.
+  if (pending_uncancelable_event_ack_count_ > 0) {
+    --pending_uncancelable_event_ack_count_;
+    return;
+  }
+
+  // Decrease the count once we receive the ack back from render for
+  // uncancelable touchmoves.
+  --sent_uncancelable_touch_move_count_;
+
+  // Send the next pending async touch move once we receive the ack.
+  if (pending_async_touchmove_) {
+    TouchEventWithLatencyInfo touch = *pending_async_touchmove_;
+    touch.event.cancelable = !send_touch_events_async_;
+    pending_async_touchmove_.reset();
+    if (!touch.event.cancelable)
+      ++sent_uncancelable_touch_move_count_;
+    touch_queue_.push_front(new CoalescedWebTouchEvent(touch, true));
+    SendTouchEventImmediately(&touch);
+  }
+}
+
 void TouchEventQueue::TryForwardNextEventToRenderer() {
   DCHECK(!dispatching_touch_ack_);
   // If there are queued touch events, then try to forward them to the renderer
   // immediately, or ACK the events back to the client if appropriate.
   while (!touch_queue_.empty()) {
     PreFilterResult filter_result =
         FilterBeforeForwarding(touch_queue_.front()->coalesced_event().event);
     switch (filter_result) {
       case ACK_WITH_NO_CONSUMER_EXISTS:
         PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
         break;
       case ACK_WITH_NOT_CONSUMED:
         PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
         break;
       case FORWARD_TO_RENDERER:
         ForwardNextEventToRenderer();
         return;
     }
   }
 }
 
 void TouchEventQueue::ForwardNextEventToRenderer() {
   TRACE_EVENT0("input", "TouchEventQueue::ForwardNextEventToRenderer");
 
   DCHECK(!empty());
   DCHECK(!dispatching_touch_);
   TouchEventWithLatencyInfo touch = touch_queue_.front()->coalesced_event();
-
   if (send_touch_events_async_ &&
       touch.event.type == WebInputEvent::TouchMove) {
     // Throttling touchmove's in a continuous touchmove stream while scrolling
     // reduces the risk of jank. However, it's still important that the web
     // application be sent touches at key points in the gesture stream,
     // e.g., when the application slop region is exceeded or touchmove
     // coalescing fails because of different modifiers.
     bool send_touchmove_now = size() > 1;
     send_touchmove_now |= pending_async_touchmove_ &&
                           !pending_async_touchmove_->CanCoalesceWith(touch);
     send_touchmove_now |=
         touch.event.timeStampSeconds >=
         last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec;
 
-    if (!send_touchmove_now) {
+    if (!send_touchmove_now || sent_uncancelable_touch_move_count_ > 0) {
       if (!pending_async_touchmove_) {
         pending_async_touchmove_.reset(new TouchEventWithLatencyInfo(touch));
       } else {
         DCHECK(pending_async_touchmove_->CanCoalesceWith(touch));
         pending_async_touchmove_->CoalesceWith(touch);
       }
       DCHECK_EQ(1U, size());
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
       // It's possible (though unlikely) that ack'ing the current touch will
       // trigger the queueing of another touch event (e.g., a touchcancel). As
       // forwarding of the queued event will be deferred while the ack is being
       // dispatched (see |OnTouchEvent()|), try forwarding it now.
       TryForwardNextEventToRenderer();
       return;
     }
   }
 
   last_sent_touch_timestamp_sec_ = touch.event.timeStampSeconds;
-
   // Flush any pending async touch move. If it can be combined with the current
   // (touchmove) event, great, otherwise send it immediately but separately. Its
   // ack will trigger forwarding of the original |touch| event.
   if (pending_async_touchmove_) {
     if (pending_async_touchmove_->CanCoalesceWith(touch)) {
       pending_async_touchmove_->CoalesceWith(touch);
       pending_async_touchmove_->event.cancelable = !send_touch_events_async_;
       touch = *pending_async_touchmove_;
       pending_async_touchmove_.reset();
     } else {
+      // Once we flush the pending async touch move, we ignore all the acks
+      // from the uncancelable touch moves that we sent out and wait for acks
+      // back.
+      ++sent_uncancelable_touch_move_count_;
       scoped_ptr<TouchEventWithLatencyInfo> async_move =
           pending_async_touchmove_.Pass();
       async_move->event.cancelable = false;
       touch_queue_.push_front(new CoalescedWebTouchEvent(*async_move, true));
       SendTouchEventImmediately(async_move.get());
       return;
     }
   }
 
   // Note: Touchstart events are marked cancelable to allow transitions between
   // platform scrolling and JS pinching. Touchend events, however, remain
   // uncancelable, mitigating the risk of jank when transitioning to a fling.
   if (send_touch_events_async_ && touch.event.type != WebInputEvent::TouchStart)
     touch.event.cancelable = false;
 
   // A synchronous ack will reset |dispatching_touch_|, in which case
   // the touch timeout should not be started.
   base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
+
+  // We increase the count when we send out a uncancelable touch move, and we
+  // use pending_uncancelable_event_ack_count_ to keep track the number of
+  // acks we do not wait any more when we flush pending async touch moves.
+  if (touch.event.type == WebInputEvent::TouchMove && !touch.event.cancelable) {
+    ++sent_uncancelable_touch_move_count_;
+  } else {
+    pending_uncancelable_event_ack_count_ +=
+        sent_uncancelable_touch_move_count_;
+    sent_uncancelable_touch_move_count_ = 0;
+  }
   SendTouchEventImmediately(&touch);
   if (dispatching_touch_ && timeout_handler_)
     timeout_handler_->StartIfNecessary(touch);
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   if (gesture_event.event.type == blink::WebInputEvent::GestureScrollBegin) {
     if (has_handler_for_current_sequence_ &&
         !drop_remaining_touches_in_sequence_) {
@@ skipping 209 matching lines @@
     if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
       send_touch_events_async_ = false;
     has_handler_for_current_sequence_ |=
         ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   } else if (WebTouchEventTraits::IsTouchSequenceEnd(event)) {
     has_handler_for_current_sequence_ = false;
   }
 }
 
 }  // namespace content