Enable gestures for wheel events on all platforms other than MacOSX.

content/browser/renderer_host/overscroll_controller.cc

 // Copyright (c) 2012 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/browser/renderer_host/overscroll_controller.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "content/browser/renderer_host/overscroll_controller_delegate.h"
+#include "content/common/input/input_event_utils.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/common/content_switches.h"
 
 using blink::WebInputEvent;
 
 namespace {
 
 bool IsScrollEndEffectEnabled() {
   return base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
       switches::kScrollEndEffect) == "1";
 }
 
+bool IsGestureEventFromTouchscreen(const blink::WebInputEvent& event) {
+  const blink::WebGestureEvent& gesture =
+      static_cast<const blink::WebGestureEvent&>(event);
+  return gesture.sourceDevice == blink::WebGestureDeviceTouchscreen;
+}
+
 }  // namespace
 
 namespace content {
 
 OverscrollController::OverscrollController()
     : overscroll_mode_(OVERSCROLL_NONE),
       scroll_state_(STATE_UNKNOWN),
       overscroll_delta_x_(0.f),
       overscroll_delta_y_(0.f),
-      delegate_(NULL) {
-}
+      delegate_(NULL),
+      use_gesutre_wheel_scrolling_(UseGestureBasedWheelScrolling()) {}
 
 OverscrollController::~OverscrollController() {
 }
 
 bool OverscrollController::WillHandleEvent(const blink::WebInputEvent& event) {
   bool reset_scroll_state = false;
   if (scroll_state_ != STATE_UNKNOWN ||
       overscroll_delta_x_ || overscroll_delta_y_) {
     switch (event.type) {
       case blink::WebInputEvent::GestureScrollEnd:
+        // Gesture scroll end is sent based on a timeout avoid
+        // resetting on events from the touchpad.
+        reset_scroll_state = IsGestureEventFromTouchscreen(event);
+        break;
+
       case blink::WebInputEvent::GestureFlingStart:
         reset_scroll_state = true;
         break;
 
       case blink::WebInputEvent::MouseWheel: {
-        const blink::WebMouseWheelEvent& wheel =
-            static_cast<const blink::WebMouseWheelEvent&>(event);
-        if (!wheel.hasPreciseScrollingDeltas ||
-            wheel.phase == blink::WebMouseWheelEvent::PhaseEnded ||
-            wheel.phase == blink::WebMouseWheelEvent::PhaseCancelled) {
-          reset_scroll_state = true;
+        if (!use_gesutre_wheel_scrolling_) {
+          const blink::WebMouseWheelEvent& wheel =
+              static_cast<const blink::WebMouseWheelEvent&>(event);
+          if (!wheel.hasPreciseScrollingDeltas ||
+              wheel.phase == blink::WebMouseWheelEvent::PhaseEnded ||
+              wheel.phase == blink::WebMouseWheelEvent::PhaseCancelled) {
+            reset_scroll_state = true;
+          }
         }
         break;
       }
 
       default:
         if (blink::WebInputEvent::isMouseEventType(event.type) ||
             blink::WebInputEvent::isKeyboardEventType(event.type)) {
           reset_scroll_state = true;
         }
         break;
@@ skipping 24 matching lines @@
   } else if (reset_scroll_state) {
     overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
   }
 
 
   return false;
 }
 
 void OverscrollController::ReceivedEventACK(const blink::WebInputEvent& event,
                                             bool processed) {
+  if (use_gesutre_wheel_scrolling_ &&
+      event.type == blink::WebInputEvent::MouseWheel)
+    return;
+
   if (processed) {
     // If a scroll event is consumed by the page, i.e. some content on the page
     // has been scrolled, then there is not going to be an overscroll gesture,
     // until the current scroll ends, and a new scroll gesture starts.
     if (scroll_state_ == STATE_UNKNOWN &&
         (event.type == blink::WebInputEvent::MouseWheel ||
          event.type == blink::WebInputEvent::GestureScrollUpdate)) {
       scroll_state_ = STATE_CONTENT_SCROLLING;
     }
     return;
@@ skipping 27 matching lines @@
   if (overscroll_mode_ == OVERSCROLL_NONE)
     return false;
 
   // Complete the overscroll gesture if there was a mouse move or a scroll-end
   // after the threshold.
   if (event.type != blink::WebInputEvent::MouseMove &&
       event.type != blink::WebInputEvent::GestureScrollEnd &&
       event.type != blink::WebInputEvent::GestureFlingStart)
     return false;
 
+  // Gesture scroll end is sent based on a timeout avoid
+  // resetting on events from the touchpad.
+  if (event.type == blink::WebInputEvent::GestureScrollEnd &&
+      !IsGestureEventFromTouchscreen(event))
+    return false;
+
   if (!delegate_)
     return false;
 
   gfx::Rect bounds = delegate_->GetVisibleBounds();
   if (bounds.IsEmpty())
     return false;
 
   if (event.type == blink::WebInputEvent::GestureFlingStart) {
     // Check to see if the fling is in the same direction of the overscroll.
     const blink::WebGestureEvent gesture =
@@ skipping 30 matching lines @@
     threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_VERT_THRESHOLD_COMPLETE);
   }
 
   return ratio >= threshold;
 }
 
 bool OverscrollController::DispatchEventResetsState(
     const blink::WebInputEvent& event) const {
   switch (event.type) {
     case blink::WebInputEvent::MouseWheel: {
-      // Only wheel events with precise deltas (i.e. from trackpad) contribute
-      // to the overscroll gesture.
-      const blink::WebMouseWheelEvent& wheel =
-          static_cast<const blink::WebMouseWheelEvent&>(event);
-      return !wheel.hasPreciseScrollingDeltas;
+      if (use_gesutre_wheel_scrolling_) {
+        return false;
+      } else {
+        // Only wheel events with precise deltas (i.e. from trackpad) contribute
+        // to the overscroll gesture.
+        const blink::WebMouseWheelEvent& wheel =
+            static_cast<const blink::WebMouseWheelEvent&>(event);
+        return !wheel.hasPreciseScrollingDeltas;
+      }
     }
 
+    // Gesture scroll begin/ends come based on a timeout avoid
+    // resetting on events from the touchpad.
+    case blink::WebInputEvent::GestureScrollBegin:
+    case blink::WebInputEvent::GestureScrollEnd:
+      return IsGestureEventFromTouchscreen(event);
+
     case blink::WebInputEvent::GestureScrollUpdate:
     case blink::WebInputEvent::GestureFlingCancel:
       return false;
 
     default:
       // Touch events can arrive during an overscroll gesture initiated by
       // touch-scrolling. These events should not reset the overscroll state.
       return !blink::WebInputEvent::isTouchEventType(event.type);
   }
 }
 
 bool OverscrollController::ProcessEventForOverscroll(
     const blink::WebInputEvent& event) {
   bool event_processed = false;
   switch (event.type) {
     case blink::WebInputEvent::MouseWheel: {
       const blink::WebMouseWheelEvent& wheel =
           static_cast<const blink::WebMouseWheelEvent&>(event);
-      if (!wheel.hasPreciseScrollingDeltas)
+      if (use_gesutre_wheel_scrolling_ || !wheel.hasPreciseScrollingDeltas)
         break;
       event_processed =
           ProcessOverscroll(wheel.deltaX * wheel.accelerationRatioX,
-                            wheel.deltaY * wheel.accelerationRatioY,
-                            wheel.type);
+                            wheel.deltaY * wheel.accelerationRatioY, true);
       break;
     }
     case blink::WebInputEvent::GestureScrollUpdate: {
       const blink::WebGestureEvent& gesture =
           static_cast<const blink::WebGestureEvent&>(event);
-      event_processed = ProcessOverscroll(gesture.data.scrollUpdate.deltaX,
-                                          gesture.data.scrollUpdate.deltaY,
-                                          gesture.type);
+      event_processed = ProcessOverscroll(
+          gesture.data.scrollUpdate.deltaX, gesture.data.scrollUpdate.deltaY,
+          gesture.sourceDevice == blink::WebGestureDeviceTouchpad);
       break;
     }
     case blink::WebInputEvent::GestureFlingStart: {
       const float kFlingVelocityThreshold = 1100.f;
       const blink::WebGestureEvent& gesture =
           static_cast<const blink::WebGestureEvent&>(event);
       float velocity_x = gesture.data.flingStart.velocityX;
       float velocity_y = gesture.data.flingStart.velocityY;
       if (fabs(velocity_x) > kFlingVelocityThreshold) {
         if ((overscroll_mode_ == OVERSCROLL_WEST && velocity_x < 0) ||
@@ skipping 19 matching lines @@
     default:
       DCHECK(blink::WebInputEvent::isGestureEventType(event.type) ||
              blink::WebInputEvent::isTouchEventType(event.type))
           << "Received unexpected event: " << event.type;
   }
   return event_processed;
 }
 
 bool OverscrollController::ProcessOverscroll(float delta_x,
                                              float delta_y,
-                                             blink::WebInputEvent::Type type) {
+                                             bool is_touchpad) {
   if (scroll_state_ != STATE_CONTENT_SCROLLING)
     overscroll_delta_x_ += delta_x;
   overscroll_delta_y_ += delta_y;
 
   float horiz_threshold = GetOverscrollConfig(
-      WebInputEvent::isGestureEventType(type) ?
-          OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHSCREEN :
-          OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHPAD);
+      is_touchpad ? OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHPAD
+                  : OVERSCROLL_CONFIG_HORIZ_THRESHOLD_START_TOUCHSCREEN);
   float vert_threshold = GetOverscrollConfig(
       OVERSCROLL_CONFIG_VERT_THRESHOLD_START);
   if (fabs(overscroll_delta_x_) <= horiz_threshold &&
       fabs(overscroll_delta_y_) <= vert_threshold) {
     SetOverscrollMode(OVERSCROLL_NONE);
     return true;
   }
 
   // Compute the current overscroll direction. If the direction is different
   // from the current direction, then always switch to no-overscroll mode first
@@ skipping 64 matching lines @@
   overscroll_mode_ = mode;
   if (overscroll_mode_ == OVERSCROLL_NONE)
     overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
   else
     scroll_state_ = STATE_OVERSCROLLING;
   if (delegate_)
     delegate_->OnOverscrollModeChange(old_mode, overscroll_mode_);
 }
 
 }  // namespace content