[exp] Browser-side fling in aura.

content/browser/renderer_host/render_widget_host_view_aura.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/render_widget_host_view_aura.h"
 
 #include "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 47 matching lines @@
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ime/input_method.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/gestures/fling_curve.h"
 #include "ui/events/gestures/gesture_recognizer.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/display.h"
+#include "ui/gfx/frame_time.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/wm/public/activation_client.h"
 #include "ui/wm/public/scoped_tooltip_disabler.h"
 #include "ui/wm/public/tooltip_client.h"
 #include "ui/wm/public/transient_window_client.h"
 #include "ui/wm/public/window_types.h"
 
@@ skipping 16 matching lines @@
 using gfx::RectToSkIRect;
 using gfx::SkIRectToRect;
 
 using blink::WebScreenInfo;
 using blink::WebInputEvent;
 using blink::WebGestureEvent;
 using blink::WebTouchEvent;
 
 namespace content {
 
+class Flinger : public ui::CompositorAnimationObserver {
+ public:
+  class Delegate {
+   public:
+    virtual ~Delegate() {}
+
+    virtual void OnScroll(const gfx::Vector2dF& scroll_delta) = 0;
+
+    virtual void OnScrollEnd() = 0;
+  };
+
+  Flinger(Delegate* delegate,
+          const gfx::Vector2dF& velocity,
+          ui::Compositor* compositor)
+      : delegate_(delegate),
+        compositor_(compositor),
+        fling_curve_(velocity, gfx::FrameTime::Now()) {
+    CHECK(delegate_);
+    compositor_->AddAnimationObserver(this);
+  }
+
+  virtual ~Flinger() { Done(); }
+
+ private:
+  void Done() {
+    if (!delegate_)
+      return;
+    compositor_->RemoveAnimationObserver(this);
+    Delegate* delegate = delegate_;
+    delegate_ = NULL;
+    delegate->OnScrollEnd();
+  }
+
+  // ui::CompositorAnimationObserver:
+  virtual void OnAnimationStep(base::TimeTicks timestamp) OVERRIDE {
+    CHECK(delegate_);
+    if (fling_curve_.start_timestamp() > timestamp)
+      return;
+    gfx::Vector2dF scroll = fling_curve_.GetScrollAmountAtTime(timestamp);
+    if (scroll.IsZero())
+      Done();
+    else
+      delegate_->OnScroll(scroll);
+  }
+
+  Delegate* delegate_;
+  ui::Compositor* compositor_;
+  ui::FlingCurve fling_curve_;
+
+  DISALLOW_COPY_AND_ASSIGN(Flinger);
+};
+
+class FlingerDelegate : public Flinger::Delegate {
+ public:
+  FlingerDelegate(RenderWidgetHostView* view,
+                  const blink::WebGestureEvent& gesture_event)
+      : view_(view), gesture_(gesture_event) {}
+
+  virtual ~FlingerDelegate() {}
+
+ private:
+  // Flinger::Delegate:
+  virtual void OnScroll(const gfx::Vector2dF& scroll_delta) OVERRIDE {
+    blink::WebGestureEvent gesture = gesture_;
+    gesture.type = blink::WebInputEvent::GestureScrollUpdateWithoutPropagation;
+    gesture.data.scrollUpdate.deltaX = scroll_delta.x();
+    gesture.data.scrollUpdate.deltaY = scroll_delta.y();
+    RenderWidgetHostImpl::From(view_->GetRenderWidgetHost())
+        ->ForwardGestureEvent(gesture);
+  }
+
+  virtual void OnScrollEnd() OVERRIDE {
+    blink::WebGestureEvent gesture = gesture_;
+    gesture.type = blink::WebInputEvent::GestureScrollEnd;
+    RenderWidgetHostImpl::From(view_->GetRenderWidgetHost())
+        ->ForwardGestureEvent(gesture);
+    delete this;
+  }
+
+  RenderWidgetHostView* view_;
+  blink::WebGestureEvent gesture_;
+
+  DISALLOW_COPY_AND_ASSIGN(FlingerDelegate);
+};
+
 namespace {
 
 // In mouse lock mode, we need to prevent the (invisible) cursor from hitting
 // the border of the view, in order to get valid movement information. However,
 // forcing the cursor back to the center of the view after each mouse move
 // doesn't work well. It reduces the frequency of useful mouse move messages
 // significantly. Therefore, we move the cursor to the center of the view only
 // if it approaches the border. |kMouseLockBorderPercentage| specifies the width
 // of the border area, in percentage of the corresponding dimension.
 const int kMouseLockBorderPercentage = 15;
@@ skipping 1841 matching lines @@
     return;
   }
 
   if (touch_editing_client_ && touch_editing_client_->HandleInputEvent(event))
     return;
 
   RenderViewHostDelegate* delegate = NULL;
   if (host_->IsRenderView())
     delegate = RenderViewHost::From(host_)->GetDelegate();
 
+  // If there is an active fling, then any incoming new gesture event should
+  // terminate the fling.
+  if (flinger_ && event->type() == ui::ET_GESTURE_BEGIN)
+    flinger_.reset();
+
   if (delegate && event->type() == ui::ET_GESTURE_BEGIN &&
       event->details().touch_points() == 1) {
     delegate->HandleGestureBegin();
   }
 
   blink::WebGestureEvent gesture = MakeWebGestureEvent(event);
   if (event->type() == ui::ET_GESTURE_TAP_DOWN) {
     // Webkit does not stop a fling-scroll on tap-down. So explicitly send an
     // event to stop any in-progress flings.
     blink::WebGestureEvent fling_cancel = gesture;
     fling_cancel.type = blink::WebInputEvent::GestureFlingCancel;
     fling_cancel.sourceDevice = blink::WebGestureDeviceTouchscreen;
     host_->ForwardGestureEvent(fling_cancel);
   }
 
-  if (gesture.type != blink::WebInputEvent::Undefined) {
+  if (gesture.type == blink::WebInputEvent::GestureFlingStart) {
+    flinger_.reset(
+        new Flinger(new FlingerDelegate(this, gesture),
+                    gfx::Vector2dF(gesture.data.flingStart.velocityX,
+                                   gesture.data.flingStart.velocityY),
+                    window_->GetHost()->compositor()));
+  } else if (gesture.type != blink::WebInputEvent::Undefined) {
     host_->ForwardGestureEventWithLatencyInfo(gesture, *event->latency());
 
     if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN ||
         event->type() == ui::ET_GESTURE_SCROLL_UPDATE ||
         event->type() == ui::ET_GESTURE_SCROLL_END) {
       RecordAction(base::UserMetricsAction("TouchscreenScroll"));
     } else if (event->type() == ui::ET_SCROLL_FLING_START) {
       RecordAction(base::UserMetricsAction("TouchscreenScrollFling"));
     }
   }
@@ skipping 509 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewBase, public:
 
 // static
 void RenderWidgetHostViewBase::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content