Event unittests cover both wheel scroll latching and propagating cases.

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 163 matching lines @@
                             cc::InputHandler::ScrollInputType type));
   MOCK_METHOD1(ScrollAnimatedBegin,
                ScrollStatus(const gfx::Point& viewport_point));
   MOCK_METHOD3(ScrollAnimated,
                ScrollStatus(const gfx::Point& viewport_point,
                             const gfx::Vector2dF& scroll_delta,
                             base::TimeDelta));
   MOCK_METHOD1(ScrollBy, cc::InputHandlerScrollResult(cc::ScrollState*));
   MOCK_METHOD1(ScrollEnd, void(cc::ScrollState*));
   MOCK_METHOD0(FlingScrollBegin, cc::InputHandler::ScrollStatus());
+  MOCK_METHOD0(ScrollingShouldSwitchtoMainThread, bool());
 
   std::unique_ptr<cc::SwapPromiseMonitor> CreateLatencyInfoSwapPromiseMonitor(
       ui::LatencyInfo* latency) override {
     return nullptr;
   }
 
   cc::ScrollElasticityHelper* CreateScrollElasticityHelper() override {
     return NULL;
   }
   bool GetScrollOffsetForLayer(int layer_id,
                                gfx::ScrollOffset* offset) override {
     return false;
   }
   bool ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) override {
     return false;
   }
 
-  bool ScrollingShouldSwitchtoMainThread() override { return false; }
-
   void BindToClient(cc::InputHandlerClient* client,
                     bool touchpad_and_wheel_scroll_latching_enabled) override {}
 
   void MouseDown() override {}
   void MouseUp() override {}
   void MouseLeave() override {}
 
   void MouseMoveAt(const gfx::Point& mouse_position) override {}
 
   MOCK_CONST_METHOD2(IsCurrentlyScrollingLayerAt,
@@ skipping 151 matching lines @@
     RecordMainThreadScrollingReasons(device, reasons);
   }
 };
 
 }  // namespace
 
 class InputHandlerProxyTest
     : public testing::Test,
       public testing::WithParamInterface<InputHandlerProxyTestType> {
  public:
-  InputHandlerProxyTest()
+  InputHandlerProxyTest(bool touchpad_and_wheel_scroll_latching_enabled = true)
       : synchronous_root_scroll_(GetParam() == ROOT_SCROLL_SYNCHRONOUS_HANDLER),
         install_synchronous_handler_(
             GetParam() == ROOT_SCROLL_SYNCHRONOUS_HANDLER ||
             GetParam() == CHILD_SCROLL_SYNCHRONOUS_HANDLER),
-        expected_disposition_(InputHandlerProxy::DID_HANDLE) {
+        expected_disposition_(InputHandlerProxy::DID_HANDLE),
+        touchpad_and_wheel_scroll_latching_enabled_(
+            touchpad_and_wheel_scroll_latching_enabled) {
     input_handler_.reset(
-        new TestInputHandlerProxy(&mock_input_handler_, &mock_client_, false));
+        new TestInputHandlerProxy(&mock_input_handler_, &mock_client_,
+                                  touchpad_and_wheel_scroll_latching_enabled_));
     scroll_result_did_scroll_.did_scroll = true;
     scroll_result_did_not_scroll_.did_scroll = false;
 
     if (install_synchronous_handler_) {
       EXPECT_CALL(mock_input_handler_,
                   RequestUpdateForSynchronousInputHandler())
           .Times(1);
       input_handler_->SetOnlySynchronouslyAnimateRootFlings(
           &mock_synchronous_input_handler_);
     }
 
     mock_input_handler_.set_is_scrolling_root(synchronous_root_scroll_);
 
     // Set a default device so tests don't always have to set this.
     gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   }
 
-  ~InputHandlerProxyTest() {
-    input_handler_.reset();
-  }
+  virtual ~InputHandlerProxyTest() { input_handler_.reset(); }
 
 // This is defined as a macro so the line numbers can be traced back to the
 // correct spot when it fails.
 #define EXPECT_SET_NEEDS_ANIMATE_INPUT(times)                                \
   do {                                                                       \
     if (synchronous_root_scroll_) {                                          \
       EXPECT_CALL(mock_synchronous_input_handler_,                           \
                   SetNeedsSynchronousAnimateInput())                         \
           .Times(times);                                                     \
       EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(0);     \
@@ skipping 62 matching lines @@
 
   void SetSmoothScrollEnabled(bool value) {
     input_handler_->smooth_scroll_enabled_ = value;
   }
 
   base::HistogramTester& histogram_tester() {
     return histogram_tester_;
   }
 
  protected:
+  void GestureFlingAnimatesTouchpad();
+  void DidReceiveInputEvent_ForFling();
+  void GestureScrollStarted();
+  void GestureFlingPassiveListener();
+  void GestureFlingStartedTouchpad();
+  void GestureFlingStopsAtContentEdge();
+  void GestureFlingTransferResetsTouchpad();
+
   const bool synchronous_root_scroll_;
   const bool install_synchronous_handler_;
   testing::StrictMock<MockInputHandler> mock_input_handler_;
   testing::StrictMock<MockSynchronousInputHandler>
       mock_synchronous_input_handler_;
   std::unique_ptr<TestInputHandlerProxy> input_handler_;
   testing::StrictMock<MockInputHandlerProxyClient> mock_client_;
   WebGestureEvent gesture_;
   InputHandlerProxy::EventDisposition expected_disposition_;
   base::HistogramTester histogram_tester_;
   cc::InputHandlerScrollResult scroll_result_did_scroll_;
   cc::InputHandlerScrollResult scroll_result_did_not_scroll_;
+  bool touchpad_and_wheel_scroll_latching_enabled_;
 };
 
-class InputHandlerProxyEventQueueTest : public testing::Test {
+class InputHandlerProxyWithoutWheelScrollLatchingTest
+    : public InputHandlerProxyTest {
+ public:
+  InputHandlerProxyWithoutWheelScrollLatchingTest()
+      : InputHandlerProxyTest(false) {}
+};
+
+class InputHandlerProxyEventQueueTest : public testing::TestWithParam<bool> {
  public:
   InputHandlerProxyEventQueueTest() : weak_ptr_factory_(this) {
     feature_list_.InitAndEnableFeature(features::kVsyncAlignedInputEvents);
   }
 
   ~InputHandlerProxyEventQueueTest() { input_handler_proxy_.reset(); }
 
   void SetUp() override {
+    bool wheel_scroll_latching_enabled = GetParam();
     event_disposition_recorder_.clear();
     input_handler_proxy_ = base::MakeUnique<TestInputHandlerProxy>(
-        &mock_input_handler_, &mock_client_, false);
+        &mock_input_handler_, &mock_client_, wheel_scroll_latching_enabled);
     if (input_handler_proxy_->compositor_event_queue_)
       input_handler_proxy_->compositor_event_queue_ =
           base::MakeUnique<CompositorThreadEventQueue>();
   }
 
   void StartTracing() {
     base::trace_event::TraceLog::GetInstance()->SetEnabled(
         base::trace_event::TraceConfig("*"),
         base::trace_event::TraceLog::RECORDING_MODE);
   }
@@ skipping 87 matching lines @@
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kBlocking));
 
   WebMouseWheelEvent wheel(WebInputEvent::MouseWheel, WebInputEvent::ControlKey,
                            WebInputEvent::TimeStampForTesting);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(wheel));
   VERIFY_AND_RESET_MOCKS();
 }
 
-TEST_P(InputHandlerProxyTest, GestureScrollStarted) {
+void InputHandlerProxyTest::GestureScrollStarted() {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
   gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_,input_handler_->HandleInputEvent(gesture_));
 
   // The event should not be marked as handled if scrolling is not possible.
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+      .WillOnce(testing::Return(false));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // Mark the event as handled if scroll happens.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.setType(WebInputEvent::GestureScrollUpdate);
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.setType(WebInputEvent::GestureScrollEnd);
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
+TEST_P(InputHandlerProxyTest, GestureScrollStarted) {
+  GestureScrollStarted();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest, GestureScrollStarted) {
+  GestureScrollStarted();
+}
 
 TEST_P(InputHandlerProxyTest, GestureScrollOnMainThread) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
       .WillOnce(testing::Return(kMainThreadScrollState));
 
   gesture_.setType(WebInputEvent::GestureScrollBegin);
@@ skipping 264 matching lines @@
 
   gesture_.setType(WebInputEvent::GestureScrollEnd);
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_))
       .WillOnce(testing::Return());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
-TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchpad) {
+void InputHandlerProxyTest::GestureFlingStartedTouchpad() {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+
+  // HandleGestureScrollBegin will set gesture_scroll_on_impl_thread_.
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
+
+  VERIFY_AND_RESET_MOCKS();
+
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
 
   gesture_.setType(WebInputEvent::GestureFlingStart);
   gesture_.data.flingStart.velocityX = 10;
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
+  if (touchpad_and_wheel_scroll_latching_enabled_) {
+    // The fling cancellation shouldn't get deferred because velocityX is less
+    // than minimum.
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(1);
+  }
   // Verify that a GestureFlingCancel during an animation cancels it.
   gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+
+  VERIFY_AND_RESET_MOCKS();
+}
+TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchpad) {
+  GestureFlingStartedTouchpad();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest,
+       GestureFlingStartedTouchpad) {
+  GestureFlingStartedTouchpad();
 }
 
 TEST_P(InputHandlerProxyTest, GestureFlingTouchpadScrollLatchingEnabled) {
   // Reset the input_handler_ with wheel scroll latching enabled.
   input_handler_.reset(
       new TestInputHandlerProxy(&mock_input_handler_, &mock_client_, true));
   if (install_synchronous_handler_) {
     EXPECT_CALL(mock_input_handler_, RequestUpdateForSynchronousInputHandler())
         .Times(1);
     input_handler_->SetOnlySynchronouslyAnimateRootFlings(
@@ skipping 72 matching lines @@
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
 
   // When scroll latching is enabled, ScrollBegin shouldn't get called for
   // every tick.
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .Times(0);
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+      .WillOnce(testing::Return(false));
 
   // When scroll latching is enabled, ScrollEnd gets called when the last
   // ScrollBy did not scroll.
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Fling has ended, the last Animate won't cause any more wheel ticks.
@@ skipping 43 matching lines @@
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   // Since the previous fling was ignored, we should also be dropping the next
   // fling_cancel.
   gesture_.setType(WebInputEvent::GestureFlingCancel);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
-TEST_P(InputHandlerProxyTest, GestureFlingAnimatesTouchpad) {
+void InputHandlerProxyTest::GestureFlingAnimatesTouchpad() {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+
+  // HandleGestureScrollBegin will set gesture_scroll_on_impl_thread_.
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
+
+  VERIFY_AND_RESET_MOCKS();
+
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
   gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // The first animate call should let us pick up an animation start time, but
   // we shouldn't actually move anywhere just yet. The first frame after the
   // fling start will typically include the last scroll from the gesture that
   // 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 start scrolling in the -X direction.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Let's say on the third call we hit a non-scrollable region. We should abort
   // the fling and not scroll.
   // We also should pass the current fling parameters out to the client so the
   // rest of the fling can be
   // transferred to the main thread.
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kMainThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kMainThreadScrollState));
+    EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  } else {
+    EXPECT_CALL(
+        mock_input_handler_,
+        ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
+        .WillOnce(testing::Return(scroll_result_did_not_scroll_));
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+    EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+        .WillOnce(testing::Return(true));
+  }
   // 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
   // *) cumulativeScroll depends on the curve, but since we've animated in the
   // -X direction the X value should be < 0
   EXPECT_CALL(
       mock_client_,
       TransferActiveWheelFlingAnimation(testing::AllOf(
@@ skipping 25 matching lines @@
 
   // 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;
   gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
+TEST_P(InputHandlerProxyTest, GestureFlingAnimatesTouchpad) {
+  GestureFlingAnimatesTouchpad();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest,
+       GestureFlingAnimatesTouchpad) {
+  GestureFlingAnimatesTouchpad();
+}
 
-TEST_P(InputHandlerProxyTest, GestureFlingPassiveListener) {
+void InputHandlerProxyTest::GestureFlingPassiveListener() {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+
+  // HandleGestureScrollBegin will set gesture_scroll_on_impl_thread_.
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
+
+  VERIFY_AND_RESET_MOCKS();
+
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
   gesture_ = CreateFling(blink::WebGestureDeviceTouchpad, fling_delta,
                          fling_point, fling_global_point, modifiers);
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // The first animate call should let us pick up an animation start time, but
   // we shouldn't actually move anywhere just yet. The first frame after the
   // fling start will typically include the last scroll from the gesture that
   // 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 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::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   WebMouseWheelEvent expected_wheel(WebInputEvent::MouseWheel, modifiers,
                                     WebInputEvent::TimeStampForTesting);
   expected_wheel.setPositionInWidget(fling_point.x, fling_point.y);
   expected_wheel.setPositionInScreen(fling_global_point.x,
                                      fling_global_point.y);
   expected_wheel.deltaX = fling_delta.x / 10;
   expected_wheel.hasPreciseScrollingDeltas = true;
 
   EXPECT_CALL(mock_client_, DispatchNonBlockingEventToMainThread_(
                                 WheelEventsMatch(expected_wheel)))
       .Times(1);
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(1);
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(1);
 
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Ensure we can cancel the gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  if (touchpad_and_wheel_scroll_latching_enabled_) {
+    // The fling cancellation should be deferred.
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  }
 
   VERIFY_AND_RESET_MOCKS();
 }
+TEST_P(InputHandlerProxyTest, GestureFlingPassiveListener) {
+  GestureFlingPassiveListener();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest,
+       GestureFlingPassiveListener) {
+  GestureFlingPassiveListener();
+}
 
-TEST_P(InputHandlerProxyTest, GestureFlingTransferResetsTouchpad) {
+void InputHandlerProxyTest::GestureFlingTransferResetsTouchpad() {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+
+  // HandleGestureScrollBegin will set gesture_scroll_on_impl_thread_.
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
+
+  VERIFY_AND_RESET_MOCKS();
+
   // Start a gesture fling in the -X direction with zero Y movement.
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
   gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   // Start the fling animation at time 10. This shouldn't actually scroll, just
   // establish a start time.
   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 start scrolling in the -X direction.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Let's say on the third call we hit a non-scrollable region. We should abort
   // the fling and not scroll.
   // We also should pass the current fling parameters out to the client so the
   // rest of the fling can be
   // transferred to the main thread.
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kMainThreadScrollState));
-
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kMainThreadScrollState));
+    EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  } else {
+    EXPECT_CALL(
+        mock_input_handler_,
+        ScrollBy(testing::Property(&cc::ScrollState::delta_x, testing::Lt(0))))
+        .WillOnce(testing::Return(scroll_result_did_not_scroll_));
+    EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+        .WillOnce(testing::Return(true));
+  }
 
   // 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
   // *) cumulativeScroll depends on the curve, but since we've animated in the
   // -X direction the X value should be < 0
   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::Field(&WebSize::width, testing::Gt(0))))));
+  if (touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+
   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);
 
   VERIFY_AND_RESET_MOCKS();
 
   // 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;
   gesture_.setType(WebInputEvent::GestureFlingCancel);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
   input_handler_->MainThreadHasStoppedFlinging();
 
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+
+  // HandleGestureScrollBegin will set gesture_scroll_on_impl_thread_.
+  expected_disposition_ = InputHandlerProxy::DID_HANDLE;
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
+
+  VERIFY_AND_RESET_MOCKS();
+
   // Start a second gesture fling, this time in the +Y direction with no X.
   fling_delta = WebFloatPoint(0, -1000);
   fling_point = WebPoint(95, 87);
   fling_global_point = WebPoint(32, 71);
   modifiers = WebInputEvent::AltKey;
   gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Start the second fling animation at time 30.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .Times(0);
   time = base::TimeTicks() + base::TimeDelta::FromSeconds(30);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Tick the second fling once normally.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Then abort the second fling.
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kMainThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kMainThreadScrollState));
+    EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  } else {
+    EXPECT_CALL(
+        mock_input_handler_,
+        ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Gt(0))))
+        .WillOnce(testing::Return(scroll_result_did_not_scroll_));
+    EXPECT_CALL(mock_input_handler_, ScrollingShouldSwitchtoMainThread())
+        .WillOnce(testing::Return(true));
+  }
 
   // We should get parameters from the second fling, nothing from the first
   // fling should "leak".
   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(30)),
           testing::Field(&WebActiveWheelFlingParameters::cumulativeScroll,
                          testing::Field(&WebSize::height, testing::Lt(0))))));
+
+  if (touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
+TEST_P(InputHandlerProxyTest, GestureFlingTransferResetsTouchpad) {
+  GestureFlingTransferResetsTouchpad();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest,
+       GestureFlingTransferResetsTouchpad) {
+  GestureFlingTransferResetsTouchpad();
+}
 
 TEST_P(InputHandlerProxyTest, GestureFlingStartedTouchscreen) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   gesture_.setType(WebInputEvent::GestureScrollBegin);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
@@ skipping 387 matching lines @@
 
   gesture_.setType(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // After sending a GestureScrollBegin, the member variable
   // |gesture_scroll_on_impl_thread_| should be true.
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   VERIFY_AND_RESET_MOCKS();
 }
 
-TEST_P(InputHandlerProxyTest, GestureFlingStopsAtContentEdge) {
+void InputHandlerProxyTest::GestureFlingStopsAtContentEdge() {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(::testing::_, ::testing::_))
+      .WillOnce(testing::Return(kImplThreadScrollState));
+
+  // HandleGestureScrollBegin will set gesture_scroll_on_impl_thread_.
+  gesture_.setType(WebInputEvent::GestureScrollBegin);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+  EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
+
+  VERIFY_AND_RESET_MOCKS();
+
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   // The first animate doesn't cause any scrolling.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The second animate starts scrolling in the positive X and Y directions.
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Lt(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The third animate overscrolls in the positive Y direction but scrolls
   // somewhat.
   cc::InputHandlerScrollResult overscroll;
   overscroll.did_scroll = true;
   overscroll.did_overscroll_root = true;
   overscroll.accumulated_root_overscroll = gfx::Vector2dF(0, 100);
   overscroll.unused_scroll_delta = gfx::Vector2dF(0, 10);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Lt(0))))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
       DidOverscroll(
           overscroll.accumulated_root_overscroll,
           overscroll.unused_scroll_delta,
           testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
           testing::_));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_,
               GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
       .WillOnce(testing::Return(cc::EventListenerProperties::kNone));
-  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
-      .WillOnce(testing::Return(kImplThreadScrollState));
+  if (!touchpad_and_wheel_scroll_latching_enabled_) {
+    EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+        .WillOnce(testing::Return(kImplThreadScrollState));
+  }
   EXPECT_CALL(
       mock_input_handler_,
       ScrollBy(testing::Property(&cc::ScrollState::delta_y, testing::Eq(0))))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   time += base::TimeDelta::FromMilliseconds(100);
   Animate(time);
   VERIFY_AND_RESET_MOCKS();
 }
+TEST_P(InputHandlerProxyTest, GestureFlingStopsAtContentEdge) {
+  GestureFlingStopsAtContentEdge();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest,
+       GestureFlingStopsAtContentEdge) {
+  GestureFlingStopsAtContentEdge();
+}
 
 TEST_P(InputHandlerProxyTest, GestureFlingNotCancelledBySmallTimeDelta) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
 
   gesture_.setType(WebInputEvent::GestureScrollBegin);
@@ skipping 919 matching lines @@
 
   // GestureScrollEnd should terminate the resumed scroll properly.
   time += dt;
   gesture_.setTimeStampSeconds(InSecondsF(time));
   gesture_.setType(WebInputEvent::GestureScrollEnd);
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
-
-TEST_P(InputHandlerProxyTest, DidReceiveInputEvent_ForFling) {
+void InputHandlerProxyTest::DidReceiveInputEvent_ForFling() {
   testing::StrictMock<MockInputHandlerProxyClientWithDidAnimateForInput>
       mock_client;
   input_handler_.reset(
-      new TestInputHandlerProxy(&mock_input_handler_, &mock_client, false));
+      new TestInputHandlerProxy(&mock_input_handler_, &mock_client,
+                                touchpad_and_wheel_scroll_latching_enabled_));
   if (install_synchronous_handler_) {
     EXPECT_CALL(mock_input_handler_, RequestUpdateForSynchronousInputHandler())
         .Times(1);
     input_handler_->SetOnlySynchronouslyAnimateRootFlings(
         &mock_synchronous_input_handler_);
   }
   mock_input_handler_.set_is_scrolling_root(synchronous_root_scroll_);
 
   gesture_.setType(WebInputEvent::GestureFlingStart);
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
-  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
+  if (!touchpad_and_wheel_scroll_latching_enabled_)
+    EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
       input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
   EXPECT_CALL(mock_client, DidAnimateForInput());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
+TEST_P(InputHandlerProxyTest, DidReceiveInputEvent_ForFling) {
+  DidReceiveInputEvent_ForFling();
+}
+TEST_P(InputHandlerProxyWithoutWheelScrollLatchingTest,
+       DidReceiveInputEvent_ForFling) {
+  DidReceiveInputEvent_ForFling();
+}
 
 TEST(SynchronousInputHandlerProxyTest, StartupShutdown) {
   testing::StrictMock<MockInputHandler> mock_input_handler;
   testing::StrictMock<MockInputHandlerProxyClient> mock_client;
   testing::StrictMock<MockSynchronousInputHandler>
       mock_synchronous_input_handler;
   ui::InputHandlerProxy proxy(&mock_input_handler, &mock_client, false);
 
   // When adding a SynchronousInputHandler, immediately request an
   // UpdateRootLayerStateForSynchronousInputHandler() call.
@@ skipping 258 matching lines @@
                            base::Bucket(2, 1)));
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_));
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   EXPECT_EQ(expected_disposition_,
             input_handler_->HandleInputEvent(gesture_scroll_end));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
-TEST_F(InputHandlerProxyEventQueueTest, VSyncAlignedGestureScroll) {
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedGestureScroll) {
   base::HistogramTester histogram_tester;
 
   // 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::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(1);
 
@@ skipping 42 matching lines @@
   EXPECT_EQ(0ul, event_queue().size());
   // Should run callbacks for every original events.
   EXPECT_EQ(4ul, event_disposition_recorder_.size());
   EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[1]);
   EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[2]);
   EXPECT_EQ(InputHandlerProxy::DID_HANDLE, event_disposition_recorder_[3]);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   histogram_tester.ExpectUniqueSample(kCoalescedCountHistogram, 2, 1);
 }
 
-TEST_F(InputHandlerProxyEventQueueTest, VSyncAlignedGestureScrollPinchScroll) {
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedGestureScrollPinchScroll) {
   base::HistogramTester histogram_tester;
 
   // Handle scroll on compositor.
   cc::InputHandlerScrollResult scroll_result_did_scroll_;
   scroll_result_did_scroll_.did_scroll = true;
 
   // Start scroll in the first frame.
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(
@@ skipping 48 matching lines @@
 
   input_handler_proxy_->DeliverInputForBeginFrame();
 
   EXPECT_EQ(0ul, event_queue().size());
   EXPECT_EQ(12ul, event_disposition_recorder_.size());
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 1, 2);
   histogram_tester.ExpectBucketCount(kCoalescedCountHistogram, 2, 2);
 }
 
-TEST_F(InputHandlerProxyEventQueueTest, VSyncAlignedQueueingTime) {
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedQueueingTime) {
   base::HistogramTester histogram_tester;
   std::unique_ptr<base::SimpleTestTickClock> tick_clock =
       base::MakeUnique<base::SimpleTestTickClock>();
   base::SimpleTestTickClock* tick_clock_ptr = tick_clock.get();
   tick_clock_ptr->SetNowTicks(base::TimeTicks::Now());
   SetInputHandlerProxyTickClockForTesting(std::move(tick_clock));
 
   // Handle scroll on compositor.
   cc::InputHandlerScrollResult scroll_result_did_scroll_;
   scroll_result_did_scroll_.did_scroll = true;
@@ skipping 25 matching lines @@
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   histogram_tester.ExpectUniqueSample(kContinuousHeadQueueingTimeHistogram, 140,
                                       1);
   histogram_tester.ExpectUniqueSample(kContinuousTailQueueingTimeHistogram, 80,
                                       1);
   histogram_tester.ExpectBucketCount(kNonContinuousQueueingTimeHistogram, 0, 1);
   histogram_tester.ExpectBucketCount(kNonContinuousQueueingTimeHistogram, 70,
                                      1);
 }
 
-TEST_F(InputHandlerProxyEventQueueTest, VSyncAlignedCoalesceScrollAndPinch) {
+TEST_P(InputHandlerProxyEventQueueTest, VSyncAlignedCoalesceScrollAndPinch) {
   // Start scroll in the first frame.
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(kImplThreadScrollState));
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimateInput()).Times(1);
 
   // GSUs and GPUs in one sequence should be coalesced into 1 GSU and 1 GPU.
   HandleGestureEvent(WebInputEvent::GestureScrollBegin);
   HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -20);
   HandleGestureEvent(WebInputEvent::GestureScrollUpdate, -7);
   HandleGestureEvent(WebInputEvent::GesturePinchUpdate, 2.0f, 13, 10);
@@ skipping 31 matching lines @@
       ToWebGestureEvent(event_queue()[4]->event()).data.scrollUpdate.deltaY);
   EXPECT_EQ(WebInputEvent::GesturePinchUpdate,
             event_queue()[5]->event().type());
   EXPECT_EQ(
       0.5f,
       ToWebGestureEvent(event_queue()[5]->event()).data.pinchUpdate.scale);
   EXPECT_EQ(WebInputEvent::GesturePinchEnd, event_queue()[6]->event().type());
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 }
 
-TEST_F(InputHandlerProxyEventQueueTest, OriginalEventsTracing) {
+TEST_P(InputHandlerProxyEventQueueTest, OriginalEventsTracing) {
   // 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_,
@@ skipping 50 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) {
+TEST_P(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_,
@@ skipping 28 matching lines @@
   EXPECT_EQ(WebInputEvent::GestureFlingCancel,
             event_queue()[0]->event().type());
   input_handler_proxy_->DeliverInputForBeginFrame();
   EXPECT_EQ(0ul, event_queue().size());
   EXPECT_EQ(5ul, event_disposition_recorder_.size());
   // Should stop scrolling. Note that no ScrollEnd was sent.
   EXPECT_TRUE(
       !input_handler_proxy_->gesture_scroll_on_impl_thread_for_testing());
 }
 
-TEST_F(InputHandlerProxyEventQueueTest, GestureScrollAfterFling) {
+TEST_P(InputHandlerProxyEventQueueTest, GestureScrollAfterFling) {
   // 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_,
@@ skipping 18 matching lines @@
   // New ScrollBegin should be dispatched immediately as there is no on-going
   // scroll, fling or pinch.
   HandleGestureEvent(WebInputEvent::GestureScrollBegin);
   EXPECT_EQ(0ul, event_queue().size());
 }
 
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
 
+INSTANTIATE_TEST_CASE_P(AnimateInput,
+                        InputHandlerProxyWithoutWheelScrollLatchingTest,
+                        testing::ValuesIn(test_types));
+
+INSTANTIATE_TEST_CASE_P(InputHandlerProxyEventQueueTests,
+                        InputHandlerProxyEventQueueTest,
+                        testing::Bool());
+
 }  // namespace test
 }  // namespace ui