cc: Add a rails argument to InputHandler::ScrollBy

content/renderer/input/input_handler_proxy.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/input/input_handler_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 150 matching lines @@
             "Event.Latency.RendererImpl.GestureFlingStart",
             delta.InMicroseconds(), 1, 1000000, 100);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
+cc::InputHandler::RailsMode ConvertRailsMode(
+    blink::WebInputEvent::RailsMode rails_mode) {
+  switch (rails_mode) {
+    case blink::WebInputEvent::RailsModeFree:
+      return cc::InputHandler::RAILS_MODE_FREE;
+    case blink::WebInputEvent::RailsModeHorizontal:
+      return cc::InputHandler::RAILS_MODE_HORIZONTAL;
+    case blink::WebInputEvent::RailsModeVertical:
+      return cc::InputHandler::RAILS_MODE_VERTICAL;
+    default:
+      NOTREACHED();
+      break;
+  }
+  return cc::InputHandler::RAILS_MODE_FREE;
+}
+
 }  // namespace
 
 namespace content {
 
 InputHandlerProxy::InputHandlerProxy(cc::InputHandler* input_handler,
                                      InputHandlerProxyClient* client)
     : client_(client),
       input_handler_(input_handler),
       deferred_fling_cancel_time_seconds_(0),
 #ifndef NDEBUG
@@ skipping 143 matching lines @@
       break;
   }
 
   return DID_NOT_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleMouseWheel(
     const WebMouseWheelEvent& wheel_event) {
   InputHandlerProxy::EventDisposition result = DID_NOT_HANDLE;
   cc::InputHandlerScrollResult scroll_result;
-
-  // TODO(ccameron): The rail information should be pushed down into
-  // InputHandler.
-  gfx::Vector2dF scroll_delta(
-      wheel_event.railsMode != WebInputEvent::RailsModeVertical
-          ? -wheel_event.deltaX
-          : 0,
-      wheel_event.railsMode != WebInputEvent::RailsModeHorizontal
-          ? -wheel_event.deltaY
-          : 0);
+  const gfx::Vector2dF scroll_delta(-wheel_event.deltaX, -wheel_event.deltaY);
+  const cc::InputHandler::RailsMode rails_mode =
+      ConvertRailsMode(wheel_event.railsMode);
 
   if (wheel_event.scrollByPage) {
     // TODO(jamesr): We don't properly handle scroll by page in the compositor
     // thread, so punt it to the main thread. http://crbug.com/236639
     result = DID_NOT_HANDLE;
   } else if (!wheel_event.canScroll) {
     // Wheel events with |canScroll| == false will not trigger scrolling,
     // only event handlers.  Forward to the main thread.
     result = DID_NOT_HANDLE;
   } else if (smooth_scroll_enabled_) {
@@ skipping 13 matching lines @@
   } else {
     cc::InputHandler::ScrollStatus scroll_status = input_handler_->ScrollBegin(
         gfx::Point(wheel_event.x, wheel_event.y), cc::InputHandler::WHEEL);
     switch (scroll_status) {
       case cc::InputHandler::SCROLL_STARTED: {
         TRACE_EVENT_INSTANT2("input",
                              "InputHandlerProxy::handle_input wheel scroll",
                              TRACE_EVENT_SCOPE_THREAD, "deltaX",
                              scroll_delta.x(), "deltaY", scroll_delta.y());
         gfx::Point scroll_point(wheel_event.x, wheel_event.y);
-        scroll_result = input_handler_->ScrollBy(scroll_point, scroll_delta);
+        scroll_result =
+            input_handler_->ScrollBy(scroll_point, scroll_delta, rails_mode);
         HandleOverscroll(scroll_point, scroll_result);
         input_handler_->ScrollEnd();
         result = scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
         break;
       }
       case cc::InputHandler::SCROLL_IGNORED:
         // TODO(jamesr): This should be DROP_EVENT, but in cases where we fail
         // to properly sync scrollability it's safer to send the event to the
         // main thread. Change back to DROP_EVENT once we have synchronization
         // bugs sorted out.
@@ skipping 64 matching lines @@
   DCHECK(expect_scroll_update_end_);
 #endif
 
   if (!gesture_scroll_on_impl_thread_ && !gesture_pinch_on_impl_thread_)
     return DID_NOT_HANDLE;
 
   gfx::Point scroll_point(gesture_event.x, gesture_event.y);
   gfx::Vector2dF scroll_delta(-gesture_event.data.scrollUpdate.deltaX,
                               -gesture_event.data.scrollUpdate.deltaY);
   cc::InputHandlerScrollResult scroll_result = input_handler_->ScrollBy(
-      scroll_point, scroll_delta);
+      scroll_point, scroll_delta, cc::InputHandler::RAILS_MODE_FREE);
   HandleOverscroll(scroll_point, scroll_result);
   return scroll_result.did_scroll ? DID_HANDLE : DROP_EVENT;
 }
 
 InputHandlerProxy::EventDisposition InputHandlerProxy::HandleGestureScrollEnd(
   const WebGestureEvent& gesture_event) {
 #ifndef NDEBUG
   DCHECK(expect_scroll_update_end_);
   expect_scroll_update_end_ = false;
 #endif
@@ skipping 455 matching lines @@
                clipped_increment.height);
 
   bool did_scroll = false;
 
   switch (fling_parameters_.sourceDevice) {
     case blink::WebGestureDeviceTouchpad:
       did_scroll = TouchpadFlingScroll(clipped_increment);
       break;
     case blink::WebGestureDeviceTouchscreen: {
       clipped_increment = ToClientScrollIncrement(clipped_increment);
-      cc::InputHandlerScrollResult scroll_result = input_handler_->ScrollBy(
-          fling_parameters_.point, clipped_increment);
+      cc::InputHandlerScrollResult scroll_result =
+          input_handler_->ScrollBy(fling_parameters_.point, clipped_increment,
+                                   cc::InputHandler::RAILS_MODE_FREE);
       HandleOverscroll(fling_parameters_.point, scroll_result);
       did_scroll = scroll_result.did_scroll;
     } break;
   }
 
   if (did_scroll) {
     fling_parameters_.cumulativeScroll.width += clipped_increment.width;
     fling_parameters_.cumulativeScroll.height += clipped_increment.height;
   }
 
   // It's possible the provided |increment| is sufficiently small as to not
   // trigger a scroll, e.g., with a trivial time delta between fling updates.
   // Return true in this case to prevent early fling termination.
   if (std::abs(clipped_increment.width) < kScrollEpsilon &&
       std::abs(clipped_increment.height) < kScrollEpsilon)
     return true;
 
   return did_scroll;
 }
 
 }  // namespace content