[Android] Add a native pull-to-refresh overscroll effect

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/android/build_info.h"
 #include "base/basictypes.h"
@@ skipping 16 matching lines @@
 #include "cc/output/copy_output_result.h"
 #include "cc/output/viewport_selection_bound.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/trees/layer_tree_host.h"
 #include "content/browser/accessibility/browser_accessibility_manager_android.h"
 #include "content/browser/android/composited_touch_handle_drawable.h"
 #include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/edge_effect.h"
 #include "content/browser/android/edge_effect_l.h"
 #include "content/browser/android/in_process/synchronous_compositor_impl.h"
-#include "content/browser/android/overscroll_glow.h"
+#include "content/browser/android/overscroll_controller_android.h"
 #include "content/browser/devtools/render_view_devtools_agent_host.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/media/media_web_contents_observer.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/dip_util.h"
 #include "content/browser/renderer_host/image_transport_factory_android.h"
 #include "content/browser/renderer_host/input/synthetic_gesture_target_android.h"
@@ skipping 33 matching lines @@
 
 namespace {
 
 const int kUndefinedOutputSurfaceId = -1;
 
 // Used to accomodate finite precision when comparing scaled viewport and
 // content widths. While this value may seem large, width=device-width on an N7
 // V1 saw errors of ~0.065 between computed window and content widths.
 const float kMobileViewportWidthEpsilon = 0.15f;
 
-// Used for conditional creation of EdgeEffect types for overscroll.
-const int kKitKatMR2SDKVersion = 19;
-
 static const char kAsyncReadBackString[] = "Compositing.CopyFromSurfaceTime";
 
 // Sends an acknowledgement to the renderer of a processed IME event.
 void SendImeEventAck(RenderWidgetHostImpl* host) {
   host->Send(new ViewMsg_ImeEventAck(host->GetRoutingID()));
 }
 
 void CopyFromCompositingSurfaceFinished(
     ReadbackRequestCallback& callback,
     scoped_ptr<cc::SingleReleaseCallback> release_callback,
@@ skipping 27 matching lines @@
     latency_info.AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
         0,
         0,
         base::TimeTicks() + base::TimeDelta::FromMicroseconds(time_micros),
         1);
   }
   return latency_info;
 }
 
-OverscrollGlow::DisplayParameters CreateOverscrollDisplayParameters(
-    const cc::CompositorFrameMetadata& frame_metadata) {
-  const float scale_factor =
-      frame_metadata.page_scale_factor * frame_metadata.device_scale_factor;
-
-  // Compute the size and offsets for each edge, where each effect is sized to
-  // the viewport and offset by the distance of each viewport edge to the
-  // respective content edge.
-  OverscrollGlow::DisplayParameters params;
-  params.size = gfx::ScaleSize(
-      frame_metadata.scrollable_viewport_size, scale_factor);
-  params.edge_offsets[OverscrollGlow::EDGE_TOP] =
-      -frame_metadata.root_scroll_offset.y() * scale_factor;
-  params.edge_offsets[OverscrollGlow::EDGE_LEFT] =
-      -frame_metadata.root_scroll_offset.x() * scale_factor;
-  params.edge_offsets[OverscrollGlow::EDGE_BOTTOM] =
-      (frame_metadata.root_layer_size.height() -
-       frame_metadata.root_scroll_offset.y() -
-       frame_metadata.scrollable_viewport_size.height()) *
-      scale_factor;
-  params.edge_offsets[OverscrollGlow::EDGE_RIGHT] =
-      (frame_metadata.root_layer_size.width() -
-       frame_metadata.root_scroll_offset.x() -
-       frame_metadata.scrollable_viewport_size.width()) *
-      scale_factor;
-
-  return params;
-}
-
-bool UseEdgeEffectL() {
-  static bool use_edge_effect_l =
-      base::android::BuildInfo::GetInstance()->sdk_int() > kKitKatMR2SDKVersion;
-  return use_edge_effect_l;
-}
-
-scoped_ptr<EdgeEffectBase> CreateEdgeEffect(
-    ui::SystemUIResourceManager* resource_manager,
-    float device_scale_factor) {
-  DCHECK(resource_manager);
-  if (UseEdgeEffectL())
-    return scoped_ptr<EdgeEffectBase>(new EdgeEffectL(resource_manager));
-
-  return scoped_ptr<EdgeEffectBase>(
-      new EdgeEffect(resource_manager, device_scale_factor));
-}
-
-scoped_ptr<OverscrollGlow> CreateOverscrollEffect(
-    ContentViewCore* content_view_core) {
-  DCHECK(content_view_core);
-  ui::WindowAndroidCompositor* compositor =
-      content_view_core->GetWindowAndroid()->GetCompositor();
-  DCHECK(compositor);
-  ui::SystemUIResourceManager* system_resource_manager =
-      &compositor->GetSystemUIResourceManager();
-
-  if (UseEdgeEffectL())
-    EdgeEffectL::PreloadResources(system_resource_manager);
-  else
-    EdgeEffect::PreloadResources(system_resource_manager);
-
-  return make_scoped_ptr(
-      new OverscrollGlow(base::Bind(&CreateEdgeEffect,
-                                    system_resource_manager,
-                                    content_view_core->GetDpiScale())));
-}
-
 scoped_ptr<TouchSelectionController> CreateSelectionController(
     TouchSelectionControllerClient* client,
     ContentViewCore* content_view_core) {
   DCHECK(client);
   DCHECK(content_view_core);
   int tap_timeout_ms = gfx::ViewConfiguration::GetTapTimeoutInMs();
   int touch_slop_pixels = gfx::ViewConfiguration::GetTouchSlopInPixels();
   return make_scoped_ptr(new TouchSelectionController(
       client,
       base::TimeDelta::FromMilliseconds(tap_timeout_ms),
       touch_slop_pixels / content_view_core->GetDpiScale()));
 }
 
+scoped_ptr<OverscrollControllerAndroid> CreateOverscrollController(
+    ContentViewCore* content_view_core) {
+  DCHECK(content_view_core);
+  ui::WindowAndroid* window = content_view_core->GetWindowAndroid();
+  DCHECK(window);
+  ui::WindowAndroidCompositor* compositor = window->GetCompositor();
+  DCHECK(compositor);
+  return make_scoped_ptr(new OverscrollControllerAndroid(
+      content_view_core->GetWebContents(),
+      compositor,
+      content_view_core->GetDpiScale()));
+}
+
 ui::GestureProvider::Config CreateGestureProviderConfig() {
   ui::GestureProvider::Config config = ui::DefaultGestureProviderConfig();
   config.disable_click_delay =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableClickDelay);
   return config;
 }
 
 bool HasFixedPageScale(const cc::CompositorFrameMetadata& frame_metadata) {
   return frame_metadata.min_page_scale_factor ==
@@ skipping 36 matching lines @@
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       outstanding_vsync_requests_(0),
       is_showing_(!widget_host->is_hidden()),
       content_view_core_(NULL),
       ime_adapter_android_(this),
       cached_background_color_(SK_ColorWHITE),
       last_output_surface_id_(kUndefinedOutputSurfaceId),
-      overscroll_effect_enabled_(
+      overscroll_controller_enabled_(
           !base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kDisableOverscrollEdgeEffect)),
       gesture_provider_(CreateGestureProviderConfig(), this),
       gesture_text_selector_(this),
       accelerated_surface_route_id_(0),
       using_synchronous_compositor_(SynchronousCompositorImpl::FromID(
                                         widget_host->GetProcess()->GetID(),
                                         widget_host->GetRoutingID()) != NULL),
       frame_evictor_(new DelegatedFrameEvictor(this)),
       locks_on_frame_count_(0),
@@ skipping 181 matching lines @@
 void RenderWidgetHostViewAndroid::MovePluginWindows(
     const std::vector<WebPluginGeometry>& moves) {
   // We don't have plugin windows on Android. Do nothing. Note: this is called
   // from RenderWidgetHost::OnUpdateRect which is itself invoked while
   // processing the corresponding message from Renderer.
 }
 
 void RenderWidgetHostViewAndroid::Focus() {
   host_->Focus();
   host_->SetInputMethodActive(true);
-  if (overscroll_effect_)
-    overscroll_effect_->Enable();
+  if (overscroll_controller_)
+    overscroll_controller_->Enable();
 }
 
 void RenderWidgetHostViewAndroid::Blur() {
   host_->SetInputMethodActive(false);
   host_->Blur();
-  if (overscroll_effect_)
-    overscroll_effect_->Disable();
+  if (overscroll_controller_)
+    overscroll_controller_->Disable();
 }
 
 bool RenderWidgetHostViewAndroid::HasFocus() const {
   if (!content_view_core_)
     return false;  // ContentViewCore not created yet.
 
   return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
@@ skipping 525 matching lines @@
 void RenderWidgetHostViewAndroid::ComputeContentsSize(
     const cc::CompositorFrameMetadata& frame_metadata) {
   // Calculate the content size.  This should be 0 if the texture_size is 0.
   gfx::Vector2dF offset;
   if (texture_size_in_layer_.IsEmpty())
     content_size_in_layer_ = gfx::Size();
   content_size_in_layer_ = gfx::ToCeiledSize(gfx::ScaleSize(
       frame_metadata.scrollable_viewport_size,
       frame_metadata.device_scale_factor * frame_metadata.page_scale_factor));
 
-  if (overscroll_effect_) {
-    overscroll_effect_->UpdateDisplayParameters(
-        CreateOverscrollDisplayParameters(frame_metadata));
-  }
 }
 
 void RenderWidgetHostViewAndroid::InternalSwapCompositorFrame(
     uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   last_scroll_offset_ = frame->metadata.root_scroll_offset;
   if (!frame->delegated_frame_data) {
     LOG(ERROR) << "Non-delegated renderer path no longer supported";
     return;
   }
@@ skipping 178 matching lines @@
   // web design, so text will be legible without zooming). Also disable
   // double tap and pinch for pages that prevent zooming in or out.
   bool has_mobile_viewport = HasMobileViewport(frame_metadata);
   bool has_fixed_page_scale = HasFixedPageScale(frame_metadata);
   gesture_provider_.SetDoubleTapSupportForPageEnabled(
       !has_fixed_page_scale && !has_mobile_viewport);
 
   if (!content_view_core_)
     return;
 
+  if (overscroll_controller_)
+    overscroll_controller_->OnFrameMetadataUpdated(frame_metadata);
+
   if (selection_controller_) {
     selection_controller_->OnSelectionBoundsChanged(
         frame_metadata.selection_start, frame_metadata.selection_end);
   }
 
   // All offsets and sizes are in CSS pixels.
   content_view_core_->UpdateFrameInfo(
       frame_metadata.root_scroll_offset,
       frame_metadata.page_scale_factor,
       gfx::Vector2dF(frame_metadata.min_page_scale_factor,
@@ skipping 16 matching lines @@
   accelerated_surface_route_id_ = route_id;
 }
 
 void RenderWidgetHostViewAndroid::AttachLayers() {
   if (!content_view_core_)
     return;
   if (!layer_.get())
     return;
 
   content_view_core_->AttachLayer(layer_);
-  if (overscroll_effect_)
-    overscroll_effect_->Enable();
+  if (overscroll_controller_)
+    overscroll_controller_->Enable();
   layer_->SetHideLayerAndSubtree(!is_showing_);
 }
 
 void RenderWidgetHostViewAndroid::RemoveLayers() {
   if (!content_view_core_)
     return;
 
   if (!layer_.get())
     return;
 
   content_view_core_->RemoveLayer(layer_);
-  if (overscroll_effect_)
-    overscroll_effect_->Disable();
+  if (overscroll_controller_)
+    overscroll_controller_->Disable();
 }
 
 void RenderWidgetHostViewAndroid::RequestVSyncUpdate(uint32 requests) {
   // The synchronous compositor does not requre BeginFrame messages.
   if (using_synchronous_compositor_)
     requests &= FLUSH_INPUT;
 
   bool should_request_vsync = !outstanding_vsync_requests_ && requests;
   outstanding_vsync_requests_ |= requests;
   // Note that if we're not currently observing the root window, outstanding
@@ skipping 38 matching lines @@
 
   base::TimeTicks deadline =
       display_time - host_->GetEstimatedBrowserCompositeTime();
 
   host_->Send(new ViewMsg_BeginFrame(
       host_->GetRoutingID(),
       cc::BeginFrameArgs::Create(frame_time, deadline, vsync_period)));
 }
 
 bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
-  bool needs_animate =
-      overscroll_effect_ ? overscroll_effect_->Animate(frame_time) : false;
+  bool needs_animate = false;
+  if (overscroll_controller_) {
+    needs_animate |= overscroll_controller_->Animate(
+        frame_time, content_view_core_->GetLayer().get());
+  }
   if (selection_controller_)
     needs_animate |= selection_controller_->Animate(frame_time);
   return needs_animate;
 }
 
 void RenderWidgetHostViewAndroid::EvictDelegatedFrame() {
   if (layer_.get())
     DestroyDelegatedContent();
   frame_evictor_->DiscardedFrame();
   // We are evicting the delegated frame,
@@ skipping 30 matching lines @@
 
 void RenderWidgetHostViewAndroid::ProcessAckedTouchEvent(
     const TouchEventWithLatencyInfo& touch, InputEventAckState ack_result) {
   const bool event_consumed = ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
   gesture_provider_.OnTouchEventAck(event_consumed);
 }
 
 void RenderWidgetHostViewAndroid::GestureEventAck(
     const blink::WebGestureEvent& event,
     InputEventAckState ack_result) {
-  // The overscroll effect requires an explicit release signal that may not be
-  // sent from the renderer compositor.
-  if (event.type == blink::WebInputEvent::GestureScrollEnd ||
-      event.type == blink::WebInputEvent::GestureFlingStart) {
-    DidOverscroll(DidOverscrollParams());
-  }
+  if (overscroll_controller_)
+    overscroll_controller_->OnGestureEventAck(event, ack_result);
 
   if (content_view_core_)
     content_view_core_->OnGestureEventAck(event, ack_result);
 }
 
 InputEventAckState RenderWidgetHostViewAndroid::FilterInputEvent(
     const blink::WebInputEvent& input_event) {
   if (selection_controller_) {
     switch (input_event.type) {
       case blink::WebInputEvent::GestureLongPress:
         selection_controller_->OnLongPressEvent();
         break;
       case blink::WebInputEvent::GestureTap:
         selection_controller_->OnTapEvent();
         break;
       default:
         break;
     }
   }
 
+  if (overscroll_controller_ &&
+      blink::WebInputEvent::isGestureEventType(input_event.type) &&
+      overscroll_controller_->WillHandleGestureEvent(
+          static_cast<const blink::WebGestureEvent&>(input_event))) {
+    return INPUT_EVENT_ACK_STATE_CONSUMED;
+  }
+
   if (content_view_core_ &&
       content_view_core_->FilterInputEvent(input_event))
     return INPUT_EVENT_ACK_STATE_CONSUMED;
 
   if (!host_)
     return INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
 
   if (input_event.type == blink::WebInputEvent::GestureTapDown ||
       input_event.type == blink::WebInputEvent::TouchStart) {
     GpuDataManagerImpl* gpu_data = GpuDataManagerImpl::GetInstance();
@@ skipping 64 matching lines @@
 
 void RenderWidgetHostViewAndroid::SendMouseWheelEvent(
     const blink::WebMouseWheelEvent& event) {
   if (host_)
     host_->ForwardWheelEvent(event);
 }
 
 void RenderWidgetHostViewAndroid::SendGestureEvent(
     const blink::WebGestureEvent& event) {
   // Sending a gesture that may trigger overscroll should resume the effect.
-  if (overscroll_effect_)
-    overscroll_effect_->Enable();
+  if (overscroll_controller_)
+    overscroll_controller_->Enable();
 
   if (host_)
     host_->ForwardGestureEventWithLatencyInfo(event, CreateLatencyInfo(event));
 }
 
 void RenderWidgetHostViewAndroid::MoveCaret(const gfx::Point& point) {
   if (host_)
     host_->MoveCaret(point);
 }
 
@@ skipping 31 matching lines @@
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
 void RenderWidgetHostViewAndroid::DidOverscroll(
     const DidOverscrollParams& params) {
   if (!content_view_core_ || !layer_.get() || !is_showing_)
     return;
 
-  const float device_scale_factor = content_view_core_->GetDpiScale();
-
-  if (overscroll_effect_ &&
-      overscroll_effect_->OnOverscrolled(
-          content_view_core_->GetLayer().get(),
-          base::TimeTicks::Now(),
-          gfx::ScaleVector2d(params.accumulated_overscroll,
-                             device_scale_factor),
-          gfx::ScaleVector2d(params.latest_overscroll_delta,
-                             device_scale_factor),
-          gfx::ScaleVector2d(params.current_fling_velocity,
-                             device_scale_factor),
-          gfx::ScaleVector2d(
-              params.causal_event_viewport_point.OffsetFromOrigin(),
-              device_scale_factor))) {
-    SetNeedsAnimate();
-  }
+  if (overscroll_controller_)
+    overscroll_controller_->OnOverscrolled(params);
 }
 
 void RenderWidgetHostViewAndroid::DidStopFlinging() {
   if (content_view_core_)
     content_view_core_->DidStopFlinging();
 }
 
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RemoveLayers();
   StopObservingRootWindow();
 
   bool resize = false;
   if (content_view_core != content_view_core_) {
-    overscroll_effect_.reset();
+    overscroll_controller_.reset();
     selection_controller_.reset();
     ReleaseLocksOnSurface();
     resize = true;
   }
 
   content_view_core_ = content_view_core;
 
   BrowserAccessibilityManager* manager = NULL;
   if (host_)
     manager = host_->GetRootBrowserAccessibilityManager();
@@ skipping 10 matching lines @@
     return;
 
   StartObservingRootWindow();
 
   if (resize)
     WasResized();
 
   if (!selection_controller_)
     selection_controller_ = CreateSelectionController(this, content_view_core_);
 
-  if (overscroll_effect_enabled_ && !overscroll_effect_ &&
-      content_view_core_->GetWindowAndroid()->GetCompositor())
-    overscroll_effect_ = CreateOverscrollEffect(content_view_core_);
+  if (overscroll_controller_enabled_ && !overscroll_controller_ &&
+      content_view_core_->GetWindowAndroid()->GetCompositor()) {
+    overscroll_controller_ = CreateOverscrollController(content_view_core_);
+  }
 }
 
 void RenderWidgetHostViewAndroid::RunAckCallbacks() {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
     ack_callbacks_.pop();
   }
 }
 
 void RenderWidgetHostViewAndroid::OnGestureEvent(
     const ui::GestureEventData& gesture) {
   SendGestureEvent(CreateWebGestureEventFromGestureEventData(gesture));
 }
 
 void RenderWidgetHostViewAndroid::OnCompositingDidCommit() {
   RunAckCallbacks();
 }
 
 void RenderWidgetHostViewAndroid::OnAttachCompositor() {
   DCHECK(content_view_core_);
-  if (overscroll_effect_enabled_ && !overscroll_effect_)
-    overscroll_effect_ = CreateOverscrollEffect(content_view_core_);
+  if (overscroll_controller_enabled_ && !overscroll_controller_)
+    overscroll_controller_ = CreateOverscrollController(content_view_core_);
 }
 
 void RenderWidgetHostViewAndroid::OnDetachCompositor() {
   DCHECK(content_view_core_);
   DCHECK(!using_synchronous_compositor_);
   RunAckCallbacks();
-  overscroll_effect_.reset();
+  overscroll_controller_.reset();
 }
 
 void RenderWidgetHostViewAndroid::OnVSync(base::TimeTicks frame_time,
                                           base::TimeDelta vsync_period) {
   TRACE_EVENT0("cc", "RenderWidgetHostViewAndroid::OnVSync");
   if (!host_)
     return;
 
   const uint32 current_vsync_requests = outstanding_vsync_requests_;
   outstanding_vsync_requests_ = 0;
@@ skipping 151 matching lines @@
   results->orientationAngle = display.RotationAsDegree();
   results->orientationType =
       RenderWidgetHostViewBase::GetOrientationTypeForMobile(display);
   gfx::DeviceDisplayInfo info;
   results->depth = info.GetBitsPerPixel();
   results->depthPerComponent = info.GetBitsPerComponent();
   results->isMonochrome = (results->depthPerComponent == 0);
 }
 
 } // namespace content