input: Make the OverscrollController less intrusive, and some code cleanup.

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/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"
@@ skipping 46 matching lines @@
   }
 
   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 host when appropriate.
-    if (ShouldForwardToHost(event)) {
+    if (WebKit::WebInputEvent::isGestureEventType(event.type)) {
+      // A gesture-event isn't sent to the GestureEventFilter when overscroll is
+      // in progress. So dispatch the event through the RenderWidgetHost so that
+      // it can reach the GestureEventFilter.
       const WebKit::WebGestureEvent& gevent =
           static_cast<const WebKit::WebGestureEvent&>(event);
       return render_widget_host_->ShouldForwardGestureEvent(
           GestureEventWithLatencyInfo(gevent, latency_info));
     }
 
-    return false;
+    return true;
   }
 
   if (overscroll_mode_ != OVERSCROLL_NONE && DispatchEventResetsState(event)) {
     SetOverscrollMode(OVERSCROLL_NONE);
-    // The overscroll gesture status is being reset. If the event is a
-    // gesture event (from either touchscreen or trackpad), then make sure the
-    // host gets the event first (if it didn't already process it).
-    if (ShouldForwardToHost(event)) {
+    if (WebKit::WebInputEvent::isGestureEventType(event.type)) {
+      // A gesture-event isn't sent to the GestureEventFilter when overscroll is
+      // in progress. So dispatch the event through the RenderWidgetHost so that
+      // it can reach the GestureEventFilter.
       const WebKit::WebGestureEvent& gevent =
           static_cast<const WebKit::WebGestureEvent&>(event);
       return render_widget_host_->ShouldForwardGestureEvent(
           GestureEventWithLatencyInfo(gevent, latency_info));
     }
 
     // Let the event be dispatched to the renderer.
     return true;
   }
 
   if (overscroll_mode_ != OVERSCROLL_NONE) {
-    // Consume the event and update overscroll state when in the middle of the
-    // overscroll gesture.
-    ProcessEventForOverscroll(event);
-
-    if (event.type == WebKit::WebInputEvent::TouchEnd ||
-        event.type == WebKit::WebInputEvent::TouchCancel ||
-        event.type == WebKit::WebInputEvent::TouchMove) {
-      return true;
-    }
-    return false;
+    // Consume the event only if it updates the overscroll state.
+    if (ProcessEventForOverscroll(event))
+      return false;
   }
 
   return true;
 }
 
 void OverscrollController::ReceivedEventACK(const WebKit::WebInputEvent& event,
                                             bool 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,
@@ skipping 104 matching lines @@
     case WebKit::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 !WebKit::WebInputEvent::isTouchEventType(event.type);
   }
 }
 
-void OverscrollController::ProcessEventForOverscroll(
+bool OverscrollController::ProcessEventForOverscroll(
     const WebKit::WebInputEvent& event) {
+  bool event_processed = false;
   switch (event.type) {
     case WebKit::WebInputEvent::MouseWheel: {
       const WebKit::WebMouseWheelEvent& wheel =
           static_cast<const WebKit::WebMouseWheelEvent&>(event);
       if (!wheel.hasPreciseScrollingDeltas)
-        return;
+        break;
 
       ProcessOverscroll(wheel.deltaX * wheel.accelerationRatioX,
                         wheel.deltaY * wheel.accelerationRatioY,
                         wheel.type);
+      event_processed = true;
       break;
     }
     case WebKit::WebInputEvent::GestureScrollUpdate: {
       const WebKit::WebGestureEvent& gesture =
           static_cast<const WebKit::WebGestureEvent&>(event);
       ProcessOverscroll(gesture.data.scrollUpdate.deltaX,
                         gesture.data.scrollUpdate.deltaY,
                         gesture.type);
+      event_processed = true;
       break;
     }
     case WebKit::WebInputEvent::GestureFlingStart: {
       const float kFlingVelocityThreshold = 1100.f;
       const WebKit::WebGestureEvent& gesture =
           static_cast<const WebKit::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) ||
             (overscroll_mode_ == OVERSCROLL_EAST && velocity_x > 0)) {
           CompleteAction();
+          event_processed = true;
           break;
         }
       } else if (fabs(velocity_y) > kFlingVelocityThreshold) {
         if ((overscroll_mode_ == OVERSCROLL_NORTH && velocity_y < 0) ||
             (overscroll_mode_ == OVERSCROLL_SOUTH && velocity_y > 0)) {
           CompleteAction();
+          event_processed = true;
           break;
         }
       }
 
       // Reset overscroll state if fling didn't complete the overscroll gesture.
       SetOverscrollMode(OVERSCROLL_NONE);
       break;
     }
 
     default:
       DCHECK(WebKit::WebInputEvent::isGestureEventType(event.type) ||
              WebKit::WebInputEvent::isTouchEventType(event.type))
           << "Received unexpected event: " << event.type;
   }
+  return event_processed;
 }
 
 void OverscrollController::ProcessOverscroll(float delta_x,
                                              float delta_y,
                                              WebKit::WebInputEvent::Type type) {
   if (scroll_state_ != STATE_CONTENT_SCROLLING)
     overscroll_delta_x_ += delta_x;
   overscroll_delta_y_ += delta_y;
 
   float horiz_threshold = GetOverscrollConfig(
@@ skipping 69 matching lines @@
   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::ShouldForwardToHost(
-    const WebKit::WebInputEvent& event) const {
-  if (!WebKit::WebInputEvent::isGestureEventType(event.type))
-    return false;
-
-  // If the RenderWidgetHost already processed this event, then the event must
-  // not be sent again.
-  return !render_widget_host_->HasQueuedGestureEvents();
-}
-
 }  // namespace content