Touchpad and wheel scroll latching for ChromeOS behind flag.

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 436 matching lines @@
     EXPECT_EQ(expected_disposition_,
               input_handler_->HandleInputEvent(gesture_));
 
     VERIFY_AND_RESET_MOCKS();
   }
 
   void SetSmoothScrollEnabled(bool value) {
     input_handler_->smooth_scroll_enabled_ = value;
   }
 
+  void SetTouchpadAndWheelScrollLatchingEnabled(bool value) {
+    input_handler_->touchpad_and_wheel_scroll_latching_enabled_ = value;
+  }
+
   base::HistogramTester& histogram_tester() {
     return histogram_tester_;
   }
 
  protected:
   const bool synchronous_root_scroll_;
   const bool install_synchronous_handler_;
   testing::StrictMock<MockInputHandler> mock_input_handler_;
   testing::StrictMock<MockSynchronousInputHandler>
       mock_synchronous_input_handler_;
@@ skipping 444 matching lines @@
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // 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_));
 }
 
+TEST_P(InputHandlerProxyTest, GestureFlingTouchpadScrollLatchingEnabled) {
+  SetTouchpadAndWheelScrollLatchingEnabled(true);
+  // 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));
+
+  // When scroll latching is enabled, ScrollEnd shouldn't get called while
+  // handling GestureFlingStart.
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
+
+  VERIFY_AND_RESET_MOCKS();
+
+  // The first animate call won't start scrolling.
+  EXPECT_SET_NEEDS_ANIMATE_INPUT(1);
+  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));
+
+  // 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_scroll_));
+
+  // When scroll latching is enabled, ScrollEnd shouldn't get called for every
+  // tick.
+  EXPECT_CALL(mock_input_handler_, ScrollEnd(testing::_)).Times(0);
+  time += base::TimeDelta::FromMilliseconds(100);
+  Animate(time);
+
+  VERIFY_AND_RESET_MOCKS();
+
+  // The last call should stop scrolling.
+  EXPECT_CALL(mock_input_handler_,
+              GetEventListenerProperties(cc::EventListenerClass::kMouseWheel))
+      .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_));
+
+  // 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);
+
+  // Fling has ended, the last Animate won't cause any more wheel ticks.
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_)).Times(0);

[bokan, 2017/01/12 19:33:17]

This needs to go above the Animate call to be effective I think. btw, if you
haven't seen it, reading through at least the beginning of
https://wiki.corp.google.com/twiki/bin/view/Main/GMockGuide is super helpful.

[sahel, 2017/01/12 19:45:22]

Thanks for the doc, I will do that.
I think it's effective as it is now, when I change the Times(0) to Timers(1) the
test fails.

+
+  VERIFY_AND_RESET_MOCKS();
+}
+
 TEST_P(InputHandlerProxyTest, GestureFlingOnMainThreadTouchpad) {
   // 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::GestureFlingStart);
   gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
@@ skipping 2201 matching lines @@
   EXPECT_EQ(WebInputEvent::GesturePinchEnd, event_queue()[6]->event().type);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 }
 
 INSTANTIATE_TEST_CASE_P(AnimateInput,
                         InputHandlerProxyTest,
                         testing::ValuesIn(test_types));
 
 }  // namespace test
 }  // namespace ui