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"
 
@@ skipping 74 matching lines @@
 
   // This is the list of the original events that were coalesced.
   WebTouchEventWithLatencyList events_;
 
   DISALLOW_COPY_AND_ASSIGN(CoalescedWebTouchEvent);
 };
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client)
     : client_(client),
       dispatching_touch_ack_(false),
-      no_touch_move_to_renderer_(false) {
+      no_touch_to_renderer_(false),
+      synthesized_cancel_event_(NULL) {
   DCHECK(client);
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
+  latest_event_ = event;
   // 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_) {
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
     touch_queue_.push_back(new CoalescedWebTouchEvent(event));
     if (ShouldForwardToRenderer(event.event))
       client_->SendTouchEventImmediately(event);
     else
       PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS,
                             ui::LatencyInfo());
     return;
   }
 
   // If the last queued touch-event was a touch-move, and the current event is
   // 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))
+    if (last_event->CoalesceEventIfPossible(event)) {
+      latest_event_ = last_event->coalesced_event();
       return;
+    }
   }
   touch_queue_.push_back(new CoalescedWebTouchEvent(event));
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const ui::LatencyInfo& latency_info) {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return;
 
@@ skipping 26 matching lines @@
         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) {
+  if (gesture_event.event.type == WebKit::WebInputEvent::GestureScrollBegin) {
+    if (no_touch_to_renderer_)
+      return;
+    no_touch_to_renderer_ = true;
+    TouchEventWithLatencyInfo cancel_event = GetLatestEvent();
+    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;
+    DCHECK(!synthesized_cancel_event_);
+    synthesized_cancel_event_ = new CoalescedWebTouchEvent(cancel_event);
+    touch_queue_.push_front(synthesized_cancel_event_);

[sadrul, 2013/09/23 16:17:33]

When is this cancel event actually dispatched to the renderer?

[jdduke (slow), 2013/09/23 16:34:34]

Inserting the cancel at the front... The only way this will work is if
GestureScrollBegin came synchronously from a PopTouchEventToClient (i.e.,
|dispatching_touch_ack_| is true).  We cannot make that assumption...  

Otherwise, if the queue was previously empty, as sadrul@ suggests, the cancel
will never be forwarded, and we'll just keep queueing events.  If the queue was
non-empty, and so a touch-event was in-flight, we'll be ack'ing the wrong event
in ProcessTouchAck.

[Yufeng Shen (Slow to review), 2013/09/23 20:49:34]

How about :
1) if the touch_queue_ is empty, we enqueue the cancel event and send it to
renderer immediately
2) if the touch_queue is not empty, we insert the cancel event after the first
event in the queue.

Does this seem correct ? My only concern is that if the touch_queue_ is empty,
and we are in dispatching ack, would sending the touch cancel cause any problem
?

+  }
+
+  if (gesture_event.event.type == WebKit::WebInputEvent::GestureScrollEnd ||

[sadrul, 2013/09/23 16:17:33]

else if 

+      gesture_event.event.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();
+  return latest_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();
 
+  // Don't send the synthesized touch cancel to view.
+  if (acked_event.get() == synthesized_cancel_event_) {
+    synthesized_cancel_event_ = NULL;
+    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::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