Handle touchpad flings with passive event listeners on compositor thread.

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/macros.h"
 #include "base/test/histogram_tester.h"
@@ skipping 192 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(FakeWebGestureCurve);
 };
 
 class MockInputHandlerProxyClient
     : public InputHandlerProxyClient {
  public:
   MockInputHandlerProxyClient() {}
   ~MockInputHandlerProxyClient() override {}
 
-  void WillShutdown() override {}
+  MOCK_METHOD0(WillShutdown, void());
 
   MOCK_METHOD1(TransferActiveWheelFlingAnimation,
                void(const WebActiveWheelFlingParameters&));
 
+  MOCK_METHOD2(DispatchNonBlockingEventToMainThread_,
+               void(const WebInputEvent& event,
+                    const ui::LatencyInfo& latency_info));
+
+  void DispatchNonBlockingEventToMainThread(
+      ui::ScopedWebInputEvent event,
+      const ui::LatencyInfo& latency_info) {
+    CHECK(event.get());
+    DispatchNonBlockingEventToMainThread_(*event.get(), latency_info);
+  }
+
   blink::WebGestureCurve* CreateFlingAnimationCurve(
       WebGestureDevice deviceSource,
       const WebFloatPoint& velocity,
-      const WebSize& cumulative_scroll) override {
+      const WebSize& cumulative_scroll) {
     return new FakeWebGestureCurve(
         blink::WebFloatSize(velocity.x, velocity.y),
         blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height));
   }
 
   MOCK_METHOD4(DidOverscroll,
                void(const gfx::Vector2dF& accumulated_overscroll,
                     const gfx::Vector2dF& latest_overscroll_delta,
                     const gfx::Vector2dF& current_fling_velocity,
                     const gfx::PointF& causal_event_viewport_point));
-  void DidStartFlinging() override {}
-  void DidStopFlinging() override {}
-  void DidAnimateForInput() override {}
+  void DidStartFlinging() override{};

[Rick Byers, 2016/09/16 14:00:54]

nit: why the semicolons?  Definitions don't normally have semicolons, right
(only declarations)?

[dtapuska, 2016/09/19 19:37:39]

Err; I initially tried to mock this entire class; done.

+  void DidStopFlinging() override{};
+  void DidAnimateForInput() override{};
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockInputHandlerProxyClient);
 };
 
 class MockInputHandlerProxyClientWithDidAnimateForInput
     : public MockInputHandlerProxyClient {
  public:
   MockInputHandlerProxyClientWithDidAnimateForInput() {}
   ~MockInputHandlerProxyClientWithDidAnimateForInput() override {}
@@ skipping 749 matching lines @@
   // lead to the scroll (either wheel or gesture scroll), so there should be no
   // visible hitch.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .Times(0);
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
-  // The second call should punt the fling to the main thread
-  // because of a passive event listener.
-  EXPECT_SET_NEEDS_ANIMATE_INPUT(0);
+  // The second call should punt activate the fling and call the method
+  // dispatching the events for the passive event listeners.
+  EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kPassive));
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .Times(0);
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
-  // Expected wheel fling animation parameters:
-  // *) fling_delta and fling_point should match the original GestureFlingStart
-  // event
-  // *) startTime should be 10 to match the time parameter of the first
-  // Animate() call after the GestureFlingStart
+      .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(
-      mock_client_,
-      TransferActiveWheelFlingAnimation(testing::AllOf(
-          testing::Field(&WebActiveWheelFlingParameters::delta,
-                         testing::Eq(fling_delta)),
-          testing::Field(&WebActiveWheelFlingParameters::point,
-                         testing::Eq(fling_point)),
-          testing::Field(&WebActiveWheelFlingParameters::globalPoint,
-                         testing::Eq(fling_global_point)),
-          testing::Field(&WebActiveWheelFlingParameters::modifiers,
-                         testing::Eq(modifiers)),
-          testing::Field(&WebActiveWheelFlingParameters::startTime,
-                         testing::Eq(10)),
-          testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll,
-                         testing::_))));
+      mock_input_handler_,
+      ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_client_,
+              DispatchNonBlockingEventToMainThread_(testing::_, testing::_))

[Rick Byers, 2016/09/16 14:00:54]

nit: Don't you want to still test the parameters of the wheel event, since they
were generated synthetically from the fling?

[dtapuska, 2016/09/19 19:37:39]

Done.

+      .Times(1);
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(1);
+
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
-  // Since we've aborted the fling, the next animation should be a no-op and
-  // should not result in another
-  // frame being requested.
-  EXPECT_SET_NEEDS_ANIMATE_INPUT(0);
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .Times(0);
-  time += base::TimeDelta::FromMilliseconds(100);
-  Animate(time);
-
-  // Since we've transferred the fling to the main thread, we need to pass the
-  // next GestureFlingCancel to the main
-  // thread as well.
-  expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
+  // Ensure we can cancel the gesture.
+  expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingTransferResetsTouchpad) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
@@ skipping 1741 matching lines @@
       testing::ElementsAre(base::Bucket(1, 1), base::Bucket(3, 1),
                            base::Bucket(5, 1), base::Bucket(14, 1)));
 }
 
 
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
 }  // namespace test
 }  // namespace ui