Send touch cancel to renderer when scrolling starts

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/debug/trace_event.h"
 #include "base/stl_util.h"
 
 namespace content {
 
 typedef std::vector<TouchEventWithLatencyInfo> WebTouchEventWithLatencyList;
 
 // This class represents a single coalesced touch event. However, it also keeps
 // track of all the original touch-events that were coalesced into a single
 // event. The coalesced event is forwarded to the renderer, while the original
 // touch-events are sent to the Client (on ACK for the coalesced event) so that
 // the Client receives the event with their original timestamp.
 class CoalescedWebTouchEvent {
  public:
   explicit CoalescedWebTouchEvent(const TouchEventWithLatencyInfo& event)
-      : coalesced_event_(event) {
+      : coalesced_event_(event),
+        ignore_ack_(false) {
     events_.push_back(event);
     TRACE_EVENT_ASYNC_BEGIN0(
         "input", "TouchEventQueue::QueueEvent", this);
   }
 
   ~CoalescedWebTouchEvent() {
     TRACE_EVENT_ASYNC_END0(
         "input", "TouchEventQueue::QueueEvent", this);
   }
 
   // Coalesces the event with the existing event if possible. Returns whether
   // the event was coalesced.
   bool CoalesceEventIfPossible(
       const TouchEventWithLatencyInfo& event_with_latency) {
     if (coalesced_event_.event.type == WebKit::WebInputEvent::TouchMove &&
         event_with_latency.event.type == WebKit::WebInputEvent::TouchMove &&
         coalesced_event_.event.modifiers ==
         event_with_latency.event.modifiers &&
         coalesced_event_.event.touchesLength ==
-        event_with_latency.event.touchesLength) {
+        event_with_latency.event.touchesLength &&
+        !ignore_ack_) {
       TRACE_EVENT_INSTANT0(
           "input", "TouchEventQueue::MoveCoalesced", TRACE_EVENT_SCOPE_THREAD);
       events_.push_back(event_with_latency);
       // The WebTouchPoints include absolute position information. So it is
       // sufficient to simply replace the previous event with the new event.
       // However, it is necessary to make sure that all the points have the
       // correct state, i.e. the touch-points that moved in the last event, but
       // didn't change in the current event, will have Stationary state. It is
       // necessary to change them back to Moved state.
       const WebKit::WebTouchEvent last_event = coalesced_event_.event;
@@ skipping 18 matching lines @@
   WebTouchEventWithLatencyList::const_iterator begin() const {
     return events_.begin();
   }
 
   WebTouchEventWithLatencyList::const_iterator end() const {
     return events_.end();
   }
 
   size_t size() const { return events_.size(); }
 
+  bool ignore_ack() const { return ignore_ack_; }
+  void set_ignore_ack(bool value) { ignore_ack_ = value; }
+
  private:
   // This is the event that is forwarded to the renderer.
   TouchEventWithLatencyInfo coalesced_event_;
 
   // This is the list of the original events that were coalesced.
   WebTouchEventWithLatencyList events_;
 
+  // If |ignore_ack_| is true, don't send this touch event to client
+  // when the event is acked.
+  bool ignore_ack_;
+
   DISALLOW_COPY_AND_ASSIGN(CoalescedWebTouchEvent);
 };
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client)
     : client_(client),
-      dispatching_touch_ack_(false),
-      no_touch_move_to_renderer_(false) {
+      dispatching_touch_ack_(NULL),
+      no_touch_to_renderer_(false) {
   DCHECK(client);
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
   // If the queueing of |event| was triggered by an ack dispatch, defer
@@ skipping 40 matching lines @@
       if (point.state == WebKit::WebTouchPoint::StatePressed)
         touch_ack_states_[point.id] = ack_result;
     }
   }
 
   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()) {
     const TouchEventWithLatencyInfo& touch =
         touch_queue_.front()->coalesced_event();
     if (ShouldForwardToRenderer(touch.event)) {
       client_->SendTouchEventImmediately(touch);
       break;
     }
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS,
                           ui::LatencyInfo());
   }
 }
 
+void TouchEventQueue::OnGestureScrollEvent(
+    const GestureEventWithLatencyInfo& gesture_event) {
+  WebKit::WebInputEvent::Type type = gesture_event.event.type;
+  if (type == WebKit::WebInputEvent::GestureScrollBegin) {
+    // We assume the scroll event are generated synchronously from
+    // dispatching a touch event ack, so that we can fake a cancel
+    // event that has the correct touch ids as the touch event that
+    // is being acked. If not, we don't do the touch-cancel optimization.
+    if (no_touch_to_renderer_ || !dispatching_touch_ack_)
+      return;
+    no_touch_to_renderer_ = true;
+    // Fake a TouchCancel to cancel the touch points of the touch event
+    // that is currently being acked.
+    TouchEventWithLatencyInfo cancel_event =
+        dispatching_touch_ack_->coalesced_event();
+    cancel_event.event.type = WebKit::WebInputEvent::TouchCancel;
+    for (size_t i = 0; i < cancel_event.event.touchesLength; i++)
+      cancel_event.event.touches[i].state =
+          WebKit::WebTouchPoint::StateCancelled;
+    CoalescedWebTouchEvent* coalesced_cancel_event =
+        new CoalescedWebTouchEvent(cancel_event);
+    // Ignore the ack of the touch cancel so when it is acked, it won't get
+    // sent to gesture recognizer.
+    coalesced_cancel_event->set_ignore_ack(true);
+    // |dispatching_touch_ack_| is non-null when we reach here, meaning we
+    // are in the scope of PopTouchEventToClient() and that no touch event
+    // in the queue is waiting for ack from renderer. So we can just insert
+    // the touch cancel at the beginning of the queue.
+    touch_queue_.push_front(coalesced_cancel_event);
+  } else if (type == WebKit::WebInputEvent::GestureScrollEnd ||
+             type == WebKit::WebInputEvent::GestureFlingStart) {
+    no_touch_to_renderer_ = false;
+  }
+}
+
 void TouchEventQueue::FlushQueue() {
   DCHECK(!dispatching_touch_ack_);
   while (!touch_queue_.empty())
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
                           ui::LatencyInfo());
 }
 
 size_t TouchEventQueue::GetQueueSize() const {
   return touch_queue_.size();
 }
 
 const TouchEventWithLatencyInfo& TouchEventQueue::GetLatestEvent() const {
   return touch_queue_.back()->coalesced_event();
 }
 
 void TouchEventQueue::PopTouchEventToClient(
     InputEventAckState ack_result,
     const ui::LatencyInfo& renderer_latency_info) {
   if (touch_queue_.empty())
     return;
   scoped_ptr<CoalescedWebTouchEvent> acked_event(touch_queue_.front());
   touch_queue_.pop_front();
 
+  if (acked_event->ignore_ack())
+    return;
+
   // Note that acking the touch-event may result in multiple gestures being sent
   // to the renderer, or touch-events being queued.
-  base::AutoReset<bool> dispatching_touch_ack(&dispatching_touch_ack_, true);
+  base::AutoReset<CoalescedWebTouchEvent*>
+      dispatching_touch_ack(&dispatching_touch_ack_, acked_event.get());
 
   base::TimeTicks now = base::TimeTicks::HighResNow();
   for (WebTouchEventWithLatencyList::const_iterator iter = acked_event->begin(),
        end = acked_event->end();
        iter != end; ++iter) {
     ui::LatencyInfo* latency = const_cast<ui::LatencyInfo*>(&(iter->latency));
     latency->AddNewLatencyFrom(renderer_latency_info);
     latency->AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_ACKED_COMPONENT, 0, 0, now, 1);
     client_->OnTouchEventAck((*iter), ack_result);
   }
 }
 
 bool TouchEventQueue::ShouldForwardToRenderer(
     const WebKit::WebTouchEvent& event) const {
+  if (no_touch_to_renderer_ &&
+      event.type != WebKit::WebInputEvent::TouchCancel)
+    return false;
+
   // Touch press events should always be forwarded to the renderer.
   if (event.type == WebKit::WebInputEvent::TouchStart)
     return true;
 
-  if (event.type == WebKit::WebInputEvent::TouchMove &&
-      no_touch_move_to_renderer_)
-    return false;
-
   for (unsigned int i = 0; i < event.touchesLength; ++i) {
     const WebKit::WebTouchPoint& point = event.touches[i];
     // If a point has been stationary, then don't take it into account.
     if (point.state == WebKit::WebTouchPoint::StateStationary)
       continue;
 
     if (touch_ack_states_.count(point.id) > 0) {
       if (touch_ack_states_.find(point.id)->second !=
           INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
         return true;
     } else {
       // If the ACK status of a point is unknown, then the event should be
       // forwarded to the renderer.
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace content