use enum to specify deviceSource for fling animation.

content/renderer/input/input_handler_proxy_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/input/input_handler_proxy.h"
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/swap_promise_monitor.h"
 #include "content/common/input/did_overscroll_params.h"
 #include "content/renderer/input/input_handler_proxy_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebFloatPoint.h"
 #include "third_party/WebKit/public/platform/WebFloatSize.h"
 #include "third_party/WebKit/public/platform/WebGestureCurve.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/events/latency_info.h"
 
 using blink::WebActiveWheelFlingParameters;
 using blink::WebFloatPoint;
 using blink::WebFloatSize;
+using blink::WebGestureDevice;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseWheelEvent;
 using blink::WebPoint;
 using blink::WebSize;
 using blink::WebTouchEvent;
 using blink::WebTouchPoint;
 
 namespace content {
 namespace {
 
 double InSecondsF(const base::TimeTicks& time) {
   return (time - base::TimeTicks()).InSecondsF();
 }
 
 WebGestureEvent CreateFling(base::TimeTicks timestamp,
-                            WebGestureEvent::SourceDevice source_device,
+                            WebGestureDevice source_device,
                             WebFloatPoint velocity,
                             WebPoint point,
                             WebPoint global_point,
                             int modifiers) {
   WebGestureEvent fling;
   fling.type = WebInputEvent::GestureFlingStart;
   fling.sourceDevice = source_device;
   fling.timeStampSeconds = (timestamp - base::TimeTicks()).InSecondsF();
   fling.data.flingStart.velocityX = velocity.x;
   fling.data.flingStart.velocityY = velocity.y;
   fling.x = point.x;
   fling.y = point.y;
   fling.globalX = global_point.x;
   fling.globalY = global_point.y;
   fling.modifiers = modifiers;
   return fling;
 }
 
-WebGestureEvent CreateFling(WebGestureEvent::SourceDevice source_device,
+WebGestureEvent CreateFling(WebGestureDevice source_device,
                             WebFloatPoint velocity,
                             WebPoint point,
                             WebPoint global_point,
                             int modifiers) {
   return CreateFling(base::TimeTicks(),
                      source_device,
                      velocity,
                      point,
                      global_point,
                      modifiers);
@@ skipping 87 matching lines @@
  public:
   MockInputHandlerProxyClient() {}
   virtual ~MockInputHandlerProxyClient() {}
 
   virtual void WillShutdown() OVERRIDE {}
 
   MOCK_METHOD1(TransferActiveWheelFlingAnimation,
                void(const WebActiveWheelFlingParameters&));
 
   virtual blink::WebGestureCurve* CreateFlingAnimationCurve(
-      int deviceSource,
+      WebGestureDevice deviceSource,
       const WebFloatPoint& velocity,
       const WebSize& cumulative_scroll) OVERRIDE {
     return new FakeWebGestureCurve(
         blink::WebFloatSize(velocity.x, velocity.y),
         blink::WebFloatSize(cumulative_scroll.width, cumulative_scroll.height));
   }
 
   MOCK_METHOD1(DidOverscroll, void(const DidOverscrollParams&));
   virtual void DidStopFlinging() OVERRIDE {}
 
@@ skipping 25 matching lines @@
 // This is defined as a macro because when an expectation is not satisfied the
 // only output you get
 // out of gmock is the line number that set the expectation.
 #define VERIFY_AND_RESET_MOCKS()                                              \
   do {                                                                        \
     testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);          \
     testing::Mock::VerifyAndClearExpectations(&mock_client_);                 \
   } while (false)
 
   void StartFling(base::TimeTicks timestamp,
-                  WebGestureEvent::SourceDevice source_device,
+                  WebGestureDevice source_device,
                   WebFloatPoint velocity,
                   WebPoint position) {
     expected_disposition_ = InputHandlerProxy::DID_HANDLE;
     VERIFY_AND_RESET_MOCKS();
 
     EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
         .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
     gesture_.type = WebInputEvent::GestureScrollBegin;
     gesture_.sourceDevice = source_device;
     EXPECT_EQ(expected_disposition_,
@@ skipping 254 matching lines @@
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
 
   gesture_.type = WebInputEvent::GestureFlingStart;
   gesture_.data.flingStart.velocityX = 10;
-  gesture_.sourceDevice = WebGestureEvent::Touchpad;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Verify that a GestureFlingCancel during an animation cancels it.
   gesture_.type = WebInputEvent::GestureFlingCancel;
-  gesture_.sourceDevice = WebGestureEvent::Touchpad;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingOnMainThreadTouchpad) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollOnMainThread));
 
   gesture_.type = WebInputEvent::GestureFlingStart;
-  gesture_.sourceDevice = WebGestureEvent::Touchpad;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // Since we returned ScrollStatusOnMainThread from scrollBegin, ensure the
   // input handler knows it's scrolling off the impl thread
   ASSERT_FALSE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
 
   VERIFY_AND_RESET_MOCKS();
 
   // Even if we didn't start a fling ourselves, we still need to send the cancel
   // event to the widget.
   gesture_.type = WebInputEvent::GestureFlingCancel;
-  gesture_.sourceDevice = WebGestureEvent::Touchpad;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingIgnoredTouchpad) {
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollIgnored));
 
   gesture_.type = WebInputEvent::GestureFlingStart;
-  gesture_.sourceDevice = WebGestureEvent::Touchpad;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   // Since the previous fling was ignored, we should also be dropping the next
   // fling_cancel.
   gesture_.type = WebInputEvent::GestureFlingCancel;
-  gesture_.sourceDevice = WebGestureEvent::Touchpad;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchpad;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingAnimatesTouchpad) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   gesture_.type = WebInputEvent::GestureFlingStart;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
-  gesture_ = CreateFling(WebGestureEvent::Touchpad,
+  gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
@@ skipping 84 matching lines @@
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // Start a gesture fling in the -X direction with zero Y movement.
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for trackpad, wheel events with the Control modifier are
   // special (reserved for zoom), so don't set that here.
   int modifiers = WebInputEvent::ShiftKey | WebInputEvent::AltKey;
-  gesture_ = CreateFling(WebGestureEvent::Touchpad,
+  gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
@@ skipping 80 matching lines @@
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
   input_handler_->MainThreadHasStoppedFlinging();
 
   // Start a second gesture fling, this time in the +Y direction with no X.
   fling_delta = WebFloatPoint(0, -1000);
   fling_point = WebPoint(95, 87);
   fling_global_point = WebPoint(32, 71);
   modifiers = WebInputEvent::AltKey;
-  gesture_ = CreateFling(WebGestureEvent::Touchpad,
+  gesture_ = CreateFling(blink::WebGestureDeviceTouchpad,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
@@ skipping 51 matching lines @@
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingStartedTouchscreen) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
 
   gesture_.type = WebInputEvent::GestureFlingStart;
   gesture_.data.flingStart.velocityX = 10;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
 
   // Verify that a GestureFlingCancel during an animation cancels it.
   gesture_.type = WebInputEvent::GestureFlingCancel;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingOnMainThreadTouchscreen) {
   // We should send all events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_NOT_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollOnMainThread));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin()).Times(0);
 
   gesture_.type = WebInputEvent::GestureFlingStart;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Even if we didn't start a fling ourselves, we still need to send the cancel
   // event to the widget.
   gesture_.type = WebInputEvent::GestureFlingCancel;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingIgnoredTouchscreen) {
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   expected_disposition_ = InputHandlerProxy::DROP_EVENT;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollIgnored));
 
   gesture_.type = WebInputEvent::GestureFlingStart;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Even if we didn't start a fling ourselves, we still need to send the cancel
   // event to the widget.
   gesture_.type = WebInputEvent::GestureFlingCancel;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingAnimatesTouchscreen) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   // Note that for touchscreen the control modifier is not special.
   int modifiers = WebInputEvent::ControlKey;
-  gesture_ = CreateFling(WebGestureEvent::Touchscreen,
+  gesture_ = CreateFling(blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
@@ skipping 26 matching lines @@
 
 TEST_F(InputHandlerProxyTest, GestureFlingWithValidTimestamp) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   int modifiers = WebInputEvent::ControlKey;
   gesture_ = CreateFling(time,
-                         WebGestureEvent::Touchscreen,
+                         blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
@@ skipping 19 matching lines @@
 
 TEST_F(InputHandlerProxyTest, GestureFlingWithInvalidTimestamp) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta start_time_offset = base::TimeDelta::FromMilliseconds(10);
   gesture_.type = WebInputEvent::GestureFlingStart;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   int modifiers = WebInputEvent::ControlKey;
   gesture_.timeStampSeconds = start_time_offset.InSecondsF();
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   gesture_.x = fling_point.x;
   gesture_.y = fling_point.y;
   gesture_.globalX = fling_global_point.x;
   gesture_.globalY = fling_global_point.y;
   gesture_.modifiers = modifiers;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
@@ skipping 42 matching lines @@
 
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   int modifiers = WebInputEvent::ControlKey | WebInputEvent::AltKey;
-  gesture_ = CreateFling(WebGestureEvent::Touchscreen,
+  gesture_ = CreateFling(blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   // |gesture_scroll_on_impl_thread_| should still be true after
@@ skipping 100 matching lines @@
 
 TEST_F(InputHandlerProxyTest, GestureFlingNotCancelledBySmallTimeDelta) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   int modifiers = WebInputEvent::ControlKey;
   gesture_ = CreateFling(time,
-                         WebGestureEvent::Touchscreen,
+                         blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
@@ skipping 41 matching lines @@
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingCancelledAfterBothAxesStopScrolling) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   gesture_.type = WebInputEvent::GestureFlingStart;
   WebFloatPoint fling_delta = WebFloatPoint(100, 100);
   gesture_.data.flingStart.velocityX = fling_delta.x;
   gesture_.data.flingStart.velocityY = fling_delta.y;
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
@@ skipping 121 matching lines @@
 }
 
 TEST_F(InputHandlerProxyTest, GestureFlingCancelledByKeyboardEvent) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
 
   // Keyboard events received during a scroll should have no effect.
   WebKeyboardEvent key_event;
   key_event.type = WebInputEvent::KeyDown;
   EXPECT_EQ(InputHandlerProxy::DID_NOT_HANDLE,
             input_handler_->HandleInputEvent(key_event));
   EXPECT_TRUE(input_handler_->gesture_scroll_on_impl_thread_for_testing());
@@ skipping 32 matching lines @@
 
 TEST_F(InputHandlerProxyTest, GestureFlingWithNegativeTimeDelta) {
   // We shouldn't send any events to the widget for this gesture.
   expected_disposition_ = InputHandlerProxy::DID_HANDLE;
   VERIFY_AND_RESET_MOCKS();
 
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   gesture_.type = WebInputEvent::GestureScrollBegin;
-  gesture_.sourceDevice = WebGestureEvent::Touchscreen;
+  gesture_.sourceDevice = blink::WebGestureDeviceTouchscreen;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // On the fling start, we should schedule an animation but not actually start
   // scrolling.
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(100, 0);
   WebPoint fling_point = WebPoint(7, 13);
   WebPoint fling_global_point = WebPoint(17, 23);
   int modifiers = WebInputEvent::ControlKey;
   gesture_ = CreateFling(time,
-                         WebGestureEvent::Touchscreen,
+                         blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_global_point,
                          modifiers);
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_, FlingScrollBegin())
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   testing::Mock::VerifyAndClearExpectations(&mock_input_handler_);
@@ skipping 26 matching lines @@
   gesture_.type = WebInputEvent::GestureFlingCancel;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 }
 
 TEST_F(InputHandlerProxyTest, FlingBoost) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   base::TimeTicks last_animate_time = time;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
-  StartFling(time, WebGestureEvent::Touchscreen, fling_delta, fling_point);
+  StartFling(
+      time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Now cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
@@ skipping 42 matching lines @@
       .WillOnce(testing::Return(true));
   input_handler_->Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // GestureFlingStart in the same direction and at sufficient speed should
   // boost the active fling.
 
   gesture_ = CreateFling(time,
-                         WebGestureEvent::Touchscreen,
+                         blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_point,
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   time += dt;
   // Note we get *2x* as much delta because 2 flings have combined.
   expected_delta = 2 * (time - last_animate_time).InSecondsF() * -fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
                        testing::Property(&gfx::Vector2dF::x,
                                          testing::Eq(expected_delta))))
       .WillOnce(testing::Return(true));
   input_handler_->Animate(time);
   last_animate_time = time;
 
   VERIFY_AND_RESET_MOCKS();
 
   // Repeated GestureFlingStarts should accumulate.
 
   CancelFling(time);
   gesture_ = CreateFling(time,
-                         WebGestureEvent::Touchscreen,
+                         blink::WebGestureDeviceTouchscreen,
                          fling_delta,
                          fling_point,
                          fling_point,
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
   VERIFY_AND_RESET_MOCKS();
 
   time += dt;
   // Note we get *3x* as much delta because 3 flings have combined.
   expected_delta = 3 * (time - last_animate_time).InSecondsF() * -fling_delta.x;
@@ skipping 23 matching lines @@
   input_handler_->Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfScrollTargetsDifferentLayer) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
-  StartFling(time, WebGestureEvent::Touchscreen, fling_delta, fling_point);
+  StartFling(
+      time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // If the GestureScrollBegin targets a different layer, the fling should be
   // cancelled and the scroll should be handled as usual.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
       .WillOnce(testing::Return(false));
   EXPECT_CALL(mock_input_handler_, ScrollEnd());
   EXPECT_CALL(mock_input_handler_, ScrollBegin(testing::_, testing::_))
       .WillOnce(testing::Return(cc::InputHandler::ScrollStarted));
 
   time += dt;
   gesture_.timeStampSeconds = InSecondsF(time);
   gesture_.type = WebInputEvent::GestureScrollBegin;
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfScrollDelayed) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
-  StartFling(time, WebGestureEvent::Touchscreen, fling_delta, fling_point);
+  StartFling(
+      time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
@@ skipping 15 matching lines @@
   input_handler_->Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfScrollInDifferentDirection) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
-  StartFling(time, WebGestureEvent::Touchscreen, fling_delta, fling_point);
+  StartFling(
+      time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // The GestureScrollBegin should be swallowed by the fling if it hits the same
   // scrolling layer.
   EXPECT_CALL(mock_input_handler_,
               IsCurrentlyScrollingLayerAt(testing::_, testing::_))
@@ skipping 23 matching lines @@
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 TEST_F(InputHandlerProxyTest, NoFlingBoostIfFlingTooSlow) {
   base::TimeDelta dt = base::TimeDelta::FromMilliseconds(10);
   base::TimeTicks time = base::TimeTicks() + dt;
   WebFloatPoint fling_delta = WebFloatPoint(1000, 0);
   WebPoint fling_point = WebPoint(7, 13);
-  StartFling(time, WebGestureEvent::Touchscreen, fling_delta, fling_point);
+  StartFling(
+      time, blink::WebGestureDeviceTouchscreen, fling_delta, fling_point);
 
   // Cancel the fling.  The fling cancellation should be deferred to allow
   // fling boosting events to arrive.
   time += dt;
   CancelFling(time);
 
   // If the new fling is too slow, no boosting should take place, with the new
   // fling replacing the old.
   WebFloatPoint small_fling_delta = WebFloatPoint(100, 0);
   gesture_ = CreateFling(time,
-                         WebGestureEvent::Touchscreen,
+                         blink::WebGestureDeviceTouchscreen,
                          small_fling_delta,
                          fling_point,
                          fling_point,
                          0);
   EXPECT_EQ(expected_disposition_, input_handler_->HandleInputEvent(gesture_));
 
   VERIFY_AND_RESET_MOCKS();
 
   // Note that the new fling delta uses the *slow*, unboosted fling velocity.
   time += dt;
   float expected_delta = dt.InSecondsF() * -small_fling_delta.x;
   EXPECT_CALL(mock_input_handler_, SetNeedsAnimate());
   EXPECT_CALL(mock_input_handler_,
               ScrollBy(testing::_,
                        testing::Property(&gfx::Vector2dF::x,
                                          testing::Eq(expected_delta))))
       .WillOnce(testing::Return(true));
   input_handler_->Animate(time);
 
   VERIFY_AND_RESET_MOCKS();
 }
 
 } // namespace
 } // namespace content