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/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 "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebExternalTextureLayer.h"
@@ skipping 32 matching lines @@
   if (!return_mailbox.IsZero()) {
     ack.gl_frame_data->mailbox = return_mailbox;
     ack.gl_frame_data->size = return_size;
     ack.gl_frame_data->sync_point =
         ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
   }
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
       route_id, renderer_host_id, ack);
 }
 
+scoped_ptr<OverscrollGlow> CreateOverscrollEffect(
+    ContentViewCoreImpl* content_view_core){
+  if (content_view_core != NULL &&
+      !content_view_core->get_overscroll_edge().isNull() &&
+      !content_view_core->get_overscroll_glow().isNull()) {
+    return make_scoped_ptr(
+        new OverscrollGlow(content_view_core->get_overscroll_edge(),
+                           content_view_core->get_overscroll_glow()));
+  }
+  return scoped_ptr<OverscrollGlow>();
+}
+
 }  // 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) {
+      texture_id_in_layer_(0),
+      overscroll_resources_updated_(true) {
   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);
@@ skipping 191 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 60 matching lines @@
   if (content_view_core_)
     content_view_core_->OnBackgroundColorChanged(color);
 }
 
 void RenderWidgetHostViewAndroid::OnStartContentIntent(
     const GURL& content_url) {
   if (content_view_core_)
     content_view_core_->StartContentIntent(content_url);
 }
 
+void RenderWidgetHostViewAndroid::OnSetOverscrollResources() {
+  overscroll_resources_updated_ = true;
+}
+
 void RenderWidgetHostViewAndroid::ImeCancelComposition() {
   ime_adapter_android_.CancelComposition();
 }
 
 void RenderWidgetHostViewAndroid::ImeCompositionRangeChanged(
     const ui::Range& range,
     const std::vector<gfx::Rect>& character_bounds) {
 }
 
 void RenderWidgetHostViewAndroid::DidUpdateBackingStore(
     const gfx::Rect& scroll_rect,
     const gfx::Vector2d& scroll_delta,
     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 158 matching lines @@
   // We need to tell ContentViewCore about the new frame before calling
   // setNeedsDisplay() below so that it has the needed information schedule the
   // next compositor frame.
   if (content_view_core_)
     content_view_core_->DidProduceRendererFrame();
 
   texture_layer_->SetNeedsDisplay();
   texture_layer_->SetBounds(gfx::Size(content_size.width(),
                                       content_size.height()));
 
+  if (overscroll_resources_updated_) {
+    SetOverscrollEffect(CreateOverscrollEffect(content_view_core_));
+    overscroll_resources_updated_ = false;
+  }
+  if (overscroll_effect_)
+    overscroll_effect_->set_size(content_size);
+
   // Calculate the uv_max based on the content size relative to the texture
   // size.
   gfx::PointF uv_max;
   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::SetOverscrollEffect(
+    scoped_ptr<OverscrollGlow> overscroll_effect) {
+  animation_timer_.Stop();
+  overscroll_effect_.swap(overscroll_effect);
+  if (content_view_core_ && are_layers_attached_)
+    overscroll_effect_->set_parent_layer(content_view_core_->GetLayer());
+}
+
+void RenderWidgetHostViewAndroid::AnimationCallback() {
+  if (overscroll_effect_ && overscroll_effect_->Animate(base::TimeTicks::Now()))
+    AnimateIfNeeded();
+}
+
+void RenderWidgetHostViewAndroid::AnimateIfNeeded() {
+  if (animation_timer_.IsRunning() || !overscroll_effect_)
+    return;
+
+  const base::TimeDelta animationInterval
+      = base::TimeDelta::FromMilliseconds(kDesiredAnimationIntervalInMs);
+
+  animation_timer_.Start(FROM_HERE, animationInterval, this,
+                         &RenderWidgetHostViewAndroid::AnimationCallback);
+}
+
 void RenderWidgetHostViewAndroid::AcceleratedSurfacePostSubBuffer(
     const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params,
     int gpu_host_id) {
   NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::AcceleratedSurfaceSuspend() {
   NOTREACHED();
 }
 
@@ skipping 133 matching lines @@
     const gfx::Vector2dF& controls_offset,
     const gfx::Vector2dF& content_offset,
     float overdraw_bottom_height) {
   if (content_view_core_) {
     // All offsets and sizes are in CSS pixels.
     content_view_core_->UpdateFrameInfo(
         scroll_offset, page_scale_factor, page_scale_factor_limits,
         content_size, viewport_size, controls_offset, content_offset,
         overdraw_bottom_height);
   }
+
+  if (overscroll_effect_)
+    overscroll_effect_->set_horizontal_overscroll_enabled(
+        content_size.width() != viewport_size.width());
+
+}
+
+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);
+    AnimateIfNeeded();
+  }
 }
 
 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