Delegate touch handler registration logic to the TouchEventQueue

content/browser/renderer_host/input/touch_event_queue_unittest.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 "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/renderer_host/input/timeout_monitor.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
@@ skipping 17 matching lines @@
   TouchEventQueueTest()
       : sent_event_count_(0),
         acked_event_count_(0),
         last_acked_event_state_(INPUT_EVENT_ACK_STATE_UNKNOWN) {}
 
   virtual ~TouchEventQueueTest() {}
 
   // testing::Test
   virtual void SetUp() OVERRIDE {
     queue_.reset(new TouchEventQueue(this));
+    queue_->OnHasTouchEventHandlers(true);
   }
 
   virtual void TearDown() OVERRIDE {
     queue_.reset();
   }
 
   // TouchEventQueueClient
   virtual void SendTouchEventImmediately(
       const TouchEventWithLatencyInfo& event) OVERRIDE {
     ++sent_event_count_;
@@ skipping 90 matching lines @@
   size_t GetAndResetSentEventCount() {
     size_t count = sent_event_count_;
     sent_event_count_ = 0;
     return count;
   }
 
   bool IsPendingAckTouchStart() const {
     return queue_->IsPendingAckTouchStart();
   }
 
-  void Flush() {
-    queue_->FlushQueue();
-  }
-
-  void SetEnableTouchForwarding(bool enabled) {
-    queue_->no_touch_to_renderer_ = !enabled;
+  void OnHasTouchEventHandlers(bool has_handlers) {
+    queue_->OnHasTouchEventHandlers(has_handlers);
   }
 
   bool WillForwardTouchEvents() {
-    return !queue_->no_touch_to_renderer_ && !queue_->HasTimeoutEvent();
+    return queue_->has_handlers_ &&
+           !queue_->scroll_in_progress_ &&
+           !queue_->HasTimeoutEvent();
   }
 
   bool IsTimeoutRunning() {
     return queue_->IsTimeoutRunningForTesting();
   }
 
   size_t queued_event_count() const {
     return queue_->size();
   }
 
   const WebTouchEvent& latest_event() const {
     return queue_->GetLatestEventForTesting().event;
   }
 
   const WebTouchEvent& acked_event() const {
     return last_acked_event_;
   }
 
   const WebTouchEvent& sent_event() const {
     return last_sent_event_;
   }
 
   InputEventAckState acked_event_state() const {
     return last_acked_event_state_;
   }
 
-  void set_no_touch_to_renderer(bool no_touch) {
-    queue_->no_touch_to_renderer_ = no_touch;
-  }
-
-  bool no_touch_to_renderer() const {
-    return queue_->no_touch_to_renderer_;
-  }
-
  private:
   void SendTouchEvent() {
     SendTouchEvent(touch_event_);
     touch_event_.ResetPoints();
   }
 
   scoped_ptr<TouchEventQueue> queue_;
   size_t sent_event_count_;
   size_t acked_event_count_;
   WebTouchEvent last_sent_event_;
@@ skipping 28 matching lines @@
   // Receive an ACK for the second touch-event.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 }
 
 // Tests that the touch-queue is emptied if a page stops listening for touch
 // events.
-TEST_F(TouchEventQueueTest, Flush) {
-  Flush();
+TEST_F(TouchEventQueueTest, QueueFlushedWhenHandlersRemoved) {
+  OnHasTouchEventHandlers(true);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   ReleaseTouchPoint(0);
 
   // Events will be queued until the first sent event is ack'ed.
   for (int i = 5; i < 15; ++i) {
     PressTouchPoint(1, 1);
     MoveTouchPoint(0, i, i);
     ReleaseTouchPoint(0);
   }
   EXPECT_EQ(32U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Receive an ACK for the first touch-event. One of the queued touch-event
   // should be forwarded.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(31U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
 
   // Flush the queue. The touch-event queue should now be emptied, but none of
   // the queued touch-events should be sent to the renderer.
-  Flush();
+  OnHasTouchEventHandlers(false);
   EXPECT_EQ(0U, queued_event_count());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(31U, GetAndResetAckedEventCount());
 }
 
+// Tests that removal of a touch handler during a touch sequence will prevent
+// the remaining sequence from being forwarded, even if another touch handler is
+// registered during the same touch sequence.
+TEST_F(TouchEventQueueTest, ActiveSequenceDroppedWhenHandlersRemoved) {
+  // Send a touch-press event.
+  PressTouchPoint(1, 1);
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, queued_event_count());
+
+  // Queue a touch-move event.
+  MoveTouchPoint(0, 5, 5);
+  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+
+  // Touch handle deregistration should flush the queue.
+  OnHasTouchEventHandlers(false);
+  EXPECT_EQ(2U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, queued_event_count());
+
+  // The ack should be ignored as the touch queue is now empty.
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS);
+  EXPECT_EQ(0U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, queued_event_count());
+
+  // Events should be dropped while there is no touch handler.
+  MoveTouchPoint(0, 10, 10);
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+
+  // Simulate touch handler registration in the middle of a touch sequence.
+  OnHasTouchEventHandlers(true);
+
+  // The touch end for the interrupted sequence should be dropped.
+  ReleaseTouchPoint(0);
+  EXPECT_EQ(0U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+
+  // A new touch sequence should be forwarded properly.
+  PressTouchPoint(1, 1);
+  EXPECT_EQ(1U, queued_event_count());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+}
+
 // Tests that touch-events are coalesced properly in the queue.
 TEST_F(TouchEventQueueTest, Coalesce) {
   // Send a touch-press event.
   PressTouchPoint(1, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
   // Send a few touch-move events, followed by a touch-release event. All the
   // touch-move events should be coalesced into a single event.
   for (int i = 5; i < 15; ++i)
     MoveTouchPoint(0, i, i);
@@ skipping 100 matching lines @@
   MoveTouchPoint(0, 10, 10);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(2U, queued_event_count());
 
   // Receive an ACK for the press. This should cause the queued touch-move to
   // be sent to the renderer.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, queued_event_count());
 
-  Flush();
+  OnHasTouchEventHandlers(false);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, queued_event_count());
 
   // Now receive an ACK for the move.
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_CONSUMED);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, queued_event_count());
 }
 
 // Tests that touch-move events are not sent to the renderer if the preceding
@@ skipping 271 matching lines @@
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
   EXPECT_EQ(WebInputEvent::TouchMove, acked_event().type);
 }
 
 // Tests basic TouchEvent forwarding suppression.
 TEST_F(TouchEventQueueTest, NoTouchBasic) {
   // Disable TouchEvent forwarding.
-  SetEnableTouchForwarding(false);
+  OnHasTouchEventHandlers(false);
   MoveTouchPoint(0, 30, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchMove should not be sent to renderer.
   MoveTouchPoint(0, 65, 10);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchEnd should not be sent to renderer.
   ReleaseTouchPoint(0);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // TouchStart should not be sent to renderer.
   PressTouchPoint(5, 5);
   EXPECT_EQ(0U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   // Enable TouchEvent forwarding.
-  SetEnableTouchForwarding(true);
+  OnHasTouchEventHandlers(true);
 
   PressTouchPoint(80, 10);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 80, 20);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
@@ skipping 250 matching lines @@
 TEST_F(TouchEventQueueTest, NoTouchTimeoutIfAckIsSynchronous) {
   SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
 
   // Queue a TouchStart.
   SetSyncAckResult(INPUT_EVENT_ACK_STATE_CONSUMED);
   ASSERT_FALSE(IsTimeoutRunning());
   PressTouchPoint(0, 1);
   EXPECT_FALSE(IsTimeoutRunning());
 }
 
+// Tests that the timeout is disabled if the touch handler disappears.
+TEST_F(TouchEventQueueTest, TouchTimeoutStoppedIfTouchHandlerRemoved) {
+  SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
+
+  // Queue a TouchStart.
+  PressTouchPoint(0, 1);
+  ASSERT_TRUE(IsTimeoutRunning());
+
+  // Unload the touch handler.
+  OnHasTouchEventHandlers(false);
+  EXPECT_FALSE(IsTimeoutRunning());
+}
+
 // Tests that a TouchCancel timeout plays nice when the timed out touch stream
 // turns into a scroll gesture sequence.
 TEST_F(TouchEventQueueTest, TouchTimeoutWithFollowupGesture) {
   SetUpForTimeoutTesting(kDefaultTouchTimeoutDelayMs);
 
   // Queue a TouchStart.
   PressTouchPoint(0, 1);
   EXPECT_TRUE(IsTimeoutRunning());
   EXPECT_TRUE(WillForwardTouchEvents());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
@@ skipping 149 matching lines @@
   EXPECT_TRUE(WillForwardTouchEvents());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
 
   // Subsequent events should be handled normally.
   PressTouchPoint(0, 1);
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(0U, GetAndResetAckedEventCount());
 }
 }  // namespace content