[exp] Browser-side fling.

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"
@@ skipping 10 matching lines @@
 #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"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/event.h"
+#include "ui/events/gestures/fling_curve.h"
 #include "ui/events/keycodes/keyboard_codes.h"
+#include "ui/gfx/frame_time.h"
+
+#if defined(OS_ANDROID)
+#include "ui/gfx/android/scroller.h"
+#endif
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebKeyboardEvent;
 using blink::WebMouseEvent;
 using blink::WebMouseWheelEvent;
 
 namespace content {
 namespace {
 
 const char* GetEventAckName(InputEventAckState ack_result) {
   switch(ack_result) {
     case INPUT_EVENT_ACK_STATE_UNKNOWN: return "UNKNOWN";
     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";
     case INPUT_EVENT_ACK_STATE_IGNORED: return "IGNORED";
   }
   DLOG(WARNING) << "Unhandled InputEventAckState in GetEventAckName.";
   return "";
 }
 
 } // namespace
 
+#if defined(OS_ANDROID)
+namespace {
+
+// Value taken directly from Android's ViewConfiguration. As the value has not
+// changed in 4+ years, and does not depend on any device-specific configuration
+// parameters, copy it directly to avoid potential JNI interop issues in the
+// render process (see crbug.com/362614).
+const float kDefaultAndroidPlatformScrollFriction = 0.015f;
+
+gfx::Scroller::Config GetScrollerConfig() {
+  gfx::Scroller::Config config;
+  config.flywheel_enabled = false;
+  config.fling_friction = kDefaultAndroidPlatformScrollFriction;
+  return config;
+}
+
+}  // namespace
+#endif  // defined(OS_ANDROID)
+
+Flinger::Flinger(const blink::WebGestureEvent& fling_event)
+    : fling_event_(fling_event),
+#if defined(OS_ANDROID)
+      scroller_(new gfx::Scroller(GetScrollerConfig())) {
+#else
+      fling_curve_(new ui::FlingCurve(
+          gfx::Vector2dF(fling_event.data.flingStart.velocityX,
+                         fling_event.data.flingStart.velocityY),
+          gfx::FrameTime::Now())) {
+#endif
+  CHECK_EQ(blink::WebInputEvent::GestureFlingStart, fling_event_.type);
+#if defined(OS_ANDROID)
+  scroller_->Fling(0.f,
+                   0.f,
+                   fling_event.data.flingStart.velocityX,
+                   fling_event.data.flingStart.velocityY,
+                   INT_MIN,
+                   INT_MAX,
+                   INT_MIN,
+                   INT_MAX,
+                   gfx::FrameTime::Now());
+#endif
+}
+
+Flinger::~Flinger() {
+}
+
+blink::WebGestureEvent Flinger::GetNextScrollEvent() {
+  gfx::Vector2dF scroll;
+  bool scroll_end_reached = false;
+
+  base::TimeTicks now = gfx::FrameTime::Now();
+#if defined(OS_ANDROID)
+  gfx::PointF pre_scroll_location(scroller_->GetCurrX(), scroller_->GetCurrY());
+  if (scroller_->ComputeScrollOffset(now)) {
+    gfx::PointF new_location(scroller_->GetCurrX(), scroller_->GetCurrY());
+    scroll = new_location - pre_scroll_location;
+  } else {
+    scroll_end_reached = true;
+  }
+#else
+  scroll = fling_curve_->GetScrollAmountAtTime(now);
+  scroll_end_reached = scroll.IsZero();
+#endif
+
+  if (scroll_end_reached) {
+    blink::WebGestureEvent scroll_end = fling_event_;
+    scroll_end.type = blink::WebInputEvent::GestureScrollEnd;
+    return scroll_end;
+  }
+
+  blink::WebGestureEvent scroll_update = fling_event_;
+  scroll_update.type =
+      blink::WebInputEvent::GestureScrollUpdateWithoutPropagation;
+  scroll_update.data.scrollUpdate.deltaX = scroll.x();
+  scroll_update.data.scrollUpdate.deltaY = scroll.y();
+  return scroll_update;
+}
+
 InputRouterImpl::Config::Config() {
 }
 
 InputRouterImpl::InputRouterImpl(IPC::Sender* sender,
                                  InputRouterClient* client,
                                  InputAckHandler* ack_handler,
                                  int routing_id,
                                  const Config& config)
     : sender_(sender),
       client_(client),
@@ skipping 98 matching lines @@
   LOCAL_HISTOGRAM_COUNTS_100("Renderer.KeyboardQueueSize", key_queue_.size());
 
   gesture_event_queue_.FlingHasBeenHalted();
 
   // Only forward the non-native portions of our event.
   FilterAndSendWebInputEvent(key_event, latency_info, is_keyboard_shortcut);
 }
 
 void InputRouterImpl::SendGestureEvent(
     const GestureEventWithLatencyInfo& original_gesture_event) {
+  if (original_gesture_event.event.type ==
+      blink::WebInputEvent::GestureFlingStart) {
+    const blink::WebGestureEvent& fling_event = original_gesture_event.event;
+    gfx::Vector2dF velocity(fling_event.data.flingStart.velocityX,
+                            fling_event.data.flingStart.velocityY);
+    if (!velocity.IsZero()) {
+      flinger_.reset(new Flinger(fling_event));
+      SendGestureEvent(GestureEventWithLatencyInfo(
+          flinger_->GetNextScrollEvent(), original_gesture_event.latency));
+      return;
+    }
+  }
+
+  if (original_gesture_event.event.type ==
+          blink::WebInputEvent::GestureFlingCancel &&
+      flinger_) {
+    blink::WebGestureEvent gesture_event = flinger_->GetNextScrollEvent();
+    flinger_.reset();
+    gesture_event.type = blink::WebInputEvent::GestureScrollEnd;
+    SendGestureEvent(GestureEventWithLatencyInfo(
+        gesture_event, original_gesture_event.latency));
+    return;
+  }
+
   input_stream_validator_.Validate(original_gesture_event.event);
 
   GestureEventWithLatencyInfo gesture_event(original_gesture_event);
 
   if (touch_action_filter_.FilterGestureEvent(&gesture_event.event))
     return;
 
   if (gesture_event.event.sourceDevice == blink::WebGestureDeviceTouchscreen)
     touch_event_queue_.OnGestureScrollEvent(gesture_event);
 
@@ skipping 102 matching lines @@
     UpdateTouchAckTimeoutEnabled();
   }
   ack_handler_->OnTouchEventAck(event, ack_result);
 }
 
 void InputRouterImpl::OnGestureEventAck(
     const GestureEventWithLatencyInfo& event,
     InputEventAckState ack_result) {
   touch_event_queue_.OnGestureEventAck(event, ack_result);
   ack_handler_->OnGestureEventAck(event, ack_result);
+
+  if (flinger_ &&
+      event.event.type ==
+          blink::WebInputEvent::GestureScrollUpdateWithoutPropagation) {
+    const blink::WebGestureEvent& acked_event = event.event;
+    blink::WebGestureEvent fling_update = flinger_->GetNextScrollEvent();
+    if (ack_result != INPUT_EVENT_ACK_STATE_CONSUMED &&
+        (std::abs(acked_event.data.scrollUpdate.deltaX) > 0.1f ||
+         std::abs(acked_event.data.scrollUpdate.deltaY) > 0.1f)) {
+      fling_update.type = blink::WebInputEvent::GestureScrollEnd;
+    }
+    if (fling_update.type == blink::WebInputEvent::GestureScrollEnd)
+      flinger_.reset();
+    SendGestureEvent(GestureEventWithLatencyInfo(fling_update, event.latency));
+  }
 }
 
 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;
   }
 
   select_range_pending_ = true;
@@ skipping 140 matching lines @@
 void InputRouterImpl::OnInputEventAck(
     const InputHostMsg_HandleInputEvent_ACK_Params& ack) {
   client_->DecrementInFlightEventCount();
 
   // Log the time delta for processing an input event.
   TimeDelta delta = TimeTicks::Now() - input_event_start_time_;
   UMA_HISTOGRAM_TIMES("MPArch.IIR_InputEventDelta", delta);
 
   if (ack.overscroll) {
     DCHECK(ack.type == WebInputEvent::MouseWheel ||
-           ack.type == WebInputEvent::GestureScrollUpdate);
+           ack.type == WebInputEvent::GestureScrollUpdate ||
+           ack.type == WebInputEvent::GestureScrollUpdateWithoutPropagation);
     OnDidOverscroll(*ack.overscroll);
   }
 
   ProcessInputEventAck(ack.type, ack.state, ack.latency, 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
   // 'void' instead is just as safe (since NotificationSource
   // is not actually typesafe) and avoids this error.
   int type = static_cast<int>(ack.type);
   NotificationService::current()->Notify(
       NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_INPUT_EVENT_ACK,
       Source<void>(this),
       Details<int>(&type));
 }
 
 void InputRouterImpl::OnDidOverscroll(const DidOverscrollParams& params) {
   client_->DidOverscroll(params);
+  if (flinger_) {
+    blink::WebGestureEvent gesture_event = flinger_->GetNextScrollEvent();
+    flinger_.reset();
+    gesture_event.type = blink::WebInputEvent::GestureScrollEnd;
+    SendGestureEvent(
+        GestureEventWithLatencyInfo(gesture_event, ui::LatencyInfo()));
+  }
 }
 
 void InputRouterImpl::OnMsgMoveCaretAck() {
   move_caret_pending_ = false;
   if (next_move_caret_)
     SendMoveCaret(next_move_caret_.Pass());
 }
 
 void InputRouterImpl::OnSelectRangeAck() {
   select_range_pending_ = false;
@@ skipping 198 matching lines @@
 InputRouterImpl::QueuedWheelEvent::QueuedWheelEvent(
     const MouseWheelEventWithLatencyInfo& event,
     bool synthesized_from_pinch)
     : event(event), synthesized_from_pinch(synthesized_from_pinch) {
 }
 
 InputRouterImpl::QueuedWheelEvent::~QueuedWheelEvent() {
 }
 
 }  // namespace content