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

ui/events/blink/input_handler_proxy_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 "ui/events/blink/input_handler_proxy.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 108 matching lines @@
                             WebPoint global_point,
                             int modifiers) {
   return CreateFling(base::TimeTicks(),
                      source_device,
                      velocity,
                      point,
                      global_point,
                      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;
     gesture.y = y;
   }
   return WebInputEventTraits::Clone(gesture);
 }
 
 void OnTraceDataCollected(base::Closure quit_closure,
                           base::trace_event::TraceResultBuffer* buffer,
@@ skipping 386 matching lines @@
     return base::WrapUnique(
         trace_analyzer::TraceAnalyzer::Create(trace_output.json_output));
   }
 
   void HandleGestureEvent(WebInputEvent::Type type,
                           float deltay_or_scale = 0,
                           int x = 0,
                           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()));
   }
 
   void DidHandleInputEventAndOverscroll(
       InputHandlerProxy::EventDisposition event_disposition,
       WebScopedInputEvent input_event,
       const ui::LatencyInfo& latency_info,
       std::unique_ptr<ui::DidOverscrollParams> overscroll_params) {
@@ skipping 2970 matching lines @@
   // The ScrollUpdate of the pair doesn't carry original events and won't be
   // traced.
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate,
             end_events[3]->GetKnownArgAsInt("type"));
   EXPECT_EQ(4, end_events[3]->GetKnownArgAsInt("coalesced_count"));
   EXPECT_EQ(WebInputEvent::GestureScrollEnd,
             end_events[4]->GetKnownArgAsInt("type"));
   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));
 
 }  // namespace test
 }  // namespace ui