use enum to specify deviceSource for fling animation.

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/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ skipping 341 matching lines @@
   }
 
   return DID_NOT_HANDLE;
 }
 
 InputHandlerProxy::EventDisposition
 InputHandlerProxy::HandleGestureFling(
     const WebGestureEvent& gesture_event) {
   cc::InputHandler::ScrollStatus scroll_status;
 
-  if (gesture_event.sourceDevice == WebGestureEvent::Touchpad) {
+  if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
     scroll_status = input_handler_->ScrollBegin(
         gfx::Point(gesture_event.x, gesture_event.y),
         cc::InputHandler::NonBubblingGesture);
   } else {
     if (!gesture_scroll_on_impl_thread_)
       scroll_status = cc::InputHandler::ScrollOnMainThread;
     else
       scroll_status = input_handler_->FlingScrollBegin();
   }
 
 #ifndef NDEBUG
   expect_scroll_update_end_ = false;
 #endif
 
   switch (scroll_status) {
     case cc::InputHandler::ScrollStarted: {
-      if (gesture_event.sourceDevice == WebGestureEvent::Touchpad)
+      if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad)
         input_handler_->ScrollEnd();
 
       const float vx = gesture_event.data.flingStart.velocityX;
       const float vy = gesture_event.data.flingStart.velocityY;
       current_fling_velocity_ = gfx::Vector2dF(vx, vy);
+      // TODO(rjkroege): Remove cast after landing 3rd patch for
+      // http://crbug.com/343327
       fling_curve_.reset(client_->CreateFlingAnimationCurve(
-          gesture_event.sourceDevice, WebFloatPoint(vx, vy), blink::WebSize()));
+          (blink::WebGestureDevice)gesture_event.sourceDevice,
+          WebFloatPoint(vx, vy),
+          blink::WebSize()));
       disallow_horizontal_fling_scroll_ = !vx;
       disallow_vertical_fling_scroll_ = !vy;
       TRACE_EVENT_ASYNC_BEGIN2("input",
                                "InputHandlerProxy::HandleGestureFling::started",
                                this,
                                "vx",
                                vx,
                                "vy",
                                vy);
       // Note that the timestamp will only be used to kickstart the animation if
@@ skipping 16 matching lines @@
                            "scroll_on_main_thread",
                            TRACE_EVENT_SCOPE_THREAD);
       fling_may_be_active_on_main_thread_ = true;
       return DID_NOT_HANDLE;
     }
     case cc::InputHandler::ScrollIgnored: {
       TRACE_EVENT_INSTANT0(
           "input",
           "InputHandlerProxy::HandleGestureFling::ignored",
           TRACE_EVENT_SCOPE_THREAD);
-      if (gesture_event.sourceDevice == WebGestureEvent::Touchpad) {
+      if (gesture_event.sourceDevice == blink::WebGestureDeviceTouchpad) {
         // We still pass the curve to the main thread if there's nothing
         // scrollable, in case something
         // registers a handler before the curve is over.
         return DID_NOT_HANDLE;
       }
       return DROP_EVENT;
     }
     case cc::InputHandler::ScrollStatusCount:
       NOTREACHED();
       break;
@@ skipping 37 matching lines @@
   }
 
   switch (gesture_event.type) {
     case WebInputEvent::GestureTapCancel:
     case WebInputEvent::GestureTapDown:
       return false;
 
     case WebInputEvent::GestureScrollBegin:
       if (!input_handler_->IsCurrentlyScrollingLayerAt(
               gfx::Point(gesture_event.x, gesture_event.y),
-              fling_parameters_.sourceDevice == WebGestureEvent::Touchpad
+              fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchpad
                   ? cc::InputHandler::NonBubblingGesture
                   : cc::InputHandler::Gesture)) {
         CancelCurrentFling(true);
         return false;
       }
 
       // TODO(jdduke): Use |gesture_event.data.scrollBegin.delta{X,Y}Hint| to
       // determine if the ScrollBegin should immediately cancel the fling.
       FlingBoostExtend(gesture_event);
       return true;
@@ skipping 29 matching lines @@
 
       if (fling_boosted)
         current_fling_velocity_ += new_fling_velocity;
       else
         current_fling_velocity_ = new_fling_velocity;
 
       WebFloatPoint velocity(current_fling_velocity_.x(),
                              current_fling_velocity_.y());
       deferred_fling_cancel_time_seconds_ = 0;
       last_fling_boost_event_ = WebGestureEvent();
+      // TODO(rjkroege): Remove cast after 3rd patch of http://crbug.com/343327
       fling_curve_.reset(client_->CreateFlingAnimationCurve(
-          gesture_event.sourceDevice, velocity, blink::WebSize()));
+          (blink::WebGestureDevice)gesture_event.sourceDevice,
+          velocity,
+          blink::WebSize()));
       fling_parameters_.startTime = gesture_event.timeStampSeconds;
       fling_parameters_.delta = velocity;
       fling_parameters_.point = WebPoint(gesture_event.x, gesture_event.y);
       fling_parameters_.globalPoint =
           WebPoint(gesture_event.globalX, gesture_event.globalY);
 
       TRACE_EVENT_INSTANT2("input",
                            fling_boosted ? "InputHandlerProxy::FlingBoosted"
                                          : "InputHandlerProxy::FlingReplaced",
                            TRACE_EVENT_SCOPE_THREAD,
@@ skipping 118 matching lines @@
         kFlingOverscrollThreshold;
   }
 
   client_->DidOverscroll(params);
 }
 
 bool InputHandlerProxy::CancelCurrentFling(
     bool send_fling_stopped_notification) {
   bool had_fling_animation = fling_curve_;
   if (had_fling_animation &&
-      fling_parameters_.sourceDevice == WebGestureEvent::Touchscreen) {
+      fling_parameters_.sourceDevice == blink::WebGestureDeviceTouchscreen) {
     input_handler_->ScrollEnd();
     TRACE_EVENT_ASYNC_END0(
         "input",
         "InputHandlerProxy::HandleGestureFling::started",
         this);
   }
 
   TRACE_EVENT_INSTANT1("input",
                        "InputHandlerProxy::CancelCurrentFling",
                        TRACE_EVENT_SCOPE_THREAD,
@@ skipping 73 matching lines @@
   TRACE_EVENT2("input",
                "InputHandlerProxy::scrollBy",
                "x",
                clipped_increment.width,
                "y",
                clipped_increment.height);
 
   bool did_scroll = false;
 
   switch (fling_parameters_.sourceDevice) {
-    case WebGestureEvent::Touchpad:
+    case blink::WebGestureDeviceTouchpad:
       did_scroll = TouchpadFlingScroll(clipped_increment);
       break;
-    case WebGestureEvent::Touchscreen:
+    case blink::WebGestureDeviceTouchscreen:
       clipped_increment = ToClientScrollIncrement(clipped_increment);
       did_scroll = input_handler_->ScrollBy(fling_parameters_.point,
                                             clipped_increment);
       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