[Compositor event queue] Queue GestureFlingStart/Cancel together with scroll/pinch

ui/events/blink/input_handler_proxy_unittest.cc

Index: ui/events/blink/input_handler_proxy_unittest.cc
diff --git a/ui/events/blink/input_handler_proxy_unittest.cc b/ui/events/blink/input_handler_proxy_unittest.cc
index 6c866856e9e6032b29eb52d1f7432677b7c6616c..b3b3fed85677a12db1c8d947360412a20ac49413 100644
--- a/ui/events/blink/input_handler_proxy_unittest.cc
+++ b/ui/events/blink/input_handler_proxy_unittest.cc
@@ -126,15 +126,17 @@ WebGestureEvent CreateFling(WebGestureDevice source_device,
                      modifiers);
 }
 
-WebScopedInputEvent CreateGestureScrollOrPinch(WebInputEvent::Type type,
-                                               float deltaYOrScale = 0,
-                                               int x = 0,
-                                               int y = 0) {
+WebScopedInputEvent CreateGestureScrollFlingPinch(WebInputEvent::Type type,
+                                                  float deltaYOrScale = 0,
+                                                  int x = 0,
+                                                  int y = 0) {
   WebGestureEvent gesture(type, WebInputEvent::NoModifiers,
                           WebInputEvent::TimeStampForTesting);
   gesture.sourceDevice = blink::WebGestureDeviceTouchpad;
   if (type == WebInputEvent::GestureScrollUpdate) {
     gesture.data.scrollUpdate.deltaY = deltaYOrScale;
+  } else if (type == WebInputEvent::GestureFlingStart) {

[tdresser, 2017/03/10 15:31:06]

Should we have a test involving a fling cancel?

[chongz, 2017/03/14 14:51:06]

I've improved the test to cover FlingCancel better.

But actually this "if" condition is only for setting extra parameters and won't
prevent creating FlingCancel events.

+    gesture.data.flingStart.velocityY = deltaYOrScale;
   } else if (type == WebInputEvent::GesturePinchUpdate) {
     gesture.data.pinchUpdate.scale = deltaYOrScale;
     gesture.x = x;
@@ -541,7 +543,7 @@ class InputHandlerProxyEventQueueTest : public testing::Test {
                           int y = 0) {
     LatencyInfo latency;
     input_handler_proxy_->HandleInputEventWithLatencyInfo(
-        CreateGestureScrollOrPinch(type, deltay_or_scale, x, y), latency,
+        CreateGestureScrollFlingPinch(type, deltay_or_scale, x, y), latency,
         base::Bind(
             &InputHandlerProxyEventQueueTest::DidHandleInputEventAndOverscroll,
             weak_ptr_factory_.GetWeakPtr()));
@@ -3532,6 +3534,44 @@ TEST_F(InputHandlerProxyEventQueueTest, OriginalEventsTracing) {
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 }
 
+TEST_F(InputHandlerProxyEventQueueTest, GestureScrollFlingOrder) {
+  // Handle scroll on compositor.
+  cc::InputHandlerScrollResult scroll_result_did_scroll_;
+  scroll_result_did_scroll_.did_scroll = true;
+
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillRepeatedly(testing::Return(kImplThreadScrollState));
+  EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput())
+      .Times(::testing::AtLeast(1));
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
+      .WillRepeatedly(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_))
+      .Times(::testing::AtLeast(1));
+
+  // Simulate scroll.
+  HandleGestureEvent(WebInputEvent::GestureScrollBegin);
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -20);
+  HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -30);
+  HandleGestureEvent(WebInputEvent::GestureFlingStart, -10);
+  HandleGestureEvent(WebInputEvent::GestureFlingCancel);
+
+  // ScrollUpdate and Fling should be queued.
+  EXPECT_EQ(3ul, event_queue().size());
+  EXPECT_EQ(1ul, event_disposition_recorder_.size());
+  EXPECT_EQ(WebInputEvent::GestureScrollUpdate,
+            event_queue()[0]->event().type());
+  EXPECT_EQ(WebInputEvent::GestureFlingStart, event_queue()[1]->event().type());
+  EXPECT_EQ(WebInputEvent::GestureFlingCancel,
+            event_queue()[2]->event().type());
+
+  // Dispatch all events.
+  input_handler_proxy_->DeliverInputForBeginFrame();
+  EXPECT_EQ(0ul, event_queue().size());
+  EXPECT_EQ(5ul, event_disposition_recorder_.size());
+}
+
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));