Send touch cancel to renderer when scrolling starts

content/browser/renderer_host/input/immediate_input_router_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/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
 #include "content/browser/renderer_host/input/immediate_input_router.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
@@ skipping 131 matching lines @@
   }
 
   const WebTouchEvent& latest_event() const {
     return touch_event_queue()->GetLatestEvent().event;
   }
 
   void EnableNoTouchToRendererWhileScrolling() {
     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 {
     return input_router()->touch_event_queue();
   }
 
   unsigned GestureEventLastQueueEventSize() {
     return gesture_event_filter()->coalesced_gesture_events_.size();
   }
 
@@ skipping 1680 matching lines @@
   // Check that the second event was sent.
   EXPECT_EQ(1U, process_->sink().message_count());
   EXPECT_TRUE(process_->sink().GetUniqueMessageMatching(
                   InputMsg_HandleInputEvent::ID));
   process_->sink().ClearMessages();
 
   // Check that the correct unhandled wheel event was received.
   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));
   process_->sink().ClearMessages();
 
   // First touch press.
   PressTouchPoint(0, 1);
   SendTouchEvent();
   EXPECT_EQ(1U, process_->sink().message_count());
   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);
+  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();
 
-  SimulateGestureEvent(WebInputEvent::GestureScrollBegin,
-                       WebGestureEvent::Touchscreen);
-  EXPECT_EQ(1U, process_->sink().message_count());
-  EXPECT_TRUE(no_touch_move_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);
   SendTouchEvent();
   EXPECT_EQ(0U, process_->sink().message_count());
   process_->sink().ClearMessages();
 
   // 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);
+  // Touch end should not be sent to renderer.
+  ReleaseTouchPoint(0);
   SendTouchEvent();
   EXPECT_EQ(0U, process_->sink().message_count());
   process_->sink().ClearMessages();
 
-  // Touch end should still be sent to renderer.
-  ReleaseTouchPoint(0);
-  SendTouchEvent();
-  EXPECT_EQ(1U, 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);
 
   // Now touch events should come through to renderer.
   PressTouchPoint(80, 10);
   SendTouchEvent();
   EXPECT_EQ(1U, process_->sink().message_count());
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::TouchStart,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   MoveTouchPoint(0, 80, 20);
   SendTouchEvent();
   EXPECT_EQ(1U, process_->sink().message_count());
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::TouchMove,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 
   ReleaseTouchPoint(0);
   SendTouchEvent();
   EXPECT_EQ(1U, process_->sink().message_count());
   process_->sink().ClearMessages();
   SendInputEventACK(WebInputEvent::TouchEnd,
                     INPUT_EVENT_ACK_STATE_NOT_CONSUMED);
 }
 }  // namespace content