cc: Add a rails argument to InputHandler::ScrollBy

content/renderer/input/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 "content/renderer/input/input_handler_proxy.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "content/common/input/did_overscroll_params.h"
@@ skipping 72 matching lines @@
   MOCK_METHOD0(PinchGestureEnd, void());
 
   MOCK_METHOD0(SetNeedsAnimate, void());
 
   MOCK_METHOD2(ScrollBegin,
                ScrollStatus(const gfx::Point& viewport_point,
                             cc::InputHandler::ScrollInputType type));
   MOCK_METHOD2(ScrollAnimated,
                ScrollStatus(const gfx::Point& viewport_point,
                             const gfx::Vector2dF& scroll_delta));
-  MOCK_METHOD2(ScrollBy,
-               cc::InputHandlerScrollResult(
-                   const gfx::Point& viewport_point,
-                   const gfx::Vector2dF& scroll_delta));
+  MOCK_METHOD3(
+      ScrollBy,
+      cc::InputHandlerScrollResult(const gfx::Point& viewport_point,
+                                   const gfx::Vector2dF& scroll_delta,
+                                   cc::InputHandler::RailsMode rails_mode));
   MOCK_METHOD2(ScrollVerticallyByPage,
                bool(const gfx::Point& viewport_point,
                     cc::ScrollDirection direction));
   MOCK_METHOD0(ScrollEnd, void());
   MOCK_METHOD0(FlingScrollBegin, cc::InputHandler::ScrollStatus());
 
   virtual scoped_ptr<cc::SwapPromiseMonitor>
     CreateLatencyInfoSwapPromiseMonitor(ui::LatencyInfo* latency) override {
       return scoped_ptr<cc::SwapPromiseMonitor>();
   }
@@ skipping 206 matching lines @@
 
   // The event should not be marked as handled if scrolling is not possible.
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
   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_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GestureScrollEnd;
   gesture_.data.scrollUpdate.deltaY = 0;
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
@@ skipping 149 matching lines @@
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(1.5, gfx::Point(7, 13)));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaY =
       -40;  // -Y means scroll down - i.e. in the +Y direction.
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   gesture_.type = WebInputEvent::GesturePinchUpdate;
   gesture_.data.pinchUpdate.scale = 0.5;
   gesture_.x = 9;
   gesture_.y = 6;
   EXPECT_CALL(mock_input_handler_, PinchGestureUpdate(.5, gfx::Point(9, 6)));
@@ skipping 124 matching lines @@
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The second call should start scrolling in the -X direction.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // 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_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD));
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0);
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .Times(0);
   EXPECT_CALL(mock_input_handler_, ScrollEnd()).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
   // *) cumulativeScroll depends on the curve, but since we've animated in the
   // -X direction the X value should be < 0
   EXPECT_CALL(
       mock_client_,
@@ skipping 67 matching lines @@
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The second call should start scrolling in the -X direction.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // 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_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD));
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0);
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .Times(0);
   EXPECT_CALL(mock_input_handler_, ScrollEnd()).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
   // *) cumulativeScroll depends on the curve, but since we've animated in the
   // -X direction the X value should be < 0
   EXPECT_CALL(
@@ skipping 65 matching lines @@
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Tick the second fling once normally.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Gt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Then abort the second fling.
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_ON_MAIN_THREAD));
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0);
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .Times(0);
   EXPECT_CALL(mock_input_handler_, ScrollEnd()).Times(0);
 
   // 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,
@@ skipping 145 matching lines @@
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The second call should start scrolling in the -X direction.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
@@ skipping 33 matching lines @@
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   // With a valid time stamp, the first animate call should skip start time
   // initialization and immediately begin scroll update production. This reduces
   // the likelihood of a hitch between the scroll preceding the fling and
   // the first scroll generated by the fling.
   // Scrolling should start in the -X direction.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += dt;
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
@@ skipping 42 matching lines @@
   base::TimeTicks time =
       base::TimeTicks() + start_time_offset + base::TimeDelta::FromSeconds(1);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Further animation ticks should update the fling as usual.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
@@ skipping 46 matching lines @@
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The second call should start scrolling in the -X direction.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
@@ skipping 24 matching lines @@
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The second animate starts scrolling in the positive X and Y directions.
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // 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_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
       DidOverscroll(testing::AllOf(
           testing::Field(
               &DidOverscrollParams::accumulated_overscroll,
               testing::Eq(overscroll.accumulated_root_overscroll)),
           testing::Field(
               &DidOverscrollParams::latest_overscroll_delta,
               testing::Eq(overscroll.unused_scroll_delta)),
           testing::Field(
               &DidOverscrollParams::current_fling_velocity,
               testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Eq(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Eq(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingNotCancelledBySmallTimeDelta) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
@@ skipping 34 matching lines @@
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   // A small time delta should not stop the fling, even if the client
   // reports no scrolling.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
   time += base::TimeDelta::FromMicroseconds(5);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   // A time delta of zero should not stop the fling, and neither should it
   // trigger scrolling on the client.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   // Lack of movement on the client, with a non-trivial scroll delta, should
   // terminate the fling.
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(1))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(1)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
   time += base::TimeDelta::FromMilliseconds(100);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingCancelledAfterBothAxesStopScrolling) {
   cc::InputHandlerScrollResult overscroll;
@@ skipping 26 matching lines @@
   // The first animate doesn't cause any scrolling.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The second animate starts scrolling in the positive X and Y directions.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The third animate hits the bottom content edge.
   overscroll.accumulated_root_overscroll = gfx::Vector2dF(0, 100);
   overscroll.unused_scroll_delta = gfx::Vector2dF(0, 100);
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
       DidOverscroll(testing::AllOf(
           testing::Field(
               &DidOverscrollParams::accumulated_overscroll,
               testing::Eq(overscroll.accumulated_root_overscroll)),
           testing::Field(
               &DidOverscrollParams::latest_overscroll_delta,
               testing::Eq(overscroll.unused_scroll_delta)),
           testing::Field(
               &DidOverscrollParams::current_fling_velocity,
               testing::Property(&gfx::Vector2dF::y, testing::Lt(0))))));
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The next call to animate will no longer scroll vertically.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y, testing::Eq(0))))
+                       testing::Property(&gfx::Vector2dF::y, testing::Eq(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The next call will hit the right edge.
   overscroll.accumulated_root_overscroll = gfx::Vector2dF(100, 100);
   overscroll.unused_scroll_delta = gfx::Vector2dF(100, 0);
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(overscroll));
   EXPECT_CALL(
       mock_client_,
       DidOverscroll(testing::AllOf(
           testing::Field(
               &DidOverscrollParams::accumulated_overscroll,
               testing::Eq(overscroll.accumulated_root_overscroll)),
           testing::Field(
               &DidOverscrollParams::latest_overscroll_delta,
               testing::Eq(overscroll.unused_scroll_delta)),
           testing::Field(
               &DidOverscrollParams::current_fling_velocity,
               testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The next call to animate will no longer scroll horizontally or vertically,
   // and the fling should be cancelled.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate()).Times(0);
-  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_)).Times(0);
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .Times(0);
   time += base::TimeDelta::FromMilliseconds(10);
   input_handler_->Animate(time);
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
   EXPECT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 }
 
 TEST_F(InputHandlerProxyTest, MultiTouchPointHitTestNegative) {
   // None of the three touch points fall in the touch region. So the event
   // should be dropped.
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
@@ skipping 129 matching lines @@
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // If we get a negative time delta, that is, the Animation tick time happens
   // before the fling's start time then we should *not* try scrolling and
   // instead reset the fling start time.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::_)).Times(0);
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .Times(0);
   time -= base::TimeDelta::FromMilliseconds(5);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // The first call should have reset the start time so subsequent calls should
   // generate scroll events.
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0))))
+                       testing::Property(&gfx::Vector2dF::x, testing::Lt(0)),
+                       cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
 
   input_handler_->Animate(time + base::TimeDelta::FromMilliseconds(1));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
@@ skipping 23 matching lines @@
   gesture_.type = WebInputEvent::GestureScrollBegin;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Animate calls within the deferred cancellation window should continue.
   time += dt;
   float expected_delta =
       (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   input_handler_->Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureScrollUpdates in the same direction and at sufficient speed should
   // be swallowed by the fling.
   time += dt;
   gesture_.timeStampSeconds = InSecondsF(time);
   gesture_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaX = fling_delta.x;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Animate calls within the deferred cancellation window should continue.
   time += dt;
   expected_delta = (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   input_handler_->Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureFlingStart in the same direction and at sufficient speed should
   // boost the active fling.
 
   gesture_ = CreateFling(time,
                          blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_point,
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   time += dt;
   // Note we get *2x* as much delta because 2 flings have combined.
   expected_delta = 2 * (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   input_handler_->Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // Repeated GestureFlingStarts should accumulate.
 
   CancelFling(time);
   gesture_ = CreateFling(time,
                          blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_point,
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   time += dt;
   // Note we get *3x* as much delta because 3 flings have combined.
   expected_delta = 3 * (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   input_handler_->Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureFlingCancel should terminate the fling if no boosting gestures are
   // received within the timeout window.
 
   time += dt;
@@ skipping 102 matching lines @@
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Note that the new fling delta uses the orthogonal, unboosted fling
   // velocity.
   time += dt;
   float expected_delta = dt.InSecondsF() * -orthogonal_fling_delta.y;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::y,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::y,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   input_handler_->Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfScrollInDifferentDirection) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
@@ skipping 21 matching lines @@
 
   // If the GestureScrollUpdate is in a different direction than the fling,
   // the fling should be cancelled and scrolling should resume.
   time += dt;
   gesture_.timeStampSeconds = InSecondsF(time);
   gesture_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaX = -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(fling_delta.x))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(fling_delta.x)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfFlingTooSlow) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
@@ skipping 16 matching lines @@
                          fling_point,
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Note that the new fling delta uses the *slow*, unboosted fling velocity.
   time += dt;
   float expected_delta = dt.InSecondsF() * -small_fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   input_handler_->Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfPreventBoostingFlagIsSet) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
@@ skipping 38 matching lines @@
 
   VERIFY_AND_RESET_MOCKS();
 
   // Now animate the fling to completion (in this case, the fling should
   // terminate because the input handler reports a failed scroll). As the fling
   // was cancelled during an active scroll sequence, a synthetic
   // GestureScrollBegin should be processed, resuming the scroll.
   time += dt;
   float expected_delta =
       (time - last_animate_time).InSecondsF() * -fling_delta.x;
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_not_scroll_));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
   input_handler_->Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 
   // Subsequent GestureScrollUpdates after the cancelled, boosted fling should
   // cause scrolling as usual.
   time += dt;
   expected_delta = 7.3f;
   gesture_.timeStampSeconds = InSecondsF(time);
   gesture_.type = WebInputEvent::GestureScrollUpdate;
   gesture_.data.scrollUpdate.deltaX = -expected_delta;
-  EXPECT_CALL(mock_input_handler_,
-              ScrollBy(testing::_,
-                       testing::Property(&gfx::Vector2dF::x,
-                                         testing::Eq(expected_delta))))
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::Property(&gfx::Vector2dF::x,
+                                             testing::Eq(expected_delta)),
+               cc::InputHandler::RAILS_MODE_FREE))
       .WillOnce(testing::Return(scroll_result_did_scroll_));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureScrollEnd should terminate the resumed scroll properly.
   time += dt;
   gesture_.timeStampSeconds = InSecondsF(time);
   gesture_.type = WebInputEvent::GestureScrollEnd;
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
@@ skipping 44 matching lines @@
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_client, DidAnimateForInput());
   base::TimeTicks time = base::TimeTicks() + base::TimeDelta::FromSeconds(10);
   input_handler_->Animate(time);
 
   testing::Mock::VerifyAndClearExpectations(&mock_client);
 }
 
+TEST_F(InputHandlerProxyTest, WheelRailsModes) {
+  WebMouseWheelEvent wheel;
+  wheel.type = WebInputEvent::MouseWheel;
+  wheel.deltaX = 1;
+  wheel.deltaY = 2;
+
+  // We shouldn't send any events to the widget for this gesture.
+  VERIFY_AND_RESET_MOCKS();
+
+  // Begin the scroll gesture
+  wheel.phase = WebMouseWheelEvent::PhaseBegan;
+  wheel.railsMode = WebInputEvent::RailsModeFree;
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
+            input_handler_->HandleInputEvent(wheel));
+  VERIFY_AND_RESET_MOCKS();
+
+  // Scroll with no rails.
+  wheel.phase = WebMouseWheelEvent::PhaseChanged;
+  wheel.railsMode = WebInputEvent::RailsModeFree;
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
+            input_handler_->HandleInputEvent(wheel));
+  VERIFY_AND_RESET_MOCKS();
+
+  // Scroll with horizontal rails.
+  wheel.phase = WebMouseWheelEvent::PhaseChanged;
+  wheel.railsMode = WebInputEvent::RailsModeHorizontal;
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::_, cc::InputHandler::RAILS_MODE_HORIZONTAL))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
+            input_handler_->HandleInputEvent(wheel));
+  VERIFY_AND_RESET_MOCKS();
+
+  // Scroll with vertical rails.
+  wheel.phase = WebMouseWheelEvent::PhaseChanged;
+  wheel.railsMode = WebInputEvent::RailsModeVertical;
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
+  EXPECT_CALL(
+      mock_input_handler_,
+      ScrollBy(testing::_, testing::_, cc::InputHandler::RAILS_MODE_VERTICAL))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
+            input_handler_->HandleInputEvent(wheel));
+  VERIFY_AND_RESET_MOCKS();
+
+  // Scroll with no rails.
+  wheel.phase = WebMouseWheelEvent::PhaseChanged;
+  wheel.railsMode = WebInputEvent::RailsModeFree;
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
+            input_handler_->HandleInputEvent(wheel));
+  VERIFY_AND_RESET_MOCKS();
+
+  // Stop the scroll gesture.
+  wheel.phase = WebMouseWheelEvent::PhaseEnded;
+  wheel.railsMode = WebInputEvent::RailsModeFree;
+  EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
+      .WillOnce(testing::Return(cc::InputHandler::SCROLL_STARTED));
+  EXPECT_CALL(mock_input_handler_, ScrollBy(testing::_, testing::_,
+                                            cc::InputHandler::RAILS_MODE_FREE))
+      .WillOnce(testing::Return(scroll_result_did_scroll_));
+  EXPECT_CALL(mock_input_handler_, ScrollEnd());
+  EXPECT_EQ(InputHandlerProxy::DID_HANDLE,
+            input_handler_->HandleInputEvent(wheel));
+  VERIFY_AND_RESET_MOCKS();
+}
+
 } // namespace
 } // namespace content