Enable TouchEvent suppression on scroll for all platforms

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 "content/browser/renderer_host/input/mock_web_input_event_builders.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 
+using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebTouchEvent;
 using WebKit::WebTouchPoint;
 
 namespace content {
 
 class TouchEventQueueTest : public testing::Test,
                             public TouchEventQueueClient {
  public:
   TouchEventQueueTest()
@@ skipping 23 matching lines @@
       const TouchEventWithLatencyInfo& event,
       InputEventAckState ack_result) OVERRIDE {
     ++acked_event_count_;
     last_acked_event_ = event.event;
     last_acked_event_state_ = ack_result;
     if (followup_touch_event_) {
       scoped_ptr<WebTouchEvent> followup_touch_event =
           followup_touch_event_.Pass();
       SendTouchEvent(*followup_touch_event);
     }
+    if (followup_gesture_event_) {
+      scoped_ptr<WebGestureEvent> followup_gesture_event =
+          followup_gesture_event_.Pass();
+      queue_->OnGestureScrollEvent(
+          GestureEventWithLatencyInfo(*followup_gesture_event,
+                                      ui::LatencyInfo()));
+    }
   }
 
  protected:
 
   void SendTouchEvent(const WebTouchEvent& event) {
     queue_->QueueEvent(TouchEventWithLatencyInfo(event, ui::LatencyInfo()));
   }
 
   void SendTouchEvent() {
     SendTouchEvent(touch_event_);
     touch_event_.ResetPoints();
   }
 
+  void SendGestureEvent(WebInputEvent::Type type) {
+    WebGestureEvent event;
+    event.type = type;
+    queue_->OnGestureScrollEvent(
+        GestureEventWithLatencyInfo(event, ui::LatencyInfo()));
+  }
+
   void SendTouchEventACK(InputEventAckState ack_result) {
     queue_->ProcessTouchAck(ack_result, ui::LatencyInfo());
   }
 
   void SetFollowupEvent(const WebTouchEvent& event) {
     followup_touch_event_.reset(new WebTouchEvent(event));
   }
 
+  void SetFollowupEvent(const WebGestureEvent& event) {
+    followup_gesture_event_.reset(new WebGestureEvent(event));
+  }
+
   int PressTouchPoint(int x, int y) {
     return touch_event_.PressPoint(x, y);
   }
 
   void MoveTouchPoint(int index, int x, int y) {
     touch_event_.MovePoint(index, x, y);
   }
 
   void ReleaseTouchPoint(int index) {
     touch_event_.ReleasePoint(index);
@@ skipping 20 matching lines @@
   }
 
   const WebTouchEvent& latest_event() const {
     return queue_->GetLatestEvent().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:
   scoped_ptr<TouchEventQueue> queue_;
   size_t sent_event_count_;
   size_t acked_event_count_;
   WebTouchEvent last_sent_event_;
   WebTouchEvent last_acked_event_;
   InputEventAckState last_acked_event_state_;
   MockWebTouchEvent touch_event_;
   scoped_ptr<WebTouchEvent> followup_touch_event_;
+  scoped_ptr<WebGestureEvent> followup_gesture_event_;
 };
 
 
 // Tests that touch-events are queued properly.
 TEST_F(TouchEventQueueTest, Basic) {
   PressTouchPoint(1, 1);
   SendTouchEvent();
   EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
 
@@ skipping 469 matching lines @@
   stationary_event.touches[0].state = WebTouchPoint::StateStationary;
   SendTouchEvent(stationary_event);
 
   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 that no touch move events are sent to renderer during scrolling.
-TEST_F(TouchEventQueueTest, NoTouchMove) {
-  // First touch press.
+// Tests basic TouchEvent forwarding suppression.
+TEST_F(TouchEventQueueTest, NoTouchBasic) {
+  // Disable TouchEvent forwarding.
+  set_no_touch_to_renderer(true);
+  MoveTouchPoint(0, 30, 5);
+  SendTouchEvent();
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // TouchMove should not be sent to renderer.
+  MoveTouchPoint(0, 65, 10);
+  SendTouchEvent();
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // TouchEnd should not be sent to renderer.
+  ReleaseTouchPoint(0);
+  SendTouchEvent();
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // TouchStart should not be sent to renderer.
+  PressTouchPoint(5, 5);
+  SendTouchEvent();
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  // Enable TouchEvent forwarding.
+  set_no_touch_to_renderer(false);
+
+  PressTouchPoint(80, 10);
+  SendTouchEvent();
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  MoveTouchPoint(0, 80, 20);
+  SendTouchEvent();
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+
+  ReleaseTouchPoint(0);
+  SendTouchEvent();
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+}
+
+// Tests that no TouchEvents are sent to renderer during scrolling.
+TEST_F(TouchEventQueueTest, NoTouchOnScroll) {
+  // Queue a TouchStart.
   PressTouchPoint(0, 1);
   SendTouchEvent();
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
-  // Touch moves may trigger scroll.
   MoveTouchPoint(0, 20, 5);
   SendTouchEvent();
+  EXPECT_EQ(1U, queued_event_count());
   EXPECT_EQ(1U, GetAndResetSentEventCount());
+
+  // Queue another TouchStart.
+  PressTouchPoint(20, 20);
+  SendTouchEvent();
+  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
+
+  // GestureScrollBegin inserts a synthetic TouchCancel before the TouchStart.
+  WebGestureEvent followup_scroll;
+  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  SetFollowupEvent(followup_scroll);
+  ASSERT_FALSE(no_touch_to_renderer());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  EXPECT_TRUE(no_touch_to_renderer());
+  EXPECT_EQ(1U, GetAndResetSentEventCount());
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  EXPECT_EQ(2U, queued_event_count());
+  EXPECT_EQ(WebInputEvent::TouchCancel, sent_event().type);
+  EXPECT_EQ(WebInputEvent::TouchStart, latest_event().type);
 
-  // Touch move should not be sent to renderer (e.g., when scrolling starts).
-  set_no_touch_to_renderer(true);
+  // Acking the TouchCancel will result in dispatch of the next TouchStart.
+  SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  // The synthetic TouchCancel should not reach client, only the TouchStart.
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  EXPECT_EQ(0U, GetAndResetSentEventCount());
+  EXPECT_EQ(WebInputEvent::TouchStart, acked_event().type);
+
+  // TouchMove should not be sent to renderer.
   MoveTouchPoint(0, 30, 5);
   SendTouchEvent();
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 
-  // Touch move should not be sent to renderer.
-  MoveTouchPoint(0, 65, 10);
-  SendTouchEvent();
-  EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  // GestureScrollUpdates should not change affect touch forwarding.
+  SendGestureEvent(WebInputEvent::GestureScrollUpdate);
+  EXPECT_TRUE(no_touch_to_renderer());
 
-  // Touch end should not be sent to renderer.
+  // TouchEnd should not be sent to renderer.
   ReleaseTouchPoint(0);
   SendTouchEvent();
+  EXPECT_EQ(1U, GetAndResetAckedEventCount());
   EXPECT_EQ(0U, GetAndResetSentEventCount());
-  EXPECT_EQ(1U, GetAndResetAckedEventCount());
+  EXPECT_EQ(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS, acked_event_state());
 
-  // Resume sending touch moves to renderer (e.g., when scrolling ends).
-  set_no_touch_to_renderer(false);
+  // GestureScrollEnd will resume the sending of TouchEvents to renderer.
+  SendGestureEvent(WebKit::WebInputEvent::GestureScrollEnd);
+  EXPECT_FALSE(no_touch_to_renderer());
 
-  // Now touch events should come through to renderer.
+  // Now TouchEvents should be forwarded normally.
   PressTouchPoint(80, 10);
   SendTouchEvent();
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   MoveTouchPoint(0, 80, 20);
   SendTouchEvent();
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 
   ReleaseTouchPoint(0);
   SendTouchEvent();
   EXPECT_EQ(1U, GetAndResetSentEventCount());
   SendTouchEventACK(INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
   EXPECT_EQ(1U, GetAndResetAckedEventCount());
 }
 
 }  // namespace content