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 24 matching lines @@
       WebInputEvent::TouchCancel,
       // TODO(rbyers): Shouldn't we use a fresh timestamp?
       event.event.timeStampSeconds,
       &event.event);
   return event;
 }
 
 bool ShouldTouchTriggerTimeout(const WebTouchEvent& event) {
   return (event.type == WebInputEvent::TouchStart ||
           event.type == WebInputEvent::TouchMove) &&
-         !WebInputEventTraits::IgnoresAckDisposition(event);
+         WebInputEventTraits::WillReceiveAckFromRenderer(event) &&
+         event.cancelable;
 }
 
 // Compare all properties of touch points to determine the state.
 bool HasPointChanged(const WebTouchPoint& point_1,
     const WebTouchPoint& point_2) {
   DCHECK_EQ(point_1.id, point_2.id);
   if (point_1.screenPosition != point_2.screenPosition ||
       point_1.position != point_2.position ||
       point_1.radiusX != point_2.radiusX ||
       point_1.radiusY != point_2.radiusY ||
@@ skipping 19 matching lines @@
         timeout_monitor_(base::Bind(&TouchTimeoutHandler::OnTimeOut,
                                     base::Unretained(this))),
         enabled_(true),
         enabled_for_current_sequence_(false) {
     DCHECK(timeout_delay != base::TimeDelta());
   }
 
   ~TouchTimeoutHandler() {}
 
   void StartIfNecessary(const TouchEventWithLatencyInfo& event) {
-    DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
+    if (pending_ack_state_ != PENDING_ACK_NONE)
+      return;
+
     if (!enabled_)
       return;
 
     if (!ShouldTouchTriggerTimeout(event.event))
       return;
 
     if (WebTouchEventTraits::IsTouchSequenceStart(event.event))
       enabled_for_current_sequence_ = true;
 
     if (!enabled_for_current_sequence_)
@@ skipping 317 matching lines @@
   // also a touch-move, then the events can be coalesced into a single event.
   if (touch_queue_.size() > 1) {
     CoalescedWebTouchEvent* last_event = touch_queue_.back();
     if (last_event->CoalesceEventIfPossible(event))
       return;
   }
   touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
-                                      const LatencyInfo& latency_info) {
+                                      const LatencyInfo& latency_info,
+                                      const uint32 unique_touch_event_id) {
   TRACE_EVENT0("input", "TouchEventQueue::ProcessTouchAck");
 
+  // We receive an ack for async touchmove from render.
+  if (!ack_pending_async_touchmove_ids_.empty() &&
+      ack_pending_async_touchmove_ids_.front() == unique_touch_event_id) {
+    // Remove the first touchmove from the ack_pending_async_touchmove queue.
+    ack_pending_async_touchmove_ids_.pop_front();
+    // Send the next pending async touch move once we receive all acks back.
+    if (pending_async_touchmove_ && ack_pending_async_touchmove_ids_.empty()) {
+      DCHECK(touch_queue_.empty());
+
+      // Dispatch the next pending async touch move when time expires.
+      if (pending_async_touchmove_->event.timeStampSeconds >=
+          last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec) {
+        FlushPendingAsyncTouchmove();
+      }
+    }
+    return;
+  }
+
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
   if (timeout_handler_ && timeout_handler_->ConfirmTouchEvent(ack_result))
     return;
 
   touchmove_slop_suppressor_->ConfirmTouchEvent(ack_result);
 
   if (touch_queue_.empty())
     return;
 
+  DCHECK_EQ(touch_queue_.front()->coalesced_event().event.uniqueTouchEventId,
+            unique_touch_event_id);
+
   PopTouchEventToClient(ack_result, latency_info);
   TryForwardNextEventToRenderer();
 }
 
 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 =
@@ skipping 23 matching lines @@
       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;
+        ack_pending_async_touchmove_ids_.empty() &&
+        (touch.event.timeStampSeconds >=
+         last_sent_touch_timestamp_sec_ + kAsyncTouchMoveIntervalSec);
 
     if (!send_touchmove_now) {
       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);
@@ skipping 11 matching lines @@
   // 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 {
-      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());
+      FlushPendingAsyncTouchmove();
       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);
   SendTouchEventImmediately(&touch);
-  if (dispatching_touch_ && timeout_handler_)
-    timeout_handler_->StartIfNecessary(touch);
+}
+
+void TouchEventQueue::FlushPendingAsyncTouchmove() {
+  DCHECK(!dispatching_touch_);
+  scoped_ptr<TouchEventWithLatencyInfo> touch = pending_async_touchmove_.Pass();
+  touch->event.cancelable = false;
+  touch_queue_.push_front(new CoalescedWebTouchEvent(*touch, true));
+  SendTouchEventImmediately(touch.get());
 }
 
 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_) {
       DCHECK(!touchmove_slop_suppressor_->suppressing_touchmoves())
           <<  "A touch handler should be offered a touchmove before scrolling.";
     }
@@ skipping 119 matching lines @@
         break;
       }
     }
   }
 
   if (last_sent_touchevent_)
     *last_sent_touchevent_ = touch->event;
   else
     last_sent_touchevent_.reset(new WebTouchEvent(touch->event));
 
+  base::AutoReset<bool> dispatching_touch(&dispatching_touch_, true);
+
   client_->SendTouchEventImmediately(*touch);
+
+  // A synchronous ack will reset |dispatching_touch_|, in which case the touch
+  // timeout should not be started and the count also should not be increased.
+  if (dispatching_touch_) {
+    if (touch->event.type == WebInputEvent::TouchMove &&
+        !touch->event.cancelable) {
+      // When we send out a uncancelable touch move, we increase the count and
+      // we do not process input event ack any more, we will just ack to client
+      // and wait for the ack from render. Also we will remove it from the front
+      // of the queue.
+      ack_pending_async_touchmove_ids_.push_back(
+          touch->event.uniqueTouchEventId);
+      dispatching_touch_ = false;
+      PopTouchEventToClient(INPUT_EVENT_ACK_STATE_IGNORED);
+      TryForwardNextEventToRenderer();
+      return;
+    }
+
+    if (timeout_handler_)
+      timeout_handler_->StartIfNecessary(*touch);
+  }
 }
 
 TouchEventQueue::PreFilterResult
 TouchEventQueue::FilterBeforeForwarding(const WebTouchEvent& event) {
   if (WebTouchEventTraits::IsTouchSequenceStart(event)) {
     has_handler_for_current_sequence_ = false;
     send_touch_events_async_ = false;
     pending_async_touchmove_.reset();
     last_sent_touchevent_.reset();
 
@@ skipping 66 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