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"
@@ skipping 30 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),
-      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();
     layer_->SetIsDrawable(true);
   } 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 188 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 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 (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(
     const GURL& content_url) {
   if (content_view_core_)
     content_view_core_->StartContentIntent(content_url);
 }
 
 void RenderWidgetHostViewAndroid::ImeCancelComposition() {
   ime_adapter_android_.CancelComposition();
@@ skipping 10 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();

[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;
 
   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 &&

[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(
     const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params,
     int gpu_host_id) {
   NOTREACHED() << "Deprecated. Use --composite-to-mailbox.";
 
   if (params.mailbox_name.empty())
     return;
 
@@ skipping 57 matching lines @@
   current_mailbox_ = mailbox;
 
   if (consumed_current_texture_ || host_->is_hidden())
     ack_callback.Run();
   else
     ack_callbacks_.push(ack_callback);
 
   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) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
@@ skipping 118 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) {
   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 37 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content