Prevent partial touch sequences from reaching the renderer

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/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
@@ skipping 15 matching lines @@
 
 TouchEventWithLatencyInfo ObtainCancelEventForTouchEvent(
     const TouchEventWithLatencyInfo& event_to_cancel) {
   TouchEventWithLatencyInfo event = event_to_cancel;
   event.event.type = WebInputEvent::TouchCancel;
   for (size_t i = 0; i < event.event.touchesLength; i++)
     event.event.touches[i].state = WebTouchPoint::StateCancelled;
   return event;
 }
 
-bool IsNewTouchGesture(const WebTouchEvent& event) {
+bool IsNewTouchSequence(const WebTouchEvent& event) {
   if (event.type != WebInputEvent::TouchStart)
     return false;
   if (!event.touchesLength)
     return false;
   for (size_t i = 0; i < event.touchesLength; i++) {
     if (event.touches[i].state != WebTouchPoint::StatePressed)
       return false;
   }
   return true;
 }
@@ skipping 26 matching lines @@
   bool ConfirmTouchEvent(InputEventAckState ack_result) {
     switch (pending_ack_state_) {
       case PENDING_ACK_NONE:
         timeout_monitor_.Stop();
         return false;
       case PENDING_ACK_ORIGINAL_EVENT:
         if (AckedTimeoutEventRequiresCancel(ack_result)) {
           SetPendingAckState(PENDING_ACK_CANCEL_EVENT);
           TouchEventWithLatencyInfo cancel_event =
               ObtainCancelEventForTouchEvent(timeout_event_);
-          touch_queue_->UpdateTouchAckStates(
-              cancel_event.event, kDefaultNotForwardedAck);
           touch_queue_->client_->SendTouchEventImmediately(cancel_event);
         } else {
           SetPendingAckState(PENDING_ACK_NONE);
           touch_queue_->UpdateTouchAckStates(timeout_event_.event, ack_result);
         }
         return true;
       case PENDING_ACK_CANCEL_EVENT:
         SetPendingAckState(PENDING_ACK_NONE);
         return true;
     }
@@ skipping 24 matching lines @@
     SetPendingAckState(PENDING_ACK_ORIGINAL_EVENT);
     touch_queue_->FlushQueue();
   }
 
   // Skip a cancel event if the timed-out event had no consumer and was the
   // initial event in the gesture.
   bool AckedTimeoutEventRequiresCancel(InputEventAckState ack_result) const {
     DCHECK(HasTimeoutEvent());
     if (ack_result != INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
       return true;
-    return !IsNewTouchGesture(timeout_event_.event);
+    return !IsNewTouchSequence(timeout_event_.event);
   }
 
   void SetPendingAckState(PendingAckState new_pending_ack_state) {
     DCHECK_NE(pending_ack_state_, new_pending_ack_state);
     switch (new_pending_ack_state) {
       case PENDING_ACK_ORIGINAL_EVENT:
         DCHECK_EQ(pending_ack_state_, PENDING_ACK_NONE);
         TRACE_EVENT_ASYNC_BEGIN0("input", "TouchEventTimeout", this);
         break;
       case PENDING_ACK_CANCEL_EVENT:
@@ skipping 94 matching lines @@
   // when the event is acked.
   bool ignore_ack_;
 
   DISALLOW_COPY_AND_ASSIGN(CoalescedWebTouchEvent);
 };
 
 TouchEventQueue::TouchEventQueue(TouchEventQueueClient* client)
     : client_(client),
       dispatching_touch_ack_(NULL),
       dispatching_touch_(false),
-      has_handlers_(false),
-      scroll_in_progress_(false),
-      renderer_is_consuming_touch_gesture_(false),
+      touch_filtering_state_(TOUCH_FILTERING_STATE_DEFAULT),
       ack_timeout_enabled_(false) {
   DCHECK(client);
 }
 
 TouchEventQueue::~TouchEventQueue() {
   if (!touch_queue_.empty())
     STLDeleteElements(&touch_queue_);
 }
 
 void TouchEventQueue::QueueEvent(const TouchEventWithLatencyInfo& event) {
-  // Optimization of the case without touch handlers.  Removing this path
-  // yields identical results, but this avoids unnecessary allocations.
-  if (!has_handlers_) {
-    DCHECK(touch_queue_.empty());
-    client_->OnTouchEventAck(event, kDefaultNotForwardedAck);
-    return;
-  }
-
   // 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.
+    if (touch_filtering_state_ == DROP_ALL_TOUCHES ||
+        (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE &&
+         !IsNewTouchSequence(event.event))) {
+      client_->OnTouchEventAck(event, kDefaultNotForwardedAck);
+      return;
+    }
+
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
     touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
     TryForwardNextEventToRenderer();
     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))
       return;
   }
   touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const ui::LatencyInfo& latency_info) {
   DCHECK(!dispatching_touch_ack_);
   dispatching_touch_ = false;
 
   if (timeout_handler_ && timeout_handler_->ConfirmTouchEvent(ack_result))
     return;
 
   if (touch_queue_.empty())
     return;
 
-  if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED)
-    renderer_is_consuming_touch_gesture_ = true;
+  if (ack_result == INPUT_EVENT_ACK_STATE_CONSUMED &&
+      touch_filtering_state_ == FORWARD_TOUCHES_UNTIL_TIMEOUT)
+    touch_filtering_state_ = FORWARD_ALL_TOUCHES;
 
   const WebTouchEvent& acked_event =
       touch_queue_.front()->coalesced_event().event;
   UpdateTouchAckStates(acked_event, 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 (IsNewTouchGesture(touch.event)) {
-      touch_ack_states_.clear();
-      renderer_is_consuming_touch_gesture_ = false;
-    }
     if (ShouldForwardToRenderer(touch.event)) {
       ForwardToRenderer(touch);
       break;
     }
     PopTouchEventToClient(kDefaultNotForwardedAck, ui::LatencyInfo());
   }
 }
 
 void TouchEventQueue::ForwardToRenderer(
     const TouchEventWithLatencyInfo& touch) {
   DCHECK(!dispatching_touch_);
+  DCHECK_NE(touch_filtering_state_, DROP_ALL_TOUCHES);
+
+  if (IsNewTouchSequence(touch.event)) {
+    touch_filtering_state_ =
+        ack_timeout_enabled_ ? FORWARD_TOUCHES_UNTIL_TIMEOUT
+                             : FORWARD_ALL_TOUCHES;
+    touch_ack_states_.clear();
+  }
+
   // 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);
   client_->SendTouchEventImmediately(touch);
-  if (ack_timeout_enabled_ &&
-      dispatching_touch_ &&
-      !renderer_is_consuming_touch_gesture_ &&
+  if (dispatching_touch_ &&
+      touch_filtering_state_ == FORWARD_TOUCHES_UNTIL_TIMEOUT &&
       ShouldTouchTypeTriggerTimeout(touch.event.type)) {
     DCHECK(timeout_handler_);
     timeout_handler_->Start(touch);
   }
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
-  blink::WebInputEvent::Type type = gesture_event.event.type;
-  if (type == blink::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 (scroll_in_progress_ || !dispatching_touch_ack_)
-      return;
-    scroll_in_progress_ = true;
+  if (gesture_event.event.type != blink::WebInputEvent::GestureScrollBegin)
+    return;
 
-    // If we have a timeout event, a cancel has already been dispatched
-    // for the current touch stream.
-    if (HasTimeoutEvent())
-      return;
+  // We assume that scroll events are generated synchronously from
+  // dispatching a touch event ack. This allows us to generate a synthetic
+  // cancel event that has the same touch ids as the touch event that
+  // is being acked. Otherwise, we don't perform the touch-cancel optimization.
+  if (!dispatching_touch_ack_)
+    return;
 
-    // Fake a TouchCancel to cancel the touch points of the touch event
-    // that is currently being acked.
-    // Note: |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(new CoalescedWebTouchEvent(
-        ObtainCancelEventForTouchEvent(
-            dispatching_touch_ack_->coalesced_event()), true));
-  } else if (type == blink::WebInputEvent::GestureScrollEnd ||
-             type == blink::WebInputEvent::GestureFlingStart) {
-    scroll_in_progress_ = false;
-  }
+  if (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE)
+    return;
+
+  touch_filtering_state_ = DROP_TOUCHES_IN_SEQUENCE;
+
+  // Fake a TouchCancel to cancel the touch points of the touch event
+  // that is currently being acked.
+  // Note: |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(new CoalescedWebTouchEvent(
+      ObtainCancelEventForTouchEvent(
+          dispatching_touch_ack_->coalesced_event()), true));
 }
 
 void TouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
-  if (has_handlers_ == has_handlers)
-    return;
 
-  has_handlers_ = has_handlers;
-
-  if (!has_handlers_) {
-    // TODO(jdduke): Synthesize a TouchCancel if necessary to update Blink touch
-    // state tracking.
+  if (has_handlers) {
+    if (touch_filtering_state_ == DROP_ALL_TOUCHES) {
+      // If no touch handler was previously registered, ensure that we don't
+      // send a partial touch sequence to the renderer.
+      DCHECK(touch_queue_.empty());
+      touch_filtering_state_ = DROP_TOUCHES_IN_SEQUENCE;
+    }
+  } else {
+    touch_filtering_state_ = DROP_ALL_TOUCHES;

[Rick Byers, 2014/01/23 18:40:14]

I had to think about this for a minute to convince myself that you don't need
the "TODO send touchcancel" anymore.  Can you add a comment saying (I think)
something like: Since there are no handlers, there's no need to send any
remaining events in the current sequence (they'd just be ignored anyway).

I'm actually not 100% convinced that this is OK - eg. somethin in blink may
expect consistent begin/end pairs, but I'm not aware of anything offhand and I
think the risk is low.

[jdduke (slow), 2014/01/24 05:29:22]

Ahh, I actually never intended to remove that TODO.  I'll put it back in.

     if (timeout_handler_)
       timeout_handler_->Reset();
     if (!touch_queue_.empty())
       ProcessTouchAck(kDefaultNotForwardedAck, ui::LatencyInfo());
     // As there is no touch handler, ack'ing the event should flush the queue.
     DCHECK(touch_queue_.empty());
-  } else {
-    DCHECK(touch_queue_.empty());
-    // Prevent a partial sequence from being sent to the renderer.
-    TouchPointAckStates::iterator ack_it = touch_ack_states_.begin();
-    for (; ack_it != touch_ack_states_.end(); ++ack_it)
-      ack_it->second = kDefaultNotForwardedAck;
   }
 }
 
 bool TouchEventQueue::IsPendingAckTouchStart() const {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return false;
 
   const blink::WebTouchEvent& event =
       touch_queue_.front()->coalesced_event().event;
@@ skipping 23 matching lines @@
 }
 
 const TouchEventWithLatencyInfo&
 TouchEventQueue::GetLatestEventForTesting() const {
   return touch_queue_.back()->coalesced_event();
 }
 
 void TouchEventQueue::FlushQueue() {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
+  if (touch_filtering_state_ != DROP_ALL_TOUCHES)
+    touch_filtering_state_ = DROP_TOUCHES_IN_SEQUENCE;
   while (!touch_queue_.empty())
     PopTouchEventToClient(kDefaultNotForwardedAck, ui::LatencyInfo());
 }
 
 void TouchEventQueue::PopTouchEventToClient(
     InputEventAckState ack_result,
     const ui::LatencyInfo& renderer_latency_info) {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return;
@@ skipping 14 matching lines @@
     iter->latency.AddNewLatencyFrom(renderer_latency_info);
     client_->OnTouchEventAck((*iter), ack_result);
   }
 }
 
 bool TouchEventQueue::ShouldForwardToRenderer(
     const WebTouchEvent& event) const {
   if (HasTimeoutEvent())
     return false;
 
-  if (!has_handlers_)
+  if (touch_filtering_state_ == DROP_ALL_TOUCHES)
     return false;
 
-  if (scroll_in_progress_ &&
-      event.type != blink::WebInputEvent::TouchCancel)
+  if (touch_filtering_state_ == DROP_TOUCHES_IN_SEQUENCE &&
+      event.type != WebInputEvent::TouchCancel) {
+    if (IsNewTouchSequence(event))
+      return true;
     return false;
+  }
 
   // Touch press events should always be forwarded to the renderer.
   if (event.type == WebInputEvent::TouchStart)
     return true;
 
   for (unsigned int i = 0; i < event.touchesLength; ++i) {
     const WebTouchPoint& point = event.touches[i];
     // If a point has been stationary, then don't take it into account.
     if (point.state == WebTouchPoint::StateStationary)
       continue;
@@ skipping 27 matching lines @@
   } else if (event.type == WebInputEvent::TouchStart) {
     for (unsigned i = 0; i < event.touchesLength; ++i) {
       const WebTouchPoint& point = event.touches[i];
       if (point.state == WebTouchPoint::StatePressed)
         touch_ack_states_[point.id] = ack_result;
     }
   }
 }
 
 }  // namespace content