Delegate touch handler registration logic to the TouchEventQueue

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 85 matching lines @@
   }
 
   bool HasTimeoutEvent() const {
     return pending_ack_state_ != PENDING_ACK_NONE;
   }
 
   bool IsTimeoutTimerRunning() const {
     return timeout_monitor_.IsRunning();
   }
 
+  void Reset() {
+    pending_ack_state_ = PENDING_ACK_NONE;
+    timeout_monitor_.Stop();
+  }
+
  private:
   enum PendingAckState {
     PENDING_ACK_NONE,
     PENDING_ACK_ORIGINAL_EVENT,
     PENDING_ACK_CANCEL_EVENT,
   };
 
   void OnTimeOut() {
     SetPendingAckState(PENDING_ACK_ORIGINAL_EVENT);
     touch_queue_->FlushQueue();
@@ skipping 113 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),
-      no_touch_to_renderer_(false),
+      has_handlers_(false),
+      scroll_in_progress_(false),
       renderer_is_consuming_touch_gesture_(false),
       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_) {
     // There is no touch event in the queue. Forward it to the renderer
     // immediately.
     touch_queue_.push_back(new CoalescedWebTouchEvent(event, false));
     TryForwardNextEventToRenderer();
     return;
   }
 
@@ skipping 28 matching lines @@
   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))
+    if (IsNewTouchGesture(touch.event)) {
+      touch_ack_states_.clear();

[tdresser, 2014/01/09 21:14:32]

Shouldn't these be cleared per finger, not per gesture?

[jdduke (slow), 2014/01/09 22:05:04]

I thought about adding a DCHECK(touch_ack_states_.empty()), but that is safe
only if the TEQ gets ALL the touch events.  For instance, on Android, if the
first touch down responds with NO_CONSUMER_EXISTS, we cease forwarding any touch
events (for the current sequence).  In that case, |touch_ack_states_| may very
well be non-empty upon the next touch sequence.

As we transition to a unified GR, we'll rely more heavily on the TEQ for
verifying a consistent stream of touches, and we can harden this kind of
assumption.  Good catch.

       renderer_is_consuming_touch_gesture_ = false;
+    }
     if (ShouldForwardToRenderer(touch.event)) {
       ForwardToRenderer(touch);
       break;
     }
     PopTouchEventToClient(kDefaultNotForwardedAck, ui::LatencyInfo());
   }
 }
 
 void TouchEventQueue::ForwardToRenderer(
     const TouchEventWithLatencyInfo& touch) {
@@ skipping 12 matching lines @@
 }
 
 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 (no_touch_to_renderer_ || !dispatching_touch_ack_)
+    if (scroll_in_progress_ || !dispatching_touch_ack_)
       return;
-    no_touch_to_renderer_ = true;
+    scroll_in_progress_ = true;
 
     // If we have a timeout event, a cancel has already been dispatched
     // for the current touch stream.
     if (HasTimeoutEvent())
       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) {
-    no_touch_to_renderer_ = false;
+    scroll_in_progress_ = false;
   }
 }
 
-void TouchEventQueue::FlushQueue() {
+void TouchEventQueue::OnHasTouchEventHandlers(bool has_handlers) {
   DCHECK(!dispatching_touch_ack_);
   DCHECK(!dispatching_touch_);
-  while (!touch_queue_.empty())
-    PopTouchEventToClient(kDefaultNotForwardedAck, ui::LatencyInfo());
+  if (has_handlers_ == has_handlers)
+    return;

[tdresser, 2014/01/09 21:14:32]

This should be a DCHECK, shouldn't it? (Given the way we already do this check
in the input router)

+
+  has_handlers_ = has_handlers;
+
+  if (!has_handlers_) {
+    // TODO(jdduke): Synthesize a TouchCancel if necessary? This would only work
+    // if we cache the last WebTouchEvent sent to the renderer.

[tdresser, 2014/01/09 21:14:32]

Can you give me an example of when we'd want a TouchCancel sent here?

[jdduke (slow), 2014/01/09 22:05:04]

I was talking with rbyers@ about this. He seemed to think that interrupting a
touch sequence mid-stream might have some unintended consequences in the
renderer (blink apparently keeps around some touch state tracking).  I don't
think we have any outstanding bugs related to this, and at the least this change
should not be regressing in any way.  Your call whether you think the comment
worthwhile.

[tdresser, 2014/01/09 22:20:41]

Perhaps "Synthesize a TouchCancel if necessary to update blink touch state
tracking"...
I think having the comment there is reasonable.

+    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;
   return (event.type == WebInputEvent::TouchStart);
@@ skipping 19 matching lines @@
 
 bool TouchEventQueue::IsTimeoutRunningForTesting() const {
   return timeout_handler_ && timeout_handler_->IsTimeoutTimerRunning();
 }
 
 const TouchEventWithLatencyInfo&
 TouchEventQueue::GetLatestEventForTesting() const {
   return touch_queue_.back()->coalesced_event();
 }
 
+void TouchEventQueue::FlushQueue() {
+  DCHECK(!dispatching_touch_ack_);
+  DCHECK(!dispatching_touch_);
+  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;
   scoped_ptr<CoalescedWebTouchEvent> acked_event(touch_queue_.front());
   touch_queue_.pop_front();
 
   if (acked_event->ignore_ack())
@@ skipping 10 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 (no_touch_to_renderer_ &&
+  if (!has_handlers_)
+    return false;
+
+  if (scroll_in_progress_ &&
       event.type != blink::WebInputEvent::TouchCancel)
     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.
@@ skipping 29 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