Move fling implementation from renderer to browser:

content/browser/renderer_host/input/immediate_input_router.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/immediate_input_router.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
@@ skipping 52 matching lines @@
     case INPUT_EVENT_ACK_STATE_CONSUMED: return "CONSUMED";
     case INPUT_EVENT_ACK_STATE_NOT_CONSUMED: return "NOT_CONSUMED";
     case INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS: return "NO_CONSUMER_EXISTS";
   default:
     DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.\n";
     break;
   }
   return "";
 }
 
+bool BrowserSideFlingEnabled() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableBrowserSideFling);
+}
+
 } // namespace
 
+// A helper class that based on the value of the |kEnableBrowserSideFling| flag
+// does event filtering using either |BaseGestureEventFilter| or
+// |GestureEventFilter|.
+class ImmediateInputRouter::EventFilteringHelper {
+ public:
+  // |router| must outlive us.
+  explicit EventFilteringHelper(ImmediateInputRouter* router) {
+    if (BrowserSideFlingEnabled())
+      gesture_event_filter_.reset(new BaseGestureEventFilter(router));
+    else
+      gesture_event_filter_.reset(new GestureEventFilter(router, router));
+  }
+  virtual ~EventFilteringHelper() {}
+
+  bool ShouldDeferMouseDown(const MouseEventWithLatencyInfo& mouse_event) {
+    if (BrowserSideFlingEnabled())
+      return false;
+
+    return static_cast<GestureEventFilter*>(gesture_event_filter_.get())->
+        GetTouchpadTapSuppressionController()->ShouldDeferMouseDown(
+            mouse_event);
+  }
+
+  bool ShouldDeferMouseUp(const MouseEventWithLatencyInfo& mouse_event) {
+    if (BrowserSideFlingEnabled())
+      return false;
+
+    return static_cast<GestureEventFilter*>(gesture_event_filter_.get())->
+        GetTouchpadTapSuppressionController()->ShouldSuppressMouseUp();
+  }
+
+  void FlingHasBeenHalted() {
+    if (BrowserSideFlingEnabled())
+      return;
+
+    static_cast<GestureEventFilter*>(gesture_event_filter_.get())->
+        FlingHasBeenHalted();
+  }
+
+  bool ShouldForwardGesture(const GestureEventWithLatencyInfo& gesture_event) {
+    return gesture_event_filter_->ShouldForward(gesture_event);
+  }
+
+  bool HasQueuedGestureEvents() {
+    return gesture_event_filter_->HasQueuedGestureEvents();
+  }
+
+  void ProcessGestureAck(InputEventAckState ack_result,
+                         blink::WebInputEvent::Type type,
+                         const ui::LatencyInfo& latency) {
+    gesture_event_filter_->ProcessGestureAck(ack_result, type, latency);
+  }
+
+ private:
+  friend class ImmediateInputRouter;
+  scoped_ptr<BaseGestureEventFilter> gesture_event_filter_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventFilteringHelper);
+};
+
 ImmediateInputRouter::ImmediateInputRouter(IPC::Sender* sender,
                                            InputRouterClient* client,
                                            InputAckHandler* ack_handler,
                                            int routing_id)
     : sender_(sender),
       client_(client),
       ack_handler_(ack_handler),
       routing_id_(routing_id),
       select_range_pending_(false),
       move_caret_pending_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       has_touch_handler_(false),
       current_ack_source_(ACK_SOURCE_NONE),
       touch_event_queue_(new TouchEventQueue(this)),
-      gesture_event_filter_(new GestureEventFilter(this, this)) {
+      flinger_(new Flinger(this)),
+      event_filter_(new EventFilteringHelper(this)) {
   DCHECK(sender);
   DCHECK(client);
   DCHECK(ack_handler);
 }
 
 ImmediateInputRouter::~ImmediateInputRouter() {
 }
 
 void ImmediateInputRouter::Flush() {
   NOTREACHED() << "ImmediateInputRouter will never request a flush.";
@@ skipping 18 matching lines @@
 void ImmediateInputRouter::SendMouseEvent(
     const MouseEventWithLatencyInfo& mouse_event) {
   // Order is important here; we need to convert all MouseEvents before they
   // propagate further, e.g., to the tap suppression controller.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSimulateTouchScreenWithMouse)) {
     SimulateTouchGestureWithMouse(mouse_event);
     return;
   }
 
+  if (BrowserSideFlingEnabled() && flinger_->HandleMouseEvent(mouse_event))
+    return;
+
   if (mouse_event.event.type == WebInputEvent::MouseDown &&
-      gesture_event_filter_->GetTouchpadTapSuppressionController()->
-          ShouldDeferMouseDown(mouse_event))
+      event_filter_->ShouldDeferMouseDown(mouse_event))
       return;
   if (mouse_event.event.type == WebInputEvent::MouseUp &&
-      gesture_event_filter_->GetTouchpadTapSuppressionController()->
-          ShouldSuppressMouseUp())
+      event_filter_->ShouldDeferMouseUp(mouse_event))
       return;
 
   SendMouseEventImmediately(mouse_event);
 }
 
 void ImmediateInputRouter::SendWheelEvent(
     const MouseWheelEventWithLatencyInfo& wheel_event) {
+  if (BrowserSideFlingEnabled() && flinger_->HandleWheelEvent(wheel_event))
+    return;
+
   // If there's already a mouse wheel event waiting to be sent to the renderer,
   // add the new deltas to that event. Not doing so (e.g., by dropping the old
   // event, as for mouse moves) results in very slow scrolling on the Mac (on
   // which many, very small wheel events are sent).
   if (mouse_wheel_pending_) {
     if (coalesced_mouse_wheel_events_.empty() ||
         !coalesced_mouse_wheel_events_.back().CanCoalesceWith(wheel_event)) {
       coalesced_mouse_wheel_events_.push_back(wheel_event);
     } else {
       coalesced_mouse_wheel_events_.back().CoalesceWith(wheel_event);
     }
     return;
   }
   mouse_wheel_pending_ = true;
   current_wheel_event_ = wheel_event;
 
   HISTOGRAM_COUNTS_100("Renderer.WheelQueueSize",
                        coalesced_mouse_wheel_events_.size());
 
   FilterAndSendWebInputEvent(wheel_event.event, wheel_event.latency, false);
 }
 
 void ImmediateInputRouter::SendKeyboardEvent(
     const NativeWebKeyboardEvent& key_event,
     const ui::LatencyInfo& latency_info,
     bool is_keyboard_shortcut) {
+  if (BrowserSideFlingEnabled() && flinger_->HandleKeyboardEvent())
+    return;
+
   // Put all WebKeyboardEvent objects in a queue since we can't trust the
   // renderer and we need to give something to the HandleKeyboardEvent
   // handler.
   key_queue_.push_back(key_event);
   HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
-  gesture_event_filter_->FlingHasBeenHalted();
+  event_filter_->FlingHasBeenHalted();
 
   // Only forward the non-native portions of our event.
   FilterAndSendWebInputEvent(key_event, latency_info, is_keyboard_shortcut);
 }
 
 void ImmediateInputRouter::SendGestureEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
   HandleGestureScroll(gesture_event);
 
+  if (BrowserSideFlingEnabled() && flinger_->HandleGestureEvent(gesture_event))
+    return;
+
   if (!IsInOverscrollGesture() &&
-      !gesture_event_filter_->ShouldForward(gesture_event)) {
+      !event_filter_->ShouldForwardGesture(gesture_event)) {
     OverscrollController* controller = client_->GetOverscrollController();
     if (controller)
       controller->DiscardingGestureEvent(gesture_event.event);
     return;
   }
 
   FilterAndSendWebInputEvent(gesture_event.event, gesture_event.latency, false);
 }
 
 void ImmediateInputRouter::SendTouchEvent(
@@ skipping 73 matching lines @@
   ack_handler_->OnTouchEventAck(event, ack_result);
 }
 
 void ImmediateInputRouter::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   ProcessAckForOverscroll(event.event, ack_result);
   ack_handler_->OnGestureEventAck(event, ack_result);
 }
 
+void ImmediateInputRouter::SendEventForFling(
+    const blink::WebInputEvent& event) {
+  ui::LatencyInfo latency_info;
+  if (Send(new InputMsg_HandleInputEvent(
+      routing_id(), &event, latency_info, false)))
+    in_process_messages_sources_.push(MESSAGE_SOURCE_FLING);
+}
+
+void ImmediateInputRouter::FlingFinished(
+    blink::WebGestureEvent::SourceDevice source) {
+  if (source == blink::WebGestureEvent::Touchscreen) {
+    ui::LatencyInfo latency_info;
+    blink::WebGestureEvent synthetic_gesture;
+    synthetic_gesture.type = blink::WebInputEvent::GestureScrollEnd;
+    synthetic_gesture.sourceDevice = blink::WebGestureEvent::Touchscreen;
+    OfferToRenderer(synthetic_gesture, latency_info, false);
+  }
+}
+
 bool ImmediateInputRouter::SendSelectRange(scoped_ptr<IPC::Message> message) {
   DCHECK(message->type() == InputMsg_SelectRange::ID);
   if (select_range_pending_) {
     next_selection_range_ = message.Pass();
     return true;
   }
 
   select_range_pending_ = true;
   return Send(message.release());
 }
@@ skipping 61 matching lines @@
   OverscrollController::Disposition disposition =
       controller->DispatchEvent(input_event, latency_info);
 
   bool consumed = disposition == OverscrollController::CONSUMED;
 
   if (disposition == OverscrollController::SHOULD_FORWARD_TO_GESTURE_FILTER) {
     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_filter_->ShouldForward(
+    consumed = !event_filter_->ShouldForwardGesture(
         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,
@@ skipping 29 matching lines @@
 
   return consumed;
 }
 
 bool ImmediateInputRouter::OfferToRenderer(const WebInputEvent& input_event,
                                            const ui::LatencyInfo& latency_info,
                                            bool is_keyboard_shortcut) {
   input_event_start_time_ = TimeTicks::Now();
   if (Send(new InputMsg_HandleInputEvent(
           routing_id(), &input_event, latency_info, is_keyboard_shortcut))) {
+    in_process_messages_sources_.push(MESSAGE_SOURCE_REGULAR);
     client_->IncrementInFlightEventCount();
     return true;
   }
   return false;
 }
 
 void ImmediateInputRouter::OnInputEventAck(
     WebInputEvent::Type event_type,
     InputEventAckState ack_result,
     const ui::LatencyInfo& latency_info) {
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 
+  InputMessageSource source = in_process_messages_sources_.front();
+  in_process_messages_sources_.pop();
+  if (source == MESSAGE_SOURCE_FLING) {
+    flinger_->ProcessEventAck(event_type, ack_result, latency_info);
+    return;
+  }
+
   client_->DecrementInFlightEventCount();
 
   ProcessInputEventAck(event_type, ack_result, latency_info, RENDERER);
   // WARNING: |this| may be deleted at this point.
 
   // This is used only for testing, and the other end does not use the
   // source object.  On linux, specifying
   // Source<RenderWidgetHost> results in a very strange
   // runtime error in the epilogue of the enclosing
   // (ProcessInputEventAck) method, but not on other platforms; using
@@ skipping 118 matching lines @@
     SendWheelEvent(next_wheel_event);
   }
 }
 
 void ImmediateInputRouter::ProcessGestureAck(WebInputEvent::Type type,
                                              InputEventAckState ack_result,
                                              const ui::LatencyInfo& latency) {
   // If |ack_result| originated from the overscroll controller, only
   // feed |gesture_event_filter_| the ack if it was expecting one.
   if (current_ack_source_ == OVERSCROLL_CONTROLLER &&
-      !gesture_event_filter_->HasQueuedGestureEvents()) {
+      !event_filter_->HasQueuedGestureEvents()) {
     return;
   }
 
   // |gesture_event_filter_| will forward to OnGestureEventAck when appropriate.
-  gesture_event_filter_->ProcessGestureAck(ack_result, type, latency);
+  event_filter_->ProcessGestureAck(ack_result, type, latency);
 }
 
 void ImmediateInputRouter::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 ImmediateInputRouter::ProcessAckForOverscroll(
@@ skipping 95 matching lines @@
     case WebMouseEvent::ButtonNone:
       break;
   }
 }
 
 bool ImmediateInputRouter::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
+BaseGestureEventFilter* ImmediateInputRouter::gesture_event_filter() {
+  return event_filter_->gesture_event_filter_.get();
+}
+
 }  // namespace content