Move OverscrollController to RenderWidgetHostViewAura

content/browser/renderer_host/input/input_router_impl.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/browser/renderer_host/input/input_router_impl.h"
 
 #include <math.h>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/renderer_host/input/gesture_event_queue.h"
 #include "content/browser/renderer_host/input/input_ack_handler.h"
 #include "content/browser/renderer_host/input/input_router_client.h"
 #include "content/browser/renderer_host/input/touch_event_queue.h"
 #include "content/browser/renderer_host/input/touchpad_tap_suppression_controller.h"
-#include "content/browser/renderer_host/overscroll_controller.h"
 #include "content/common/content_constants_internal.h"
 #include "content/common/edit_command.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/common/input/touch_action.h"
 #include "content/common/input/web_touch_event_traits.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
@@ skipping 148 matching lines @@
     const GestureEventWithLatencyInfo& original_gesture_event) {
   event_stream_validator_.OnEvent(original_gesture_event.event);
   GestureEventWithLatencyInfo gesture_event(original_gesture_event);
 
   if (touch_action_filter_.FilterGestureEvent(&gesture_event.event))
     return;
 
   if (gesture_event.event.sourceDevice == WebGestureEvent::Touchscreen)
     touch_event_queue_.OnGestureScrollEvent(gesture_event);
 
-  if (!IsInOverscrollGesture() &&
-      !gesture_event_queue_.ShouldForward(gesture_event)) {
-    OverscrollController* controller = client_->GetOverscrollController();
-    if (controller)
-      controller->DiscardingGestureEvent(gesture_event.event);
+  if (!gesture_event_queue_.ShouldForward(gesture_event))
     return;
-  }
 
   SendGestureEventImmediately(gesture_event);
 }
 
 void InputRouterImpl::SendTouchEvent(
     const TouchEventWithLatencyInfo& touch_event) {
   touch_event_queue_.QueueEvent(touch_event);
 }
 
 // Forwards MouseEvent without passing it through
@@ skipping 88 matching lines @@
     touch_action_filter_.ResetTouchAction();
     UpdateTouchAckTimeoutEnabled();
   }
   ack_handler_->OnTouchEventAck(event, ack_result);
 }
 
 void InputRouterImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   touch_event_queue_.OnGestureEventAck(event, ack_result);
-  ProcessAckForOverscroll(event.event, ack_result);
   ack_handler_->OnGestureEventAck(event, ack_result);
 }
 
 bool InputRouterImpl::SendSelectRange(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_SelectRange::ID);
   if (select_range_pending_) {
     next_selection_range_ = message.Pass();
     return true;
   }
 
@@ skipping 27 matching lines @@
 
   // Any input event cancels a pending mouse move event.
   next_mouse_move_.reset();
 
   OfferToHandlers(input_event, latency_info, is_keyboard_shortcut);
 }
 
 void InputRouterImpl::OfferToHandlers(const WebInputEvent& input_event,
                                       const ui::LatencyInfo& latency_info,
                                       bool is_keyboard_shortcut) {
-  if (OfferToOverscrollController(input_event, latency_info))
-    return;
-
   if (OfferToClient(input_event, latency_info))
     return;
 
   OfferToRenderer(input_event, latency_info, is_keyboard_shortcut);
 
   // Touch events should always indicate in the event whether they are
   // cancelable (respect ACK disposition) or not.
   bool ignores_ack = WebInputEventTraits::IgnoresAckDisposition(input_event);
   if (WebInputEvent::isTouchEventType(input_event.type)) {
     DCHECK(!ignores_ack ==
            static_cast<const blink::WebTouchEvent&>(input_event).cancelable);
   }
 
   // If we don't care about the ack disposition, send the ack immediately.
   if (ignores_ack) {
     ProcessInputEventAck(input_event.type,
                          INPUT_EVENT_ACK_STATE_IGNORED,
                          latency_info,
                          IGNORING_DISPOSITION);
   }
 }
 
-bool InputRouterImpl::OfferToOverscrollController(
-    const WebInputEvent& input_event,
-    const ui::LatencyInfo& latency_info) {
-  OverscrollController* controller = client_->GetOverscrollController();
-  if (!controller)
-    return false;
-
-  OverscrollController::Disposition disposition =
-      controller->DispatchEvent(input_event, latency_info);
-
-  bool consumed = disposition == OverscrollController::CONSUMED;
-
-  if (disposition == OverscrollController::SHOULD_FORWARD_TO_GESTURE_QUEUE) {
-    DCHECK(WebInputEvent::isGestureEventType(input_event.type));
-    const blink::WebGestureEvent& gesture_event =
-        static_cast<const blink::WebGestureEvent&>(input_event);
-    // An ACK is expected for the event, so mark it as consumed.
-    consumed = !gesture_event_queue_.ShouldForward(
-        GestureEventWithLatencyInfo(gesture_event, latency_info));
-  }
-
-  if (consumed) {
-    InputEventAckState overscroll_ack =
-        WebInputEvent::isTouchEventType(input_event.type) ?
-            INPUT_EVENT_ACK_STATE_NOT_CONSUMED : INPUT_EVENT_ACK_STATE_CONSUMED;
-    ProcessInputEventAck(input_event.type,
-                         overscroll_ack,
-                         latency_info,
-                         OVERSCROLL_CONTROLLER);
-    // WARNING: |this| may be deleted at this point.
-  }
-
-  return consumed;
-}
-
 bool InputRouterImpl::OfferToClient(const WebInputEvent& input_event,
                                     const ui::LatencyInfo& latency_info) {
   bool consumed = false;
 
   InputEventAckState filter_ack =
       client_->FilterInputEvent(input_event, latency_info);
   switch (filter_ack) {
     case INPUT_EVENT_ACK_STATE_CONSUMED:
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS:
       // Send the ACK and early exit.
@@ skipping 223 matching lines @@
 
   if (current_wheel_event_.synthesized_from_pinch) {
     // Ack the GesturePinchUpdate event that generated this wheel event.
     ProcessInputEventAck(WebInputEvent::GesturePinchUpdate,
                          ack_result,
                          current_wheel_event_.event.latency,
                          current_ack_source_);
   } else {
     // Process the unhandled wheel event here before calling SendWheelEvent()
     // since it will mutate current_wheel_event_.
-    ProcessAckForOverscroll(current_wheel_event_.event.event, ack_result);
     ack_handler_->OnWheelEventAck(current_wheel_event_.event, ack_result);
   }
 
   // Mark the wheel event complete only after the ACKs have been handled above.
   // For example, ACKing the GesturePinchUpdate could cause another
   // GesturePinchUpdate to be sent, which should queue a wheel event rather than
   // send it immediately.
   mouse_wheel_pending_ = false;
 
   // Send the next (coalesced or synthetic) mouse wheel event.
   if (!coalesced_mouse_wheel_events_.empty()) {
     QueuedWheelEvent next_wheel_event = coalesced_mouse_wheel_events_.front();
     coalesced_mouse_wheel_events_.pop_front();
     SendWheelEvent(next_wheel_event);
   }
 }
 
 void InputRouterImpl::ProcessGestureAck(WebInputEvent::Type type,
                                         InputEventAckState ack_result,
                                         const ui::LatencyInfo& latency) {
-  // If |ack_result| originated from the overscroll controller, only
-  // feed |gesture_event_queue_| the ack if it was expecting one.
-  if (current_ack_source_ == OVERSCROLL_CONTROLLER &&
-      !gesture_event_queue_.ExpectingGestureAck()) {
+  if (!gesture_event_queue_.ExpectingGestureAck())
     return;
-  }
 
   // |gesture_event_queue_| will forward to OnGestureEventAck when appropriate.
   gesture_event_queue_.ProcessGestureAck(ack_result, type, latency);
 }
 
 void InputRouterImpl::ProcessTouchAck(
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency) {
   // |touch_event_queue_| will forward to OnTouchEventAck when appropriate.
   touch_event_queue_.ProcessTouchAck(ack_result, latency);
 }
 
-void InputRouterImpl::ProcessAckForOverscroll(const WebInputEvent& event,
-                                              InputEventAckState ack_result) {
-  // Acks sent from the overscroll controller need not be fed back into the
-  // overscroll controller.
-  if (current_ack_source_ == OVERSCROLL_CONTROLLER)
-    return;
-
-  OverscrollController* controller = client_->GetOverscrollController();
-  if (!controller)
-    return;
-
-  controller->ReceivedEventACK(
-      event, (INPUT_EVENT_ACK_STATE_CONSUMED == ack_result));
-}
-
 void InputRouterImpl::UpdateTouchAckTimeoutEnabled() {
   // Mobile sites tend to be well-behaved with respect to touch handling, so
   // they have less need for the touch timeout fallback.
   const bool fixed_page_scale = (current_view_flags_ & FIXED_PAGE_SCALE) != 0;
   const bool mobile_viewport = (current_view_flags_ & MOBILE_VIEWPORT) != 0;
 
   // TOUCH_ACTION_NONE will prevent scrolling, in which case the timeout serves
   // little purpose. It's also a strong signal that touch handling is critical
   // to page functionality, so the timeout could do more harm than good.
   const bool touch_action_none =
@@ skipping 19 matching lines @@
 bool InputRouterImpl::HasPendingEvents() const {
   return !touch_event_queue_.empty() ||
          !gesture_event_queue_.empty() ||
          !key_queue_.empty() ||
          mouse_move_pending_ ||
          mouse_wheel_pending_ ||
          select_range_pending_ ||
          move_caret_pending_;
 }
 
-bool InputRouterImpl::IsInOverscrollGesture() const {
-  OverscrollController* controller = client_->GetOverscrollController();
-  return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
-}
-
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent()
     : synthesized_from_pinch(false) {
 }
 
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent(
     const MouseWheelEventWithLatencyInfo& event,
     bool synthesized_from_pinch)
     : event(event), synthesized_from_pinch(synthesized_from_pinch) {
 }
 
 InputRouterImpl::QueuedWheelEvent::~QueuedWheelEvent() {
 }
 
 }  // namespace content