cc: Add a rails argument to InputHandler::ScrollBy

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 487 matching lines @@
 
 TEST_F(LayerTreeHostImplTest, ScrollRootCallsCommitAndRedraw) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
   EXPECT_TRUE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(),
                                                       InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(0, 10),
                                                       InputHandler::WHEEL));
   host_impl_->ScrollEnd();
   EXPECT_FALSE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(),
                                                        InputHandler::WHEEL));
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollActiveOnlyAfterScrollMovement) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
   EXPECT_FALSE(host_impl_->IsActivelyScrolling());
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(host_impl_->IsActivelyScrolling());
   host_impl_->ScrollEnd();
   EXPECT_FALSE(host_impl_->IsActivelyScrolling());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithoutRootLayer) {
   // We should not crash when trying to scroll an empty layer tree.
   EXPECT_EQ(InputHandler::SCROLL_IGNORED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 }
@@ skipping 23 matching lines @@
   // We should not crash if the tree is replaced while we are scrolling.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
   host_impl_->active_tree()->DetachLayerTree();
 
   scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // We should still be scrolling, because the scrolled layer also exists in the
   // new tree.
   gfx::Vector2d scroll_delta(0, 10);
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info, scroll_layer->id(), scroll_delta);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollBlocksOnWheelEventHandlers) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
   LayerImpl* root = host_impl_->active_tree()->root_layer();
@@ skipping 251 matching lines @@
   EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD,
             host_impl_->ScrollBegin(gfx::Point(25, 25), InputHandler::GESTURE));
   EXPECT_FALSE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(25, 25),
                                                        InputHandler::GESTURE));
 
   // All scroll types outside this region should succeed.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(75, 75), InputHandler::WHEEL));
   EXPECT_TRUE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(75, 75),
                                                       InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_FALSE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(25, 25),
                                                        InputHandler::GESTURE));
   host_impl_->ScrollEnd();
   EXPECT_FALSE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(75, 75),
                                                        InputHandler::GESTURE));
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(75, 75), InputHandler::GESTURE));
   EXPECT_TRUE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(75, 75),
                                                       InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   EXPECT_FALSE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(75, 75),
                                                        InputHandler::GESTURE));
 }
 
 TEST_F(LayerTreeHostImplTest, NonFastScrollableRegionWithOffset) {
   SetupScrollAndContentsLayers(gfx::Size(200, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   LayerImpl* root = host_impl_->active_tree()->root_layer();
   root->SetContentsScale(2.f, 2.f);
   root->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
   root->SetPosition(gfx::PointF(-25.f, 0.f));
 
   DrawFrame();
 
   // This point would fall into the non-fast scrollable region except that we've
   // moved the layer down by 25 pixels.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(40, 10), InputHandler::WHEEL));
   EXPECT_TRUE(host_impl_->IsCurrentlyScrollingLayerAt(gfx::Point(40, 10),
                                                       InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 1));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 1),
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // This point is still inside the non-fast region.
   EXPECT_EQ(InputHandler::SCROLL_ON_MAIN_THREAD,
             host_impl_->ScrollBegin(gfx::Point(10, 10), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollHandlerNotPresent) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(200, 200));
   EXPECT_FALSE(scroll_layer->have_scroll_event_handlers());
@@ skipping 23 matching lines @@
 TEST_F(LayerTreeHostImplTest, ScrollByReturnsCorrectValue) {
   SetupScrollAndContentsLayers(gfx::Size(200, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
 
   // Trying to scroll to the left/top will not succeed.
-  EXPECT_FALSE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)).did_scroll);
-  EXPECT_FALSE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10)).did_scroll);
-  EXPECT_FALSE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10)).did_scroll);
+  EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0),
+                                    InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10),
+                                    InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10),
+                                    InputHandler::RAILS_MODE_FREE).did_scroll);
 
   // Scrolling to the right/bottom will succeed.
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, 0)).did_scroll);
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)).did_scroll);
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, 10)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, 0),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, 10),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
 
   // Scrolling to left/top will now succeed.
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)).did_scroll);
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10)).did_scroll);
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
 
   // Scrolling diagonally against an edge will succeed.
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, -10)).did_scroll);
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)).did_scroll);
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 10)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, -10),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 10),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
 
   // Trying to scroll more than the available space will also succeed.
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(5000, 5000)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(5000, 5000),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
+}
+
+TEST_F(LayerTreeHostImplTest, ScrollByRespectsRails) {
+  LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(200, 200));
+  host_impl_->SetViewportSize(gfx::Size(100, 100));
+  DrawFrame();
+  InputHandlerScrollResult result;
+
+  EXPECT_EQ(InputHandler::SCROLL_STARTED,
+            host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
+
+  // A free scroll.
+  result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(1, 2),
+                                InputHandler::RAILS_MODE_FREE);
+  EXPECT_TRUE(result.did_scroll);
+  EXPECT_FALSE(result.did_overscroll_root);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 2), scroll_layer->CurrentScrollOffset());
+
+  // A vertically railed scroll.
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(1, 2),
+                       InputHandler::RAILS_MODE_VERTICAL);
+  EXPECT_TRUE(result.did_scroll);
+  EXPECT_FALSE(result.did_overscroll_root);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(1, 4), scroll_layer->CurrentScrollOffset());
+
+  // A horizontally railed scroll.
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(1, 2),
+                       InputHandler::RAILS_MODE_HORIZONTAL);
+  EXPECT_TRUE(result.did_scroll);
+  EXPECT_FALSE(result.did_overscroll_root);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(2, 4), scroll_layer->CurrentScrollOffset());
+
+  // A horizontally railed scroll which has no horizontal component.
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 2),
+                       InputHandler::RAILS_MODE_HORIZONTAL);
+  EXPECT_TRUE(result.did_scroll);
+  EXPECT_FALSE(result.did_overscroll_root);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(2, 4), scroll_layer->CurrentScrollOffset());
+
+  // A free scroll to return to the document's edge, so we can test overscroll.
+  result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-2, -4),
+                                InputHandler::RAILS_MODE_FREE);
+  EXPECT_TRUE(result.did_scroll);
+  EXPECT_FALSE(result.did_overscroll_root);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), scroll_layer->CurrentScrollOffset());
+
+  // A horizontally railed overscroll with a vertical component in overscroll
+  // direction.
+  result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-1, -2),
+                                InputHandler::RAILS_MODE_HORIZONTAL);
+  EXPECT_FALSE(result.did_scroll);
+  EXPECT_TRUE(result.did_overscroll_root);
+  EXPECT_EQ(gfx::Vector2dF(-1, 0), result.unused_scroll_delta);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), scroll_layer->CurrentScrollOffset());
+
+  // A horizontally railed overscroll with a vertical component in scroll
+  // direction.
+  result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-1, 2),
+                                InputHandler::RAILS_MODE_HORIZONTAL);
+  EXPECT_FALSE(result.did_scroll);
+  EXPECT_TRUE(result.did_overscroll_root);
+  EXPECT_EQ(gfx::Vector2dF(-1, 0), result.unused_scroll_delta);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 0), scroll_layer->CurrentScrollOffset());
+
+  // A vertically railed scroll with a horizontal component in overscroll
+  // direction.
+  result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-1, 2),
+                                InputHandler::RAILS_MODE_VERTICAL);
+  EXPECT_TRUE(result.did_scroll);
+  EXPECT_FALSE(result.did_overscroll_root);
+  EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 2), scroll_layer->CurrentScrollOffset());
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollVerticallyByPageReturnsCorrectValue) {
   SetupScrollAndContentsLayers(gfx::Size(200, 2000));
   host_impl_->SetViewportSize(gfx::Size(100, 1000));
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
@@ skipping 37 matching lines @@
 
   DrawFrame();
   gfx::Point scroll_position(10, 10);
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(scroll_position, InputHandler::WHEEL));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), overflow->CurrentScrollOffset());
 
   gfx::Vector2dF scroll_delta(10, 10);
-  host_impl_->ScrollBy(scroll_position, scroll_delta);
+  host_impl_->ScrollBy(scroll_position, scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 10), overflow->CurrentScrollOffset());
 
   overflow->set_user_scrollable_horizontal(false);
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(scroll_position, InputHandler::WHEEL));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 10), overflow->CurrentScrollOffset());
 
-  host_impl_->ScrollBy(scroll_position, scroll_delta);
+  host_impl_->ScrollBy(scroll_position, scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 0), scroll_layer->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 20), overflow->CurrentScrollOffset());
 
   overflow->set_user_scrollable_vertical(false);
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(scroll_position, InputHandler::WHEEL));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 0), scroll_layer->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 20), overflow->CurrentScrollOffset());
 
-  host_impl_->ScrollBy(scroll_position, scroll_delta);
+  host_impl_->ScrollBy(scroll_position, scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   EXPECT_VECTOR_EQ(gfx::Vector2dF(20, 10), scroll_layer->CurrentScrollOffset());
   EXPECT_VECTOR_EQ(gfx::Vector2dF(10, 20), overflow->CurrentScrollOffset());
 }
 
 TEST_F(LayerTreeHostImplTest, ImplPinchZoom) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   DrawFrame();
 
@@ skipping 42 matching lines @@
     float page_scale_delta = 2.f;
     host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd();
 
     gfx::Vector2d scroll_delta(0, 10);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     ExpectContains(*scroll_info.get(), scroll_layer->id(),
                    gfx::Vector2d(0, scroll_delta.y() / page_scale_delta));
   }
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithSwapPromises) {
   ui::LatencyInfo latency_info;
   latency_info.trace_id = 1234;
   scoped_ptr<SwapPromise> swap_promise(
       new LatencyInfoSwapPromise(latency_info));
 
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->QueueSwapPromiseForMainThreadScrollUpdate(swap_promise.Pass());
   host_impl_->ScrollEnd();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   EXPECT_EQ(1u, scroll_info->swap_promises.size());
   EXPECT_EQ(latency_info.trace_id, scroll_info->swap_promises[0]->TraceId());
 }
 
 TEST_F(LayerTreeHostImplTest, PinchGesture) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
@@ skipping 94 matching lines @@
     host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, min_page_scale,
                                                            max_page_scale);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
     scroll_layer->PullDeltaForMainThread();
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(20, 20));
 
     float page_scale_delta = 1.f;
     host_impl_->ScrollBegin(gfx::Point(10, 10), InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(10, 10));
-    host_impl_->ScrollBy(gfx::Point(10, 10), gfx::Vector2d(-10, -10));
+    host_impl_->ScrollBy(gfx::Point(10, 10), gfx::Vector2d(-10, -10),
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point(20, 20));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, page_scale_delta);
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(-10, -10));
   }
 
   // Two-finger panning should work when starting fully zoomed out.
   {
     host_impl_->active_tree()->PushPageScaleFromMainThread(0.5f, 0.5f, 4.f);
     scroll_layer->SetScrollDelta(gfx::Vector2d());
     scroll_layer->PullDeltaForMainThread();
     scroll_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 0));
 
     host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::GESTURE);
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(2.f, gfx::Point(0, 0));
     host_impl_->PinchGestureUpdate(1.f, gfx::Point(0, 0));
-    host_impl_->ScrollBy(gfx::Point(0, 0), gfx::Vector2d(10, 10));
+    host_impl_->ScrollBy(gfx::Point(0, 0), gfx::Vector2d(10, 10),
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->PinchGestureUpdate(1.f, gfx::Point(10, 10));
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     EXPECT_EQ(scroll_info->page_scale_delta, 2.f);
     ExpectContains(*scroll_info, scroll_layer->id(), gfx::Vector2d(20, 20));
   }
 }
@@ skipping 369 matching lines @@
     host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL);
     host_impl_->ScrollEnd();
     EXPECT_FALSE(did_request_animate_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
     // After a scroll, a scrollbar animation should be scheduled about 20ms from
     // now.
     host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL);
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, 5));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, 5),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_FALSE(did_request_animate_);
     EXPECT_TRUE(did_request_redraw_);
     did_request_redraw_ = false;
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
     host_impl_->ScrollEnd();
     EXPECT_FALSE(did_request_animate_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
@@ skipping 24 matching lines @@
     EXPECT_FALSE(did_request_animate_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta::FromMilliseconds(20),
               requested_animation_delay_);
     EXPECT_FALSE(animation_task_.Equals(base::Closure()));
     requested_animation_delay_ = base::TimeDelta();
     animation_task_ = base::Closure();
 
     // Scrollbar animation is not triggered unnecessarily.
     host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL);
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(5, 0));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(5, 0),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_FALSE(did_request_animate_);
     EXPECT_TRUE(did_request_redraw_);
     did_request_redraw_ = false;
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
     EXPECT_TRUE(animation_task_.Equals(base::Closure()));
 
     host_impl_->ScrollEnd();
     EXPECT_FALSE(did_request_animate_);
     EXPECT_FALSE(did_request_redraw_);
     EXPECT_EQ(base::TimeDelta(), requested_animation_delay_);
@@ skipping 127 matching lines @@
     EXPECT_EQ(gfx::SizeF(100.f, 100.f), metadata.root_layer_size);
     EXPECT_EQ(0.5f, metadata.min_page_scale_factor);
     EXPECT_EQ(4.f, metadata.max_page_scale_factor);
     EXPECT_FALSE(metadata.root_overflow_x_hidden);
     EXPECT_FALSE(metadata.root_overflow_y_hidden);
   }
 
   // Scrolling should update metadata immediately.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(0.f, 10.f), metadata.root_scroll_offset);
   }
   host_impl_->ScrollEnd();
   {
     CompositorFrameMetadata metadata =
         host_impl_->MakeCompositorFrameMetadata();
     EXPECT_EQ(gfx::Vector2dF(0.f, 10.f), metadata.root_scroll_offset);
@@ skipping 796 matching lines @@
       host_impl_->active_tree()->OuterViewportScrollLayer();
   LayerImpl *outer_container =
       host_impl_->active_tree()->OuterViewportContainerLayer();
 
   // Need SetDrawsContent so ScrollBegin's hit test finds an actual layer.
   outer_scroll->SetDrawsContent(true);
   host_impl_->active_tree()->PushPageScaleFromMainThread(2.f, 1.f, 2.f);
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, 50.f));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, 50.f),
+                       InputHandler::RAILS_MODE_FREE);
 
   // The entire scroll delta should have been used to hide the top controls.
   // The viewport layers should be resized back to their full sizes.
   EXPECT_EQ(0.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
   EXPECT_EQ(0.f, inner_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(100.f, inner_container->BoundsForScrolling().height());
   EXPECT_EQ(100.f, outer_container->BoundsForScrolling().height());
 
   // The inner viewport should be scrollable by 50px * page_scale.
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, 100.f));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, 100.f),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(50.f, inner_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(0.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(gfx::ScrollOffset(), outer_scroll->MaxScrollOffset());
 
   host_impl_->ScrollEnd();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), inner_scroll);
 
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -50.f));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -50.f),
+                       InputHandler::RAILS_MODE_FREE);
 
   // The entire scroll delta should have been used to show the top controls.
   // The outer viewport should be resized to accomodate and scrolled to the
   // bottom of the document to keep the viewport in place.
   EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
   EXPECT_EQ(50.f, outer_container->BoundsForScrolling().height());
   EXPECT_EQ(50.f, inner_container->BoundsForScrolling().height());
   EXPECT_EQ(25.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(25.f, inner_scroll->CurrentScrollOffset().y());
 
   // Now when we continue scrolling, make sure the outer viewport gets scrolled
   // since it wasn't scrollable when the scroll began.
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -20.f));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -20.f),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(15.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(25.f, inner_scroll->CurrentScrollOffset().y());
 
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -30.f));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -30.f),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(0.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(25.f, inner_scroll->CurrentScrollOffset().y());
 
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -50.f));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.f, -50.f),
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   EXPECT_EQ(0.f, outer_scroll->CurrentScrollOffset().y());
   EXPECT_EQ(0.f, inner_scroll->CurrentScrollOffset().y());
 }
 
 // Test that the fixed position container delta is appropriately adjusted
 // by the top controls showing/hiding and page scale doesn't affect it.
 TEST_F(LayerTreeHostImplTopControlsTest, FixedContainerDelta) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
@@ skipping 75 matching lines @@
 
   // scroll child to limit
   child->SetScrollDelta(gfx::Vector2dF(0, 100.f));
   child_clip->AddChild(child.Pass());
   outer_viewport_scroll_layer->AddChild(child_clip.Pass());
 
   // Scroll 25px to hide top controls
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // Top controls should be hidden
   EXPECT_EQ(scroll_delta.y(),
             top_controls_height_ -
                 host_impl_->top_controls_manager()->ContentTopOffset());
 }
 
 // Ensure setting the top controls position explicitly using the setters on the
 // TreeImpl correctly affects the top controls manager and viewport bounds.
@@ skipping 128 matching lines @@
   inner_scroll->SetScrollDelta(gfx::Vector2dF(100, 100.f));
 
   gfx::ScrollOffset viewport_offset =
       host_impl_->active_tree()->TotalScrollOffset();
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(), viewport_offset);
 
   // Hide the top controls by 25px.
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
 
   // scrolling down at the max extents no longer hides the top controls
   EXPECT_EQ(1.f, host_impl_->active_tree()->CurrentTopControlsShownRatio());
 
   // forcefully hide the top controls by 25px
   host_impl_->top_controls_manager()->ScrollBy(scroll_delta);
   host_impl_->ScrollEnd();
 
   EXPECT_FLOAT_EQ(scroll_delta.y(),
                   top_controls_height_ -
                       host_impl_->top_controls_manager()->ContentTopOffset());
 
   inner_scroll->ClampScrollToMaxScrollOffset();
   outer_scroll->ClampScrollToMaxScrollOffset();
 
   // We should still be fully scrolled.
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(),
             host_impl_->active_tree()->TotalScrollOffset());
 
   viewport_offset = host_impl_->active_tree()->TotalScrollOffset();
 
   // Bring the top controls down by 25px.
   scroll_delta = gfx::Vector2dF(0.f, -25.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // The viewport offset shouldn't have changed.
   EXPECT_EQ(viewport_offset,
             host_impl_->active_tree()->TotalScrollOffset());
 
   // Scroll the viewports to max scroll offset.
   outer_scroll->SetScrollDelta(gfx::Vector2dF(0, 200.f));
   inner_scroll->SetScrollDelta(gfx::Vector2dF(100, 100.f));
   EXPECT_EQ(host_impl_->active_tree()->TotalMaxScrollOffset(),
             host_impl_->active_tree()->TotalScrollOffset());
 }
 
 // Test that the top controls coming in and out maintains the same aspect ratio
 // between the inner and outer viewports.
 TEST_F(LayerTreeHostImplTopControlsTest, TopControlsAspectRatio) {
   SetupTopControlsAndScrollLayerWithVirtualViewport(
       gfx::Size(100, 100), gfx::Size(200, 200), gfx::Size(200, 400));
   DrawFrame();
 
   EXPECT_FLOAT_EQ(top_controls_height_,
                   host_impl_->top_controls_manager()->ContentTopOffset());
 
   gfx::Vector2dF scroll_delta(0.f, 25.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   EXPECT_FLOAT_EQ(scroll_delta.y(),
                   top_controls_height_ -
                       host_impl_->top_controls_manager()->ContentTopOffset());
 
   // Top controls were hidden by 25px so the inner viewport should have expanded
   // by that much.
   LayerImpl* outer_container =
             host_impl_->active_tree()->OuterViewportContainerLayer();
@@ skipping 17 matching lines @@
   DrawFrame();
 
   EXPECT_EQ(top_controls_height_,
             host_impl_->top_controls_manager()->ContentTopOffset());
 
   // Send a gesture scroll that will scroll the outer viewport, make sure the
   // top controls get scrolled.
   gfx::Vector2dF scroll_delta(0.f, 15.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(host_impl_->OuterViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
   host_impl_->ScrollEnd();
 
   EXPECT_FLOAT_EQ(scroll_delta.y(),
                   top_controls_height_ -
                       host_impl_->top_controls_manager()->ContentTopOffset());
 
   scroll_delta = gfx::Vector2dF(0.f, 50.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
 
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_EQ(host_impl_->OuterViewportScrollLayer(),
             host_impl_->CurrentlyScrollingLayer());
 
   host_impl_->ScrollEnd();
 
   // Position the viewports such that the inner viewport will be scrolled.
   gfx::Vector2dF inner_viewport_offset(0.f, 25.f);
   host_impl_->OuterViewportScrollLayer()->SetScrollDelta(gfx::Vector2dF());
   host_impl_->InnerViewportScrollLayer()->SetScrollDelta(inner_viewport_offset);
 
   scroll_delta = gfx::Vector2dF(0.f, -65.f);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
 
   EXPECT_EQ(top_controls_height_,
             host_impl_->top_controls_manager()->ContentTopOffset());
   EXPECT_FLOAT_EQ(
       inner_viewport_offset.y() + (scroll_delta.y() + top_controls_height_),
       host_impl_->InnerViewportScrollLayer()->ScrollDelta().y());
 
   host_impl_->ScrollEnd();
 }
 
@@ skipping 76 matching lines @@
   scroll_layer->AddChild(content_layer.Pass());
   scroll_clip_layer->AddChild(scroll_layer.Pass());
 
   scroll_clip_layer->SetHasRenderSurface(true);
   host_impl_->active_tree()->SetRootLayer(scroll_clip_layer.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
   root->SetContentBounds(contents_size);
   root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
   root->SetHasRenderSurface(true);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollMissesChild) {
   gfx::Size surface_size(10, 10);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->AddChild(CreateScrollableLayer(2, surface_size, root.get()));
   root->SetHasRenderSurface(true);
@@ skipping 86 matching lines @@
 
   LayerImpl* root_scroll =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   EXPECT_EQ(viewport_size, root_scroll->scroll_clip_layer()->bounds());
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta = scroll_delta;
   gfx::ScrollOffset expected_max_scroll = root_scroll->MaxScrollOffset();
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // Set new page scale from main thread.
   host_impl_->active_tree()->PushPageScaleFromMainThread(page_scale, page_scale,
                                                          page_scale);
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(), root_scroll->id(), expected_scroll_delta);
 
   // The scroll range should also have been updated.
@@ skipping 30 matching lines @@
 
   LayerImpl* root_scroll =
       host_impl_->active_tree()->InnerViewportScrollLayer();
   EXPECT_EQ(viewport_size, root_scroll->scroll_clip_layer()->bounds());
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta = scroll_delta;
   gfx::ScrollOffset expected_max_scroll = root_scroll->MaxScrollOffset();
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // Set new page scale on impl thread by pinching.
   host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(page_scale, gfx::Point());
   host_impl_->PinchGestureEnd();
   host_impl_->ScrollEnd();
   DrawOneFrame();
 
@@ skipping 90 matching lines @@
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   gfx::Vector2d scroll_delta(0, 10);
   gfx::Vector2d expected_scroll_delta(scroll_delta);
   gfx::ScrollOffset expected_max_scroll(child->MaxScrollOffset());
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   float page_scale = 2.f;
   host_impl_->active_tree()->PushPageScaleFromMainThread(page_scale, 1.f,
                                                          page_scale);
 
   DrawOneFrame();
 
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(
@@ skipping 30 matching lines @@
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 5));
   child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(3, 0));
 
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(-8, -7);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // The grand child should have scrolled up to its limit.
     LayerImpl* child = host_impl_->active_tree()->root_layer()->children()[0];
     LayerImpl* grand_child = child->children()[0];
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, -5));
 
@@ skipping 33 matching lines @@
 
   grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
   child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 3));
 
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::NON_BUBBLING_GESTURE));
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // The grand child should have scrolled up to its limit.
     LayerImpl* child =
         host_impl_->active_tree()->root_layer()->children()[0]->children()[0];
     LayerImpl* grand_child = child->children()[0];
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, -2));
 
     // The child should not have scrolled.
     ExpectNone(*scroll_info.get(), child->id());
 
     // The next time we scroll we should only scroll the parent.
     scroll_delta = gfx::Vector2d(0, -3);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::NON_BUBBLING_GESTURE));
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child);
     host_impl_->ScrollEnd();
 
     scroll_info = host_impl_->ProcessScrollDeltas();
 
     // The child should have scrolled up to its limit.
     ExpectContains(*scroll_info.get(), child->id(), gfx::Vector2d(0, -3));
 
     // The grand child should not have scrolled.
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, -2));
 
     // After scrolling the parent, another scroll on the opposite direction
     // should still scroll the child.
     scroll_delta = gfx::Vector2d(0, 7);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::NON_BUBBLING_GESTURE));
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
     host_impl_->ScrollEnd();
 
     scroll_info = host_impl_->ProcessScrollDeltas();
 
     // The grand child should have scrolled.
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, 5));
 
     // The child should not have scrolled.
     ExpectContains(*scroll_info.get(), child->id(), gfx::Vector2d(0, -3));
 
 
     // Scrolling should be adjusted from viewport space.
     host_impl_->active_tree()->PushPageScaleFromMainThread(2.f, 2.f, 2.f);
     host_impl_->SetPageScaleOnActiveTree(2.f);
 
     scroll_delta = gfx::Vector2d(0, -2);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(1, 1),
                                       InputHandler::NON_BUBBLING_GESTURE));
     EXPECT_EQ(grand_child, host_impl_->CurrentlyScrollingLayer());
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     scroll_info = host_impl_->ProcessScrollDeltas();
 
     // Should have scrolled by half the amount in layer space (5 - 2/2)
     ExpectContains(*scroll_info.get(), grand_child->id(), gfx::Vector2d(0, 4));
   }
 }
 TEST_F(LayerTreeHostImplTest, ScrollEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
@@ skipping 19 matching lines @@
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 2,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 4);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // Only the root scroll should have scrolled.
     ASSERT_EQ(scroll_info->scrolls.size(), 1u);
     ExpectContains(*scroll_info.get(), root_scroll_id, scroll_delta);
   }
 }
@@ skipping 43 matching lines @@
   host_impl_->active_tree()->root_layer()->SetTransform(rotate_transform);
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   // Scroll to the right in screen coordinates with a gesture.
   gfx::Vector2d gesture_scroll_delta(10, 0);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // The layer should have scrolled down in its local coordinates.
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(), scroll_layer->id(),
                  gfx::Vector2d(0, gesture_scroll_delta.x()));
 
   // Reset and scroll down with the wheel.
   scroll_layer->SetScrollDelta(gfx::Vector2dF());
   gfx::Vector2d wheel_scroll_delta(0, 10);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), wheel_scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), wheel_scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // The layer should have scrolled down in its local coordinates.
   scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(),
                  scroll_layer->id(),
                  wheel_scroll_delta);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollNonAxisAlignedRotatedLayer) {
@@ skipping 26 matching lines @@
   scroll_layer->AddChild(clip_layer.Pass());
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     // Scroll down in screen coordinates with a gesture.
     gfx::Vector2d gesture_scroll_delta(0, 10);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(1, 1), InputHandler::GESTURE));
-    host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     // The child layer should have scrolled down in its local coordinates an
     // amount proportional to the angle between it and the input scroll delta.
     gfx::Vector2d expected_scroll_delta(
         0, gesture_scroll_delta.y() *
                std::cos(MathUtil::Deg2Rad(child_layer_angle)));
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     ExpectContains(*scroll_info.get(), child_layer_id, expected_scroll_delta);
 
     // The root scroll layer should not have scrolled, because the input delta
     // was close to the layer's axis of movement.
     EXPECT_EQ(scroll_info->scrolls.size(), 1u);
   }
   {
     // Now reset and scroll the same amount horizontally.
     child_ptr->SetScrollDelta(gfx::Vector2dF());
     gfx::Vector2d gesture_scroll_delta(10, 0);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(1, 1), InputHandler::GESTURE));
-    host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), gesture_scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
 
     // The child layer should have scrolled down in its local coordinates an
     // amount proportional to the angle between it and the input scroll delta.
     gfx::Vector2d expected_scroll_delta(
         0, -gesture_scroll_delta.x() *
                std::sin(MathUtil::Deg2Rad(child_layer_angle)));
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
     ExpectContains(*scroll_info.get(), child_layer_id, expected_scroll_delta);
@@ skipping 21 matching lines @@
   scroll_layer->SetTransform(scale_transform);
 
   gfx::Size surface_size(50, 50);
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   // Scroll down in screen coordinates with a gesture.
   gfx::Vector2d scroll_delta(0, 10);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // The layer should have scrolled down in its local coordinates, but half the
   // amount.
   scoped_ptr<ScrollAndScaleSet> scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(),
                  scroll_layer->id(),
                  gfx::Vector2d(0, scroll_delta.y() / scale));
 
   // Reset and scroll down with the wheel.
   scroll_layer->SetScrollDelta(gfx::Vector2dF());
   gfx::Vector2d wheel_scroll_delta(0, 10);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), wheel_scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), wheel_scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   host_impl_->ScrollEnd();
 
   // It should apply the scale factor to the scroll delta for the wheel event.
   scroll_info = host_impl_->ProcessScrollDeltas();
   ExpectContains(*scroll_info.get(),
                  scroll_layer->id(),
                  wheel_scroll_delta);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollViewportRounding) {
@@ skipping 132 matching lines @@
   host_impl_->ScrollEnd();
 
   // Scrolling should be relative to the offset as returned by the delegate.
   gfx::Vector2dF scroll_delta(0.f, 10.f);
   gfx::ScrollOffset current_offset(7.f, 8.f);
 
   scroll_delegate.set_getter_return_value(current_offset);
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
 
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(ScrollOffsetWithDelta(current_offset, scroll_delta),
             scroll_delegate.last_set_scroll_offset());
 
   current_offset = gfx::ScrollOffset(42.f, 41.f);
   scroll_delegate.set_getter_return_value(current_offset);
-  host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+  host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(current_offset + gfx::ScrollOffset(scroll_delta),
             scroll_delegate.last_set_scroll_offset());
   host_impl_->ScrollEnd();
   scroll_delegate.set_getter_return_value(gfx::ScrollOffset());
 
   // Forces a full tree synchronization and ensures that the scroll delegate
   // sees the correct size of the new tree.
   gfx::Size new_size(42, 24);
   host_impl_->CreatePendingTree();
   CreateScrollAndContentsLayers(host_impl_->pending_tree(), new_size);
@@ skipping 54 matching lines @@
   InputHandlerScrollResult scroll_result;
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
   DrawFrame();
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
 
   // In-bounds scrolling does not affect overscroll.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_FALSE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
 
   // Overscroll events are reflected immediately.
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 50));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 50),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, 10), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, 10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
   // In-bounds scrolling resets accumulated overscroll for the scrolled axes.
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -50));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -50),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_FALSE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, 0), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_FALSE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, -10), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, -10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, 0));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, 0),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_FALSE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, 0), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, -10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-15, 0));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(-15, 0),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(-5, 0), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(-5, -10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 60));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 60),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, 10), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(-5, 10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, -60));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(10, -60),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, -10), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, -10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
   // Overscroll accumulates within the scope of ScrollBegin/ScrollEnd as long
   // as no scroll occurs.
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_FALSE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, -20), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, -30), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_FALSE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, -20), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, -50), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
   // Overscroll resets on valid scroll.
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_FALSE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, 0), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, 0), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
-  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20));
+  scroll_result = host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -20),
+                                       InputHandler::RAILS_MODE_FREE);
   EXPECT_TRUE(scroll_result.did_scroll);
   EXPECT_TRUE(scroll_result.did_overscroll_root);
   EXPECT_EQ(gfx::Vector2dF(0, -10), scroll_result.unused_scroll_delta);
   EXPECT_EQ(gfx::Vector2dF(0, -10), host_impl_->accumulated_root_overscroll());
   EXPECT_EQ(scroll_result.accumulated_root_overscroll,
             host_impl_->accumulated_root_overscroll());
 
   host_impl_->ScrollEnd();
 }
 
@@ skipping 24 matching lines @@
   grand_child_layer->PushScrollOffsetFromMainThread(gfx::ScrollOffset(0, 2));
   host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, -10);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(),
                                       InputHandler::NON_BUBBLING_GESTURE));
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
 
     // The next time we scroll we should only scroll the parent, but overscroll
     // should still not reach the root layer.
     scroll_delta = gfx::Vector2d(0, -30);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::NON_BUBBLING_GESTURE));
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child_layer);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
 
     // After scrolling the parent, another scroll on the opposite direction
     // should scroll the child.
     scroll_delta = gfx::Vector2d(0, 70);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5),
                                       InputHandler::NON_BUBBLING_GESTURE));
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child_layer);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollChildEventBubbling) {
   // When we try to scroll a non-scrollable child layer, the scroll delta
   // should be applied to one of its ancestors if possible. Overscroll should
   // be reflected only when it has bubbled up to the root scrolling layer.
@@ skipping 16 matching lines @@
   host_impl_->SetViewportSize(surface_size);
   host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 1,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     gfx::Vector2d scroll_delta(0, 8);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF(0, 6), host_impl_->accumulated_root_overscroll());
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF(0, 14), host_impl_->accumulated_root_overscroll());
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, OverscrollAlways) {
   LayerTreeSettings settings;
   CreateHostImpl(settings, CreateOutputSurface());
 
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(50, 50));
   LayerImpl* clip_layer = scroll_layer->parent()->parent();
   clip_layer->SetBounds(gfx::Size(50, 50));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   host_impl_->active_tree()->PushPageScaleFromMainThread(1.f, 0.5f, 4.f);
   DrawFrame();
   EXPECT_EQ(gfx::Vector2dF(), host_impl_->accumulated_root_overscroll());
 
   // Even though the layer can't scroll the overscroll still happens.
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
-  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+  host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                       InputHandler::RAILS_MODE_FREE);
   EXPECT_EQ(gfx::Vector2dF(0, 10), host_impl_->accumulated_root_overscroll());
 }
 
 TEST_F(LayerTreeHostImplTest, NoOverscrollOnFractionalDeviceScale) {
   gfx::Size surface_size(980, 1439);
   gfx::Size content_size(980, 1438);
   float device_scale_factor = 1.5f;
   scoped_ptr<LayerImpl> root_clip =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   root_clip->SetHasRenderSurface(true);
@@ skipping 17 matching lines @@
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 1,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     // Horizontal & Vertical GlowEffect should not be applied when
     // content size is less then view port size. For Example Horizontal &
     // vertical GlowEffect should not be applied in about:blank page.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, -1));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, -1),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
 
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, NoOverscrollWhenNotAtEdge) {
   gfx::Size surface_size(100, 100);
   gfx::Size content_size(200, 200);
@@ skipping 16 matching lines @@
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 3, 1,
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     // Edge glow effect should be applicable only upon reaching Edges
     // of the content. unnecessary glow effect calls shouldn't be
     // called while scrolling up without reaching the edge of the content.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, 100));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, 100),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, -2.30f));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, -2.30f),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
     host_impl_->ScrollEnd();
     // unusedrootDelta should be subtracted from applied delta so that
     // unwanted glow effect calls are not called.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(0, 0),
                                       InputHandler::NON_BUBBLING_GESTURE));
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, 20));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0, 20),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF(0.000000f, 17.699997f).ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
 
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.02f, -0.01f));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(0.02f, -0.01f),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF(0.000000f, 17.699997f).ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
     host_impl_->ScrollEnd();
     // TestCase to check  kEpsilon, which prevents minute values to trigger
     // gloweffect without reaching edge.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(0, 0), InputHandler::WHEEL));
-    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(-0.12f, 0.1f));
+    host_impl_->ScrollBy(gfx::Point(), gfx::Vector2dF(-0.12f, 0.1f),
+                         InputHandler::RAILS_MODE_FREE);
     EXPECT_EQ(gfx::Vector2dF().ToString(),
               host_impl_->accumulated_root_overscroll().ToString());
     host_impl_->ScrollEnd();
   }
 }
 
 class BlendStateCheckLayer : public LayerImpl {
  public:
   static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl,
                                       int id,
@@ skipping 2499 matching lines @@
                                                       Layer::INVALID_ID);
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
 
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
     gfx::Vector2d scroll_delta(0, 100);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
 
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // Only the child should have scrolled.
     ASSERT_EQ(1u, scroll_info->scrolls.size());
     ExpectNone(*scroll_info.get(), root_id);
   }
@@ skipping 25 matching lines @@
   DrawFrame();
   {
     scoped_ptr<ScrollAndScaleSet> scroll_info;
     LayerImpl* child =
         host_impl_->active_tree()->root_layer()->children()[0]->children()[0];
     LayerImpl* grand_child = child->children()[0];
 
     gfx::Vector2d scroll_delta(0, -2);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
 
     // The grand child should have scrolled up to its limit.
     scroll_info = host_impl_->ProcessScrollDeltas();
     ASSERT_EQ(1u, scroll_info->scrolls.size());
     ExpectContains(*scroll_info, grand_child->id(), scroll_delta);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
 
     // The child should have received the bubbled delta, but the locked
     // scrolling layer should remain set as the grand child.
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
     scroll_info = host_impl_->ProcessScrollDeltas();
     ASSERT_EQ(2u, scroll_info->scrolls.size());
     ExpectContains(*scroll_info, grand_child->id(), scroll_delta);
     ExpectContains(*scroll_info, child->id(), scroll_delta);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), grand_child);
 
     // The first |ScrollBy| after the fling should re-lock the scrolling
     // layer to the first layer that scrolled, which is the child.
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child);
 
     // The child should have scrolled up to its limit.
     scroll_info = host_impl_->ProcessScrollDeltas();
     ASSERT_EQ(2u, scroll_info->scrolls.size());
     ExpectContains(*scroll_info, grand_child->id(), scroll_delta);
     ExpectContains(*scroll_info, child->id(), scroll_delta + scroll_delta);
 
     // As the locked layer is at it's limit, no further scrolling can occur.
-    EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_FALSE(
+        host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                             InputHandler::RAILS_MODE_FREE).did_scroll);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child);
     host_impl_->ScrollEnd();
   }
 }
 
 TEST_F(LayerTreeHostImplTest, WheelFlingShouldBubble) {
   // When flinging via wheel, the root should eventually scroll (we should
   // bubble).
   gfx::Size surface_size(10, 10);
   gfx::Size content_size(20, 20);
@@ skipping 13 matching lines @@
   host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
   host_impl_->active_tree()->DidBecomeActive();
   DrawFrame();
   {
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
     gfx::Vector2d scroll_delta(0, 100);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
 
     host_impl_->ScrollEnd();
 
     scoped_ptr<ScrollAndScaleSet> scroll_info =
         host_impl_->ProcessScrollDeltas();
 
     // The root should have scrolled.
     ASSERT_EQ(2u, scroll_info->scrolls.size());
     ExpectContains(*scroll_info.get(), root_scroll_id, gfx::Vector2d(0, 10));
   }
@@ skipping 378 matching lines @@
         new SimpleSwapPromiseMonitor(NULL,
                                      host_impl_.get(),
                                      &set_needs_commit_count,
                                      &set_needs_redraw_count,
                                      &forward_to_main_count));
     LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
     // Scrolling normally should not trigger any forwarding.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-    EXPECT_TRUE(
-        host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
     host_impl_->ScrollEnd();
 
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(1, set_needs_redraw_count);
     EXPECT_EQ(0, forward_to_main_count);
 
     // Scrolling with a scroll handler should defer the swap to the main
     // thread.
     scroll_layer->SetHaveScrollEventHandlers(true);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-    EXPECT_TRUE(
-        host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10),
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
     host_impl_->ScrollEnd();
 
     EXPECT_EQ(0, set_needs_commit_count);
     EXPECT_EQ(2, set_needs_redraw_count);
     EXPECT_EQ(1, forward_to_main_count);
   }
 }
 
 class LayerTreeHostImplWithTopControlsTest : public LayerTreeHostImplTest {
  public:
@@ skipping 60 matching lines @@
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Scroll just the top controls and verify that the scroll succeeds.
   const float residue = 10;
   float offset = top_controls_height_ - residue;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_FLOAT_EQ(-offset,
                   host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Scroll across the boundary
   const float content_scroll = 20;
   offset = residue + content_scroll;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(-top_controls_height_,
             host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, content_scroll).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Now scroll back to the top of the content
   offset = -content_scroll;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(-top_controls_height_,
             host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // And scroll the top controls completely into view
   offset = -top_controls_height_;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // And attempt to scroll past the end
-  EXPECT_FALSE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                    InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   host_impl_->ScrollEnd();
 }
 
 TEST_F(LayerTreeHostImplWithTopControlsTest, TopControlsAnimationAtOrigin) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(100, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 200));
   host_impl_->top_controls_manager()->UpdateTopControlsState(
       BOTH, SHOWN, false);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Scroll the top controls partially.
   const float residue = 35;
   float offset = top_controls_height_ - residue;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_FLOAT_EQ(-offset,
                   host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   did_request_redraw_ = false;
   did_request_animate_ = false;
   did_request_commit_ = false;
 
   // End the scroll while the controls are still offset from their limit.
@@ skipping 49 matching lines @@
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Scroll the top controls partially.
   const float residue = 15;
   float offset = top_controls_height_ - residue;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_FLOAT_EQ(-offset,
                   host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   did_request_redraw_ = false;
   did_request_animate_ = false;
   did_request_commit_ = false;
 
   // End the scroll while the controls are still offset from the limit.
@@ skipping 42 matching lines @@
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Scroll the top controls partially.
   const float residue = 15;
   float offset = top_controls_height_ - residue;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_FLOAT_EQ(-offset,
                   host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF(0, initial_scroll_offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   did_request_redraw_ = false;
   did_request_animate_ = false;
   did_request_commit_ = false;
 
   // End the fling while the controls are still offset from the limit.
@@ skipping 36 matching lines @@
   host_impl_->SetViewportSize(gfx::Size(100, 100));
   host_impl_->top_controls_manager()->UpdateTopControlsState(BOTH, SHOWN,
                                                              false);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
 
   float offset = 50;
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(-offset, host_impl_->top_controls_manager()->ControlsTopOffset());
   EXPECT_EQ(gfx::Vector2dF().ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
 
   // Should have fully scrolled
   EXPECT_EQ(gfx::Vector2dF(0, scroll_layer->MaxScrollOffset().y()).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   float overscrollamount = 10;
 
   // Overscroll the content
-  EXPECT_FALSE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, overscrollamount))
-          .did_scroll);
+  EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(),
+                                    gfx::Vector2d(0, overscrollamount),
+                                    InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, 2 * offset).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
   EXPECT_EQ(gfx::Vector2dF(0, overscrollamount).ToString(),
             host_impl_->accumulated_root_overscroll().ToString());
 
-  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -2 * offset))
-                  .did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -2 * offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, 0).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
   EXPECT_EQ(-offset, host_impl_->top_controls_manager()->ControlsTopOffset());
 
-  EXPECT_TRUE(
-      host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -offset)).did_scroll);
+  EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, -offset),
+                                   InputHandler::RAILS_MODE_FREE).did_scroll);
   EXPECT_EQ(gfx::Vector2dF(0, 0).ToString(),
             scroll_layer->CurrentScrollOffset().ToString());
 
   // Top controls should be fully visible
   EXPECT_EQ(0, host_impl_->top_controls_manager()->ControlsTopOffset());
 
   host_impl_->ScrollEnd();
 }
 
 class LayerTreeHostImplVirtualViewportTest : public LayerTreeHostImplTest {
@@ skipping 76 matching lines @@
     gfx::Vector2dF outer_expected;
     EXPECT_VECTOR_EQ(inner_expected, inner_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(outer_expected, outer_scroll->CurrentScrollOffset());
 
     // Make sure the fling goes to the outer viewport first
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
     gfx::Vector2d scroll_delta(inner_viewport.width(), inner_viewport.height());
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     outer_expected += gfx::Vector2dF(scroll_delta.x(), scroll_delta.y());
 
     host_impl_->ScrollEnd();
 
     EXPECT_VECTOR_EQ(inner_expected, inner_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(outer_expected, outer_scroll->CurrentScrollOffset());
 
     // Fling past the outer viewport boundry, make sure inner viewport scrolls.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     outer_expected += gfx::Vector2dF(scroll_delta.x(), scroll_delta.y());
 
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     inner_expected += gfx::Vector2dF(scroll_delta.x(), scroll_delta.y());
 
     host_impl_->ScrollEnd();
 
     EXPECT_VECTOR_EQ(inner_expected, inner_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(outer_expected, outer_scroll->CurrentScrollOffset());
   }
 }
 
 TEST_F(LayerTreeHostImplVirtualViewportTest,
@@ skipping 13 matching lines @@
     EXPECT_VECTOR_EQ(inner_expected, inner_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(outer_expected, outer_scroll->CurrentScrollOffset());
 
     // Make sure the scroll goes to the outer viewport first.
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
 
     // Scroll near the edge of the outer viewport.
     gfx::Vector2d scroll_delta(inner_viewport.width(), inner_viewport.height());
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     outer_expected += scroll_delta;
 
     EXPECT_VECTOR_EQ(inner_expected, inner_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(outer_expected, outer_scroll->CurrentScrollOffset());
 
     // Now diagonal scroll across the outer viewport boundary in a single event.
     // The entirety of the scroll should be consumed, as bubbling between inner
     // and outer viewport layers is perfect.
-    host_impl_->ScrollBy(gfx::Point(), gfx::ScaleVector2d(scroll_delta, 2));
+    host_impl_->ScrollBy(gfx::Point(), gfx::ScaleVector2d(scroll_delta, 2),
+                         InputHandler::RAILS_MODE_FREE);
     outer_expected += scroll_delta;
     inner_expected += scroll_delta;
     host_impl_->ScrollEnd();
 
     EXPECT_VECTOR_EQ(inner_expected, inner_scroll->CurrentScrollOffset());
     EXPECT_VECTOR_EQ(outer_expected, outer_scroll->CurrentScrollOffset());
   }
 }
 
 TEST_F(LayerTreeHostImplVirtualViewportTest,
@@ skipping 12 matching lines @@
   LayerImpl* child_scroll = child.get();
   outer_scroll->children()[0]->AddChild(child.Pass());
 
   DrawFrame();
   {
     scoped_ptr<ScrollAndScaleSet> scroll_info;
 
     gfx::Vector2d scroll_delta(0, inner_viewport.height());
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::GESTURE));
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
 
     // The child should have scrolled up to its limit.
     scroll_info = host_impl_->ProcessScrollDeltas();
     ASSERT_EQ(1u, scroll_info->scrolls.size());
     ExpectContains(*scroll_info, child_scroll->id(), scroll_delta);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), child_scroll);
 
     // The first |ScrollBy| after the fling should re-lock the scrolling
     // layer to the first layer that scrolled, the inner viewport scroll layer.
     EXPECT_EQ(InputHandler::SCROLL_STARTED, host_impl_->FlingScrollBegin());
-    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_TRUE(host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                                     InputHandler::RAILS_MODE_FREE).did_scroll);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), inner_scroll);
 
     // The inner viewport should have scrolled up to its limit.
     scroll_info = host_impl_->ProcessScrollDeltas();
     ASSERT_EQ(2u, scroll_info->scrolls.size());
     ExpectContains(*scroll_info, child_scroll->id(), scroll_delta);
     ExpectContains(*scroll_info, inner_scroll->id(), scroll_delta);
 
     // As the locked layer is at its limit, no further scrolling can occur.
-    EXPECT_FALSE(host_impl_->ScrollBy(gfx::Point(), scroll_delta).did_scroll);
+    EXPECT_FALSE(
+        host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                             InputHandler::RAILS_MODE_FREE).did_scroll);
     EXPECT_EQ(host_impl_->CurrentlyScrollingLayer(), inner_scroll);
     host_impl_->ScrollEnd();
   }
 }
 
 class LayerTreeHostImplWithImplicitLimitsTest : public LayerTreeHostImplTest {
  public:
   void SetUp() override {
     LayerTreeSettings settings = DefaultSettings();
     settings.max_memory_for_prepaint_percentage = 50;
@@ skipping 421 matching lines @@
     host_impl_->PinchGestureBegin();
     host_impl_->PinchGestureUpdate(page_scale_delta, gfx::Point());
     host_impl_->PinchGestureEnd();
     host_impl_->ScrollEnd();
 
     gfx::Vector2dF scroll_delta(0, 5);
     EXPECT_EQ(InputHandler::SCROLL_STARTED,
               host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
     EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->CurrentScrollOffset());
 
-    host_impl_->ScrollBy(gfx::Point(), scroll_delta);
+    host_impl_->ScrollBy(gfx::Point(), scroll_delta,
+                         InputHandler::RAILS_MODE_FREE);
     host_impl_->ScrollEnd();
     EXPECT_VECTOR_EQ(gfx::Vector2dF(0, 2.5),
                      scroll_layer->CurrentScrollOffset());
   }
 }
 
 class LayerTreeHostImplCountingLostSurfaces : public LayerTreeHostImplTest {
  public:
   LayerTreeHostImplCountingLostSurfaces() : num_lost_surfaces_(0) {}
   void DidLoseOutputSurfaceOnImplThread() override { num_lost_surfaces_++; }
 
  protected:
   int num_lost_surfaces_;
 };
 
 TEST_F(LayerTreeHostImplCountingLostSurfaces, TwiceLostSurface) {
   // Really we just need at least one client notification each time
   // we go from having a valid output surface to not having a valid output
   // surface.
   EXPECT_EQ(0, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_EQ(1, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_LE(1, num_lost_surfaces_);
 }
 
 }  // namespace
 }  // namespace cc