Add overscroll edge effect animations for Android.

content/browser/renderer_host/render_widget_host_view_android.cc

Index: content/browser/renderer_host/render_widget_host_view_android.cc
diff --git a/content/browser/renderer_host/render_widget_host_view_android.cc b/content/browser/renderer_host/render_widget_host_view_android.cc
index 871f1f2819761863c55c4760ef1c4cde55bbcd4e..7cd8cd58d63ecd7fc33164679f5a2829ed4ac6ce 100644
--- a/content/browser/renderer_host/render_widget_host_view_android.cc
+++ b/content/browser/renderer_host/render_widget_host_view_android.cc
@@ -7,6 +7,7 @@
 #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"
@@ -15,6 +16,7 @@
 #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"
@@ -23,6 +25,7 @@
 #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"
@@ -73,12 +76,15 @@ 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),
-      consumed_current_texture_(true) {
+      consumed_current_texture_(true),
+      vsync_notifications_enabled_(false),
+      client_vsync_notifications_enabled_(false),
+      animation_vsync_notifications_enabled_(false) {
   if (CompositorImpl::UsesDirectGL()) {
     surface_texture_transport_.reset(new SurfaceTextureTransportClient());
     layer_ = surface_texture_transport_->Initialize();
@@ -90,6 +96,11 @@ RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
 
   layer_->SetContentsOpaque(true);
 
+  if (CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kEnableOverscrollEdgeEffect)) {
+    overscroll_effect_ = OverscrollGlow::Create();
+  }
+
   host_->SetView(this);
   SetContentViewCore(content_view_core);
 }
@@ -298,28 +309,26 @@ bool RenderWidgetHostViewAndroid::IsSurfaceAvailableForCopy() const {
 }
 
 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 {
@@ -395,12 +404,25 @@ void RenderWidgetHostViewAndroid::OnDidChangeBodyBackgroundColor(
 }
 
 void RenderWidgetHostViewAndroid::SendVSync(base::TimeTicks frame_time) {
-  host_->Send(new ViewMsg_DidVSync(host_->GetRoutingID(), frame_time));
+  if (client_vsync_notifications_enabled_)
+    host_->Send(new ViewMsg_DidVSync(host_->GetRoutingID(), frame_time));
+  if (animation_vsync_notifications_enabled_)
+    Animate();
 }
 
 void RenderWidgetHostViewAndroid::OnSetVSyncNotificationEnabled(bool enabled) {
-  if (content_view_core_)
-    content_view_core_->SetVSyncNotificationEnabled(enabled);
+  client_vsync_notifications_enabled_ = enabled;
+  RequestVSyncNotificationsIfNecessary();
+}
+
+void RenderWidgetHostViewAndroid::RequestVSyncNotificationsIfNecessary() {
+  bool notifications_enabled = client_vsync_notifications_enabled_ ||
+                               animation_vsync_notifications_enabled_;
+  if (notifications_enabled != vsync_notifications_enabled_) {

[aelias_OOO_until_Jul13, 2013/04/22 23:46:48]

I think this vsync_notifications_enabled_ value isn't needed.  Let's just always
call into content_view_core_ regardless of whether it changed or not, there's no
need for throttling.

[jdduke (slow), 2013/04/23 16:02:13]

Are you sure? Every enable/disable call will affect the mVSyncSubscriberCount in
ContentViewCore.java.  If these calls are not balanced, we'll run into issues.

Now, because it uses a subscriber count, all rwhva needs to  track is
animation_vsync_notifications_enabled_. The renderer and animation can subscribe
independently via content_view_core_->SetVSyncNotificationEnabled. However,
I'm somewhat hesitant to do that, as we're then coupled to implementation
details we shouldn't have to be aware of...

+    if (content_view_core_)
+      content_view_core_->SetVSyncNotificationEnabled(notifications_enabled);
+    vsync_notifications_enabled_ = notifications_enabled;
+  }
 }
 
 void RenderWidgetHostViewAndroid::OnStartContentIntent(
@@ -431,10 +453,10 @@ void RenderWidgetHostViewAndroid::RenderViewGone(
 }
 
 void RenderWidgetHostViewAndroid::Destroy() {
-  if (content_view_core_) {
-    content_view_core_->RemoveLayer(layer_);
-    content_view_core_ = NULL;
-  }
+  RemoveLayers();
+  content_view_core_ = NULL;
+
+  overscroll_effect_.reset();

[aelias_OOO_until_Jul13, 2013/04/22 23:46:48]

Delete this line, we can rely on the destructor.

[jdduke (slow), 2013/04/23 16:02:13]

Right, I had it here as I was unsure of the behavior behind timer callbacks, but
we don't even use that anymore.

 
   // The RenderWidgetHost's destruction led here, so don't call it.
   host_ = NULL;
@@ -565,6 +587,17 @@ void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
                  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 &&

[aelias_OOO_until_Jul13, 2013/04/22 23:46:48]

Can this page scale factor comparison be removed?  The viewport_size check
should be sufficient.  This extra check is also incorrect in the case where the
viewport tag forces the minimum scale constraint to an unusual value.

[jdduke (slow), 2013/04/23 16:02:13]

I added the page scale check when I noticed certain pages weren't satisfying the
viewport dimension constraint. I'll do some more checking. 

+        metadata.root_layer_size.width() != metadata.viewport_size.width();
+
+    overscroll_effect_->set_horizontal_overscroll_enabled(

[aelias_OOO_until_Jul13, 2013/04/22 23:46:48]

There should be an analogous check for the vertical effect.  If I try to scroll
a non-vertically scrollable Android system view (such as Settings->Display), no
vertical overscroll effect is visible.

[jdduke (slow), 2013/04/23 16:02:13]

Right, for whatever reason I thought it still showed up. Thanks.

+        horizontal_scrolling_possible);
+    overscroll_effect_->set_size(content_size);
+  }
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceBuffersSwapped(
@@ -642,6 +675,39 @@ void RenderWidgetHostViewAndroid::BuffersSwapped(
   consumed_current_texture_ = false;
 }
 
+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::Animate() {
+  if (!overscroll_effect_)
+   return;
+  overscroll_effect_->Animate(base::TimeTicks::Now());
+  ScheduleAnimation();
+}
+
+void RenderWidgetHostViewAndroid::ScheduleAnimation() {
+  animation_vsync_notifications_enabled_ = overscroll_effect_ &&
+                                           overscroll_effect_->IsAnimating();
+  RequestVSyncNotificationsIfNecessary();
+}
+
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
@@ -780,16 +846,28 @@ 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) {
   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() {