Send touch cancel to renderer when scrolling starts

content/browser/renderer_host/input/immediate_input_router_unittest.cc

Index: content/browser/renderer_host/input/immediate_input_router_unittest.cc
diff --git a/content/browser/renderer_host/input/immediate_input_router_unittest.cc b/content/browser/renderer_host/input/immediate_input_router_unittest.cc
index b464bc06e279f55505aeb2426329f4f00730daec..80fec4167b90f329295b86fdfbd3a15b40443282 100644
--- a/content/browser/renderer_host/input/immediate_input_router_unittest.cc
+++ b/content/browser/renderer_host/input/immediate_input_router_unittest.cc
@@ -149,8 +149,8 @@ class ImmediateInputRouterTest : public InputRouterTest {
     input_router()->enable_no_touch_to_renderer_while_scrolling_ = true;
   }
 
-  bool no_touch_move_to_renderer() {
-    return touch_event_queue()->no_touch_move_to_renderer_;
+  bool no_touch_to_renderer() {
+    return touch_event_queue()->no_touch_to_renderer_;
   }
 
   TouchEventQueue* touch_event_queue() const {
@@ -1851,8 +1851,8 @@ TEST_F(ImmediateInputRouterTest, UnhandledWheelEvent) {
   EXPECT_EQ(ack_handler_->acked_wheel_event().deltaY, -5);
 }
 
-// Tests that no touch move events are sent to renderer during scrolling.
-TEST_F(ImmediateInputRouterTest, NoTouchMoveWhileScroll) {
+// Tests that no touch events are sent to renderer during scrolling.
+TEST_F(ImmediateInputRouterTest, NoTouchWhileScroll) {
   EnableNoTouchToRendererWhileScrolling();
   set_debounce_interval_time_ms(0);
   input_router_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
@@ -1865,22 +1865,51 @@ TEST_F(ImmediateInputRouterTest, NoTouchMoveWhileScroll) {
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::TouchStart,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  ack_handler_->ExpectAckCalled(1);
 
   // Touch move will trigger scroll.
   MoveTouchPoint(0, 20, 5);
   SendTouchEvent();
   EXPECT_EQ(1U, process_->sink().message_count());
   process_->sink().ClearMessages();
+
+  WebGestureEvent followup_scroll;
+  followup_scroll.type = WebInputEvent::GestureScrollBegin;
+  ack_handler_->set_followup_touch_event(make_scoped_ptr(
+      new GestureEventWithLatencyInfo(followup_scroll, ui::LatencyInfo())));
+

[jdduke (slow), 2013/10/01 16:27:42]

Would it be worthwhile to add another (non-coalesced) TouchMove event to the
queue before we send the ScrollBegin? That way, we also handle the case where
there are events in the queue when the cancel is sent, which should be
dispatched on the cancel ack.

[Yufeng Shen (Slow to review), 2013/10/01 20:38:50]

Done. Send another TouchStart to the queue (so it won't get coalesced with the
TouchMove). And check that after the TouchCancel is acked, the TouchStart is
dispatched to client.

   SendInputEventACK(WebInputEvent::TouchMove,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
-
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_TRUE(no_touch_move_to_renderer());
+  ack_handler_->ExpectAckCalled(1);
+  // GestureScroll inserts touch cancel into the queue.
+  EXPECT_EQ(1U, TouchEventQueueSize());
+  EXPECT_EQ(latest_event().type, WebInputEvent::TouchCancel);

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

EXPECT_EQ(<expected value>, <actual value>), so this should be:
  EXPECT_EQ(TouchCancel, latest_event().type);
(otherwise, the error message when this fails becomes a bit confusing). The same
applies in the following lines too.

[Yufeng Shen (Slow to review), 2013/10/01 20:38:50]

Done.

+  EXPECT_EQ(2U, process_->sink().message_count());
+  // ScrollBegin is sent first, then the TouchCancel.
+  const WebInputEvent* input_event =
+      GetInputEventFromMessage(*process_->sink().GetMessageAt(0));
+  EXPECT_EQ(input_event->type, WebInputEvent::GestureScrollBegin);
+  input_event = GetInputEventFromMessage(*process_->sink().GetMessageAt(1));
+  EXPECT_EQ(input_event->type, WebInputEvent::TouchCancel);
+  EXPECT_TRUE(no_touch_to_renderer());
   process_->sink().ClearMessages();
+
+  // Clear the followup events since now the touch events are directly
+  // sent to client, instead of being sent to renderer and waiting for
+  // ack. So we should use SimulateGestureScrollUpdateEvent() instead of
+  // followup gesture events.
+  ack_handler_->set_followup_touch_event(make_scoped_ptr(
+      static_cast<GestureEventWithLatencyInfo*>(NULL)));
+  SendInputEventACK(WebInputEvent::TouchCancel,
+                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  // The touch cancel does not reach client.
+  ack_handler_->ExpectAckCalled(0);
   SendInputEventACK(WebInputEvent::GestureScrollBegin,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
+  ack_handler_->ExpectAckCalled(1);
+  EXPECT_EQ(0U, TouchEventQueueSize());
+  EXPECT_EQ(0U, process_->sink().message_count());
+  process_->sink().ClearMessages();
 
   // Touch move should not be sent to renderer.
   MoveTouchPoint(0, 30, 5);
@@ -1890,30 +1919,21 @@ TEST_F(ImmediateInputRouterTest, NoTouchMoveWhileScroll) {
 
   // Touch moves become ScrollUpdate.
   SimulateGestureScrollUpdateEvent(20, 4, 0);
-  EXPECT_TRUE(no_touch_move_to_renderer());
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::GestureScrollUpdate,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
-  // Touch move should not be sent to renderer.
-  MoveTouchPoint(0, 65, 10);
-  SendTouchEvent();
-  EXPECT_EQ(0U, process_->sink().message_count());
-  process_->sink().ClearMessages();
-
-  // Touch end should still be sent to renderer.
+  // Touch end should not be sent to renderer.
   ReleaseTouchPoint(0);
   SendTouchEvent();
-  EXPECT_EQ(1U, process_->sink().message_count());
+  EXPECT_EQ(0U, process_->sink().message_count());
   process_->sink().ClearMessages();
-  SendInputEventACK(WebInputEvent::TouchEnd,
-                    INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   // On GestureScrollEnd, resume sending touch moves to renderer.
   SimulateGestureEvent(WebKit::WebInputEvent::GestureScrollEnd,
                        WebGestureEvent::Touchscreen);
   EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_FALSE(no_touch_move_to_renderer());
+  EXPECT_FALSE(no_touch_to_renderer());
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::GestureScrollEnd,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);