Add overscroll edge effect animations for Android.

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/bind.h"
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "content/browser/android/content_view_core_impl.h"
+#include "content/browser/android/overscroll_glow.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
 #include "content/browser/renderer_host/image_transport_factory_android.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/surface_texture_transport_client_android.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
+#include "content/public/common/content_switches.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebExternalTextureLayer.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/android/java_bitmap.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "webkit/compositor_bindings/web_compositor_support_impl.h"
 
 namespace content {
 
 namespace {
 
+static const int kDesiredAnimationIntervalInMs = 16;
+
 void InsertSyncPointAndAckForGpu(
     int gpu_host_id, int route_id, const std::string& return_mailbox) {
   uint32 sync_point =
       ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
   ack_params.mailbox_name = return_mailbox;
   ack_params.sync_point = sync_point;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
       route_id, gpu_host_id, ack_params);
 }
@@ skipping 14 matching lines @@
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       route_id, renderer_host_id, ack);
 }
 
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
-      is_layer_attached_(true),
+      are_layers_attached_(true),
       content_view_core_(NULL),
       ime_adapter_android_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       cached_background_color_(SK_ColorWHITE),
       texture_id_in_layer_(0) {
   if (CompositorImpl::UsesDirectGL()) {
     surface_texture_transport_.reset(new SurfaceTextureTransportClient());
     layer_ = surface_texture_transport_->Initialize();
   } else {
     texture_layer_ = cc::TextureLayer::Create(NULL);
     layer_ = texture_layer_;
   }
 
   layer_->SetContentsOpaque(true);
   layer_->SetIsDrawable(true);
 
+  if (CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kEnableOverscrollEdgeEffect)) {
+    overscroll_effect_ = OverscrollGlow::Create();
+  }
+
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   SetContentViewCore(NULL);
   if (texture_id_in_layer_ || !last_mailbox_.IsZero()) {
     ImageTransportFactoryAndroid* factory =
         ImageTransportFactoryAndroid::GetInstance();
     // TODO: crbug.com/230137 - make workaround obsolete with refcounting.
@@ skipping 180 matching lines @@
 
   return content_view_core_->HasFocus();
 }
 
 bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
   NOTIMPLEMENTED();
   return false;
 }
 
 void RenderWidgetHostViewAndroid::Show() {
-  if (is_layer_attached_)
+  if (are_layers_attached_)
     return;
 
-  is_layer_attached_ = true;
-  if (content_view_core_)
-    content_view_core_->AttachLayer(layer_);
+  are_layers_attached_ = true;
+  AttachLayers();
 }
 
 void RenderWidgetHostViewAndroid::Hide() {
-  if (!is_layer_attached_)
+  if (!are_layers_attached_)
     return;
 
-  is_layer_attached_ = false;
-  if (content_view_core_)
-    content_view_core_->RemoveLayer(layer_);
+  are_layers_attached_ = false;
+  RemoveLayers();
 }
 
 bool RenderWidgetHostViewAndroid::IsShowing() {
   // ContentViewCoreImpl represents the native side of the Java
   // ContentViewCore.  It being NULL means that it is not attached
   // to the View system yet, so we treat this RWHVA as hidden.
-  return is_layer_attached_ && content_view_core_;
+  return are_layers_attached_ && content_view_core_;
 }
 
 gfx::Rect RenderWidgetHostViewAndroid::GetViewBounds() const {
   if (!content_view_core_)
     return gfx::Rect();
 
   // If the backing hasn't been initialized yet, report empty view bounds
   // as well. Otherwise, we may end up stuck in a white-screen state because
   // the resize ack is sent after swapbuffers.
   if (GetPhysicalBackingSize().IsEmpty())
@@ skipping 82 matching lines @@
     const std::vector<gfx::Rect>& copy_rects) {
   NOTIMPLEMENTED();
 }
 
 void RenderWidgetHostViewAndroid::RenderViewGone(
     base::TerminationStatus status, int error_code) {
   Destroy();
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
-  if (content_view_core_) {
-    content_view_core_->RemoveLayer(layer_);
-    content_view_core_ = NULL;
-  }
+  RemoveLayers();
+  content_view_core_ = NULL;
+
+  overscroll_effect_.reset();
 
   // The RenderWidgetHost's destruction led here, so don't call it.
   host_ = NULL;
 
   delete this;
 }
 
 void RenderWidgetHostViewAndroid::SetTooltipText(
     const string16& tooltip_text) {
   // Tooltips don't makes sense on Android.
@@ skipping 110 matching lines @@
   if (texture_size.GetArea() > 0)
     offset = frame->metadata.location_bar_content_translation;
   offset.set_y(offset.y() + frame->metadata.overdraw_bottom_height);
   gfx::SizeF content_size(texture_size.width() - offset.x() * dp2px,
                           texture_size.height() - offset.y() * dp2px);
   BuffersSwapped(frame->gl_frame_data->mailbox,
                  texture_size,
                  content_size,
                  callback);
 
+  if (overscroll_effect_) {
+    // Disable left/right edge effects when fully zoomed out.
+    const cc::CompositorFrameMetadata& metadata = frame->metadata;
+    bool horizontal_scrolling_possible =
+        metadata.page_scale_factor != metadata.min_page_scale_factor &&
+        metadata.root_layer_size.width() != metadata.viewport_size.width();
+
+    overscroll_effect_->set_horizontal_overscroll_enabled(
+        horizontal_scrolling_possible);
+    overscroll_effect_->set_size(content_size);
+  }
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   NOTREACHED() << "Deprecated. Use --composite-to-mailbox.";
 
   if (params.mailbox_name.empty())
     return;
 
@@ skipping 51 matching lines @@
   if (texture_size.GetArea() > 0) {
     uv_max.SetPoint(content_size.width() / texture_size.width(),
                     content_size.height() / texture_size.height());
   }
   texture_layer_->SetUV(gfx::PointF(0, 0), uv_max);
   texture_size_in_layer_ = texture_size;
   current_mailbox_ = mailbox;
   ack_callback.Run();
 }
 
+void RenderWidgetHostViewAndroid::AttachLayers() {
+  if (!content_view_core_)
+    return;
+
+  content_view_core_->AttachLayer(layer_);
+
+  if (overscroll_effect_)
+    overscroll_effect_->set_parent_layer(content_view_core_->GetLayer());
+}
+
+void RenderWidgetHostViewAndroid::RemoveLayers() {
+  if (!content_view_core_)
+    return;
+
+  if (overscroll_effect_)
+    overscroll_effect_->set_parent_layer(NULL);
+
+  content_view_core_->RemoveLayer(layer_);
+}
+
+void RenderWidgetHostViewAndroid::AnimationCallback() {
+  if (overscroll_effect_ && overscroll_effect_->Animate(base::TimeTicks::Now()))
+    ScheduleAnimation();
+}
+
+void RenderWidgetHostViewAndroid::ScheduleAnimation() {
+  if (animation_timer_.IsRunning() || !overscroll_effect_)
+    return;
+
+  const base::TimeDelta animationInterval
+      = base::TimeDelta::FromMilliseconds(kDesiredAnimationIntervalInMs);
+
+  animation_timer_.Start(FROM_HERE, animationInterval, this,

[mkosiba (inactive), 2013/04/22 16:24:53]

I'm not familiar with how animations work, so I apologize if it's a silly
question.
How is this synchronized with VSync? If the animation update tick isn't in sync
with the how CC produces frames won't the animation be janky?

[jdduke (slow), 2013/04/22 17:18:16]

It's not synchronized :) The timer hack was really only intended to get things
working quickly.  In practice, it works fairly well, but only because the effect
lacks any kind of sharp contrast with the background.

I've been waiting on https://chromiumcodereview.appspot.com/11959036 for vsync
hooks, which just landed. That will be the next addition.

+                         &RenderWidgetHostViewAndroid::AnimationCallback);
+}
+
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
@@ skipping 117 matching lines @@
 
 void RenderWidgetHostViewAndroid::MoveCaret(const gfx::Point& point) {
   if (host_)
     host_->MoveCaret(point);
 }
 
 SkColor RenderWidgetHostViewAndroid::GetCachedBackgroundColor() const {
   return cached_background_color_;
 }
 
+void RenderWidgetHostViewAndroid::OnOverscrolled(
+    const gfx::Vector2dF& accumulated_overscroll,
+    const gfx::Vector2dF& current_fling_velocity) {
+  if (overscroll_effect_) {
+    overscroll_effect_->OnOverscrolled(base::TimeTicks::Now(),
+                                       accumulated_overscroll,
+                                       current_fling_velocity);
+    ScheduleAnimation();
+  }
+}
+
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
-  if (content_view_core_ && is_layer_attached_)
-    content_view_core_->RemoveLayer(layer_);
+  if (are_layers_attached_)
+    RemoveLayers();
 
   content_view_core_ = content_view_core;
-  if (content_view_core_ && is_layer_attached_)
-    content_view_core_->AttachLayer(layer_);
+  if (are_layers_attached_)
+    AttachLayers();
 }
 
 void RenderWidgetHostViewAndroid::HasTouchEventHandlers(
     bool need_touch_events) {
   if (content_view_core_)
     content_view_core_->HasTouchEventHandlers(need_touch_events);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
@@ skipping 14 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content