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/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "cc/layers/delegated_renderer_layer.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/browser/renderer_host/touch_smooth_scroll_gesture_android.h"
 #include "content/common/gpu/client/gl_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/input_messages.h"
 #include "content/common/view_messages.h"
@@ skipping 37 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_(this),
       cached_background_color_(SK_ColorWHITE),
       texture_id_in_layer_(0),
       weak_ptr_factory_(this) {
   if (CompositorImpl::UsesDirectGL()) {
     surface_texture_transport_.reset(new SurfaceTextureTransportClient());
     layer_ = surface_texture_transport_->Initialize();
     layer_->SetIsDrawable(true);
   } else {
     if (CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kEnableDelegatedRenderer)) {
       delegated_renderer_layer_ = cc::DelegatedRendererLayer::Create(this);
       layer_ = delegated_renderer_layer_;
     } else {
       texture_layer_ = cc::TextureLayer::Create(this);
       layer_ = texture_layer_;
     }
   }
 
   layer_->SetContentsOpaque(true);
 
+  if (CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kEnableOverscrollEdgeEffect)) {
+    overscroll_effect_ = OverscrollGlow::Create();
+  }
+
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 }
 
 RenderWidgetHostViewAndroid::~RenderWidgetHostViewAndroid() {
   SetContentViewCore(NULL);
   DCHECK(ack_callbacks_.empty());
   if (texture_id_in_layer_ || !last_mailbox_.IsZero()) {
     ImageTransportFactoryAndroid* factory =
         ImageTransportFactoryAndroid::GetInstance();
@@ skipping 174 matching lines @@
   host_->Focus();
   host_->SetInputMethodActive(true);
   ResetClipping();
 }
 
 void RenderWidgetHostViewAndroid::Blur() {
   host_->Send(new InputMsg_ExecuteEditCommand(
       host_->GetRoutingID(), "Unselect", ""));
   host_->SetInputMethodActive(false);
   host_->Blur();
+
+  if (overscroll_effect_)
+    overscroll_effect_->Finish();
 }
 
 bool RenderWidgetHostViewAndroid::HasFocus() const {
   if (!content_view_core_)
     return false;  // ContentViewCore not created yet.
 
   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 55 matching lines @@
     SkColor color) {
   if (cached_background_color_ == color)
     return;
 
   cached_background_color_ = color;
   if (content_view_core_)
     content_view_core_->OnBackgroundColorChanged(color);
 }
 
 void RenderWidgetHostViewAndroid::SendVSync(base::TimeTicks frame_time) {
-  host_->Send(new ViewMsg_DidVSync(host_->GetRoutingID(), frame_time));
+  if (host_)
+    host_->Send(new ViewMsg_DidVSync(host_->GetRoutingID(), frame_time));
 }
 
 void RenderWidgetHostViewAndroid::OnSetVSyncNotificationEnabled(bool enabled) {
   if (content_view_core_)
     content_view_core_->SetVSyncNotificationEnabled(enabled);
 }
 
 void RenderWidgetHostViewAndroid::OnStartContentIntent(
     const GURL& content_url) {
   if (content_view_core_)
@@ skipping 15 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;
 
   // 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 116 matching lines @@
     const cc::CompositorFrame* frame) {
   // Calculate the content size.  This should be 0 if the texture_size is 0.
   gfx::Vector2dF offset;
   if (texture_size_in_layer_.GetArea() > 0)
     offset = frame->metadata.location_bar_content_translation;
   offset.set_y(offset.y() + frame->metadata.overdraw_bottom_height);
   offset.Scale(frame->metadata.device_scale_factor);
   content_size_in_layer_ =
       gfx::Size(texture_size_in_layer_.width() - offset.x(),
                 texture_size_in_layer_.height() - offset.y());
+  // Content size changes should be reflected in associated animation effects.
+  UpdateAnimationSize(frame);
 }
 
 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
     scoped_ptr<cc::CompositorFrame> frame) {
   // Always let ContentViewCore know about the new frame first, so it can decide
   // to schedule a Draw immediately when it sees the texture layer invalidation.
   if (content_view_core_) {
     // All offsets and sizes are in CSS pixels.
     content_view_core_->UpdateFrameInfo(
         frame->metadata.root_scroll_offset,
@@ skipping 93 matching lines @@
   ResetClipping();
 
   current_mailbox_ = mailbox;
 
   if (host_->is_hidden())
     ack_callback.Run();
   else
     ack_callbacks_.push(ack_callback);
 }
 
+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());

[no sievers, 2013/05/13 18:38:24]

Is it hard to change it so that it actually attaches it to the tree here (and
detaches below) rather than remembering a reference and attaching to the parent
at draw (or rather animate) time (see EdgeEffect::Draw())?

[jdduke (slow), 2013/05/13 20:44:24]

Yeah, I went back and forth on this as well.  The reasoning for the current
approach is that, as an EdgeEffect becomes dormant, it detaches its layers from
the parent layer.  ImageLayers (currently) can't clip themselves, so this
prevents RenderSurface promotion down the pipeline, and generally avoids
cluttering the layer tree.

So, either the EdgeEffect needs to cache its parent for when it's re-activated,
or OverscrollGlow needs to cache the parent and we just update it if necessary
at every Draw call.

The other thought I had was making an intermediate (but permanent) parent layer
in OverscrollGlow, and let RWHVA set the parent of that just like it sets the
parent of its owned layer_.

[no sievers, 2013/05/13 20:53:22]

And it doesn't work to just make it not drawable or so?

+}
+
+void RenderWidgetHostViewAndroid::RemoveLayers() {
+  if (!content_view_core_)
+    return;
+
+  if (overscroll_effect_)
+    overscroll_effect_->set_parent_layer(NULL);
+
+  content_view_core_->RemoveLayer(layer_);
+}
+
+bool RenderWidgetHostViewAndroid::Animate(base::TimeTicks frame_time) {
+  if (!overscroll_effect_ || !HasFocus())
+    return false;
+  return overscroll_effect_->Animate(frame_time);
+}
+
+void RenderWidgetHostViewAndroid::UpdateAnimationSize(
+    const cc::CompositorFrame* frame) {
+  if (!overscroll_effect_)
+    return;
+  // Disable edge effects for axes on which scrolling is impossible.
+  const cc::CompositorFrameMetadata& metadata = frame->metadata;
+  overscroll_effect_->set_horizontal_overscroll_enabled(
+      metadata.root_layer_size.width() != metadata.viewport_size.width());
+  overscroll_effect_->set_vertical_overscroll_enabled(
+      metadata.root_layer_size.height() != metadata.viewport_size.height());
+  overscroll_effect_->set_size(content_size_in_layer_);
+}
+
+void RenderWidgetHostViewAndroid::ScheduleAnimationIfNecessary() {
+  if (!content_view_core_)
+    return;
+  if (overscroll_effect_ && overscroll_effect_->IsActive())
+    content_view_core_->SetNeedsAnimate();
+}
+
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
@@ skipping 162 matching lines @@
       gfx::PointF(offset.x() * uv_scale.x(),
                   offset.y() * uv_scale.y()),
       gfx::PointF((offset.x() + clipped_content.width()) * uv_scale.x(),
                   (offset.y() + clipped_content.height()) * uv_scale.y()));
 }
 
 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_ || !HasFocus())
+    return;
+  overscroll_effect_->OnOverscrolled(base::TimeTicks::Now(),
+                                     accumulated_overscroll,
+                                     current_fling_velocity);
+  ScheduleAnimationIfNecessary();
+}
+
 void RenderWidgetHostViewAndroid::SetContentViewCore(
     ContentViewCoreImpl* content_view_core) {
   RunAckCallbacks();
 
-  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::RunAckCallbacks() {
   while (!ack_callbacks_.empty()) {
     ack_callbacks_.front().Run();
     ack_callbacks_.pop();
   }
 }
 
 void RenderWidgetHostViewAndroid::HasTouchEventHandlers(
@@ skipping 40 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content