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),
+        has_been_sent_to_renderer_(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) {

[sadrul, 2013/09/27 15:13:51]

You should check that has_been_sent_to_renderer_ isn't set for either event, and
that ignore_ack_ in the two events match.

[Yufeng Shen (Slow to review), 2013/09/30 20:43:14]

Done.

       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; }
+
+  bool has_been_sent_to_renderer() const { return has_been_sent_to_renderer_; }
+  void set_has_been_sent_to_renderer(bool value) {
+    has_been_sent_to_renderer_ = 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_;
+
+  // Whether the touch event has been sent to renderer.
+  bool has_been_sent_to_renderer_;
+
   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 45 matching lines @@
   PopTouchEventToClient(ack_result, latency_info);
   TryForwardNextEventToRenderer();
 }
 
 void TouchEventQueue::TryForwardNextEventToRenderer() {
   // 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 (touch_queue_.front()->has_been_sent_to_renderer())

[jdduke (slow), 2013/09/30 19:21:51]

You can remove this flag (or make it a DCHECK(!...), by restricting when you
call TryForwardNextEventToRenderer(), as mentioned below.

[Yufeng Shen (Slow to review), 2013/09/30 20:43:14]

removed.

+      break;
     if (ShouldForwardToRenderer(touch.event)) {
       client_->SendTouchEventImmediately(touch);
+      touch_queue_.front()->set_has_been_sent_to_renderer(true);
       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);
+    // If the touch event queue is empty, or the first touch event in the queue
+    // has not been sent to renderer (i.e. not waiting for ack), we insert the
+    // touch cancel at the beginning of the queue to be the first to send.
+    if (touch_queue_.empty() ||
+        !touch_queue_.front()->has_been_sent_to_renderer()) {
+      touch_queue_.push_front(coalesced_cancel_event);
+    } else {
+      // If there there is touch event already sent to the renderer and waiting
+      // for ack, we insert the touch cancel after that touch event.

[sadrul, 2013/09/27 15:13:51]

+ "This cancel event will be dispatched to the renderer in response to the ACK
for the earlier event."

[Yufeng Shen (Slow to review), 2013/09/30 20:43:14]

see the comments below.

+      TouchQueue::iterator it = touch_queue_.begin();
+      it++;
+      touch_queue_.insert(it, coalesced_cancel_event);
+    }
+    TryForwardNextEventToRenderer();

[jdduke (slow), 2013/09/30 19:21:51]

I believe you can remove this call.

|dispatching_touch_ack_| is true means that there is no touch-event in-flight. 
So, the head of the queue has yet to be sent, and you can |.push_front()|
regardless of whether or not the queue is empty.

This also means that we're withing the scope of |ProcessTouchAck()|, which will
make the TryForwardNextEventToRenderer() call for you at the end.

[sadrul, 2013/09/30 20:33:24]

Client::OnTouchEventAck can cause another touch-event to be added to the queue
on android, right (i.e. the ACK for a touch-event can trigger another
touch-event to be added to the queue), in which case the front isn't always the
right place for the touch-cancel event?

[Yufeng Shen (Slow to review), 2013/09/30 20:43:14]

Right. So all the complication comes from that I was afraid the gesture scroll
events
can come async for chrome on android. If in most cases the gesture scroll events
are
generated synchronously from acking a touch event, then the flow is much
simpler. As
jdduke@ said, we can always insert the touch cancel at the beginning of the TEQ.

A few exceptions of chrome on android that gesture scroll does not come from
acking a touch event is:
1. No touch handler on the page at all. So touch events are directly sent to GR
to generate
touch scroll. In this case, |dispatching_touch_ack| would be false, and we don't
fake the
touch cancel, which makes sense since no touch is sent to renderer anyway.
2. There is timeout for getting touch ack, and android touch queue sends a touch
cancel to TEQ and start sending its touch events directly to GR and generate
touch scroll events. In this  case, |dispatching_touch_ack_| is false, so we
don't fake the touch cancel. And chrome on android 's own touch cancel
optimization naturally kicks in.

[sadrul, 2013/10/01 11:32:45]

Thanks for the detailed explanation. This makes sense.

+  } 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());

[sadrul, 2013/09/27 15:13:51]

Hm, this would only work if the acked touch-event generates the scroll-gesture
synchronously, which is the case on cros/win, but is it also always the case on
android? If it is, then this would work. If not, we have to do this differently.
jdduke@: Can you confirm the behaviour on android?

(Sorry, I hadn't considered this during our earlier discussion).

[jdduke (slow), 2013/09/30 19:21:51]

Yup, that's generally the case on Android, and otherwise we'll either send our
own cancel via a timeout, or we never send touches to the TEQ.

I'd like to move the timeout here (behind a flag or something like that) so we
don't have to reason about it in multiple places. 

 
   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