overscroll: Do not overscroll if the beginning of a scroll was consumed.

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 "content/browser/renderer_host/gesture_event_filter.h"
 #include "content/browser/renderer_host/overscroll_controller_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/public/browser/overscroll_configuration.h"
 #include "content/public/browser/render_widget_host_view.h"
 
 namespace content {
 
 OverscrollController::OverscrollController(
     RenderWidgetHostImpl* render_widget_host)
     : render_widget_host_(render_widget_host),
       overscroll_mode_(OVERSCROLL_NONE),
+      scroll_state_(STATE_UNKNOWN),
       overscroll_delta_x_(0.f),
       overscroll_delta_y_(0.f),
       delegate_(NULL) {
 }
 
 OverscrollController::~OverscrollController() {
 }
 
 bool OverscrollController::WillDispatchEvent(
     const WebKit::WebInputEvent& event,
     const cc::LatencyInfo& latency_info) {
+  if (scroll_state_ != STATE_UNKNOWN) {
+    if (event.type == WebKit::WebInputEvent::GestureScrollEnd) {
+      scroll_state_ = STATE_UNKNOWN;
+    } else if (event.type == WebKit::WebInputEvent::GestureFlingStart) {
+      // Start of a fling indicates the end of a scroll, both from touchpad and
+      // touchscreen. So it is not necessary to check |sourceDevice| of the
+      // event.
+      scroll_state_ = STATE_UNKNOWN;
+    } else if (event.type == WebKit::WebInputEvent::MouseWheel) {
+      const WebKit::WebMouseWheelEvent& wheel =
+          static_cast<const WebKit::WebMouseWheelEvent&>(event);
+      if (wheel.hasPreciseScrollingDeltas &&
+          (wheel.phase == WebKit::WebMouseWheelEvent::PhaseEnded ||
+           wheel.phase == WebKit::WebMouseWheelEvent::PhaseCancelled)) {
+        scroll_state_ = STATE_UNKNOWN;
+      }
+    }
+  }
+
   if (DispatchEventCompletesAction(event)) {
     CompleteAction();
 
     // If the overscroll was caused by touch-scrolling, then the gesture event
     // that completes the action needs to be sent to the renderer, because the
     // touch-scrolls maintain state in the renderer side (in the compositor, for
     // example), and the event that completes this action needs to be sent to
     // the renderer so that those states can be updated/reset appropriately.
     // Send the event through the gesture-event filter when appropriate.
     if (ShouldForwardToGestureFilter(event)) {
@@ skipping 32 matching lines @@
         event.type == WebKit::WebInputEvent::TouchCancel)
       return true;
     return false;
   }
 
   return true;
 }
 
 void OverscrollController::ReceivedEventACK(const WebKit::WebInputEvent& event,
                                             bool processed) {
-  if (processed)
+  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 == WebKit::WebInputEvent::MouseWheel ||
+         event.type == WebKit::WebInputEvent::GestureScrollUpdate)) {
+      scroll_state_ = STATE_CONTENT_SCROLLING;
+    }
     return;
+  }
   ProcessEventForOverscroll(event);
 }
 
 void OverscrollController::Reset() {
   overscroll_mode_ = OVERSCROLL_NONE;
   overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
+  scroll_state_ = STATE_UNKNOWN;
 }
 
 bool OverscrollController::DispatchEventCompletesAction (
     const WebKit::WebInputEvent& event) const {
   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 != WebKit::WebInputEvent::MouseMove &&
@@ skipping 70 matching lines @@
       return !WebKit::WebInputEvent::isTouchEventType(event.type);
   }
 }
 
 void OverscrollController::ProcessEventForOverscroll(
     const WebKit::WebInputEvent& event) {
   switch (event.type) {
     case WebKit::WebInputEvent::MouseWheel: {
       const WebKit::WebMouseWheelEvent& wheel =
           static_cast<const WebKit::WebMouseWheelEvent&>(event);
-      if (wheel.hasPreciseScrollingDeltas) {
-        ProcessOverscroll(wheel.deltaX * wheel.accelerationRatioX,
-                          wheel.deltaY * wheel.accelerationRatioY);
-      }
+      if (!wheel.hasPreciseScrollingDeltas)
+        return;
+
+      ProcessOverscroll(wheel.deltaX * wheel.accelerationRatioX,
+                        wheel.deltaY * wheel.accelerationRatioY);
       break;
     }
     case WebKit::WebInputEvent::GestureScrollUpdate: {
       const WebKit::WebGestureEvent& gesture =
           static_cast<const WebKit::WebGestureEvent&>(event);
       ProcessOverscroll(gesture.data.scrollUpdate.deltaX,
                         gesture.data.scrollUpdate.deltaY);
       break;
     }
     case WebKit::WebInputEvent::GestureFlingStart: {
@@ skipping 22 matching lines @@
     }
 
     default:
       DCHECK(WebKit::WebInputEvent::isGestureEventType(event.type) ||
              WebKit::WebInputEvent::isTouchEventType(event.type))
           << "Received unexpected event: " << event.type;
   }
 }
 
 void OverscrollController::ProcessOverscroll(float delta_x, float delta_y) {
+  if (scroll_state_ == STATE_CONTENT_SCROLLING)
+    return;
   overscroll_delta_x_ += delta_x;
   overscroll_delta_y_ += delta_y;
 
   float threshold = GetOverscrollConfig(OVERSCROLL_CONFIG_MIN_THRESHOLD_START);
   if (fabs(overscroll_delta_x_) < threshold &&
       fabs(overscroll_delta_y_) < threshold) {
     SetOverscrollMode(OVERSCROLL_NONE);
     return;
   }
 
@@ skipping 49 matching lines @@
   overscroll_delta_x_ = overscroll_delta_y_ = 0.f;
 }
 
 void OverscrollController::SetOverscrollMode(OverscrollMode mode) {
   if (overscroll_mode_ == mode)
     return;
   OverscrollMode old_mode = overscroll_mode_;
   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_);
 }
 
 bool OverscrollController::ShouldForwardToGestureFilter(
     const WebKit::WebInputEvent& event) const {
   if (!WebKit::WebInputEvent::isGestureEventType(event.type))
     return false;
 
   // If the GestureEventFilter already processed this event, then the event must
   // not be sent to the filter again.
   return !render_widget_host_->gesture_event_filter()->HasQueuedGestureEvents();
 }
 
 }  // namespace content