[Android] Add a native pull-to-refresh overscroll effect

content/browser/android/overscroll_glow.cc

 // Copyright (c) 2013 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/android/overscroll_glow.h"
 
 #include "cc/layers/layer.h"
 #include "content/browser/android/edge_effect_base.h"
 
 using std::max;
@@ skipping 59 matching lines @@
     default:
       NOTREACHED() << "Invalid edge: " << edge;
       return gfx::SizeF();
   };
 }
 
 }  // namespace
 
 OverscrollGlow::OverscrollGlow(const EdgeEffectProvider& edge_effect_provider)
     : edge_effect_provider_(edge_effect_provider),
-      enabled_(true),
+      edge_offsets_(),
       initialized_(false) {
   DCHECK(!edge_effect_provider_.is_null());
 }
 
 OverscrollGlow::~OverscrollGlow() {
   Detach();
 }
 
-void OverscrollGlow::Enable() {
-  enabled_ = true;
+void OverscrollGlow::Reset() {
+  if (!initialized_)
+    return;
+  Detach();
+  for (size_t i = 0; i < EDGE_COUNT; ++i)
+    edge_effects_[i]->Finish();
 }
 
-void OverscrollGlow::Disable() {
-  if (!enabled_)
-    return;
-  enabled_ = false;
-  if (!enabled_ && initialized_) {
-    Detach();
-    for (size_t i = 0; i < EDGE_COUNT; ++i)
-      edge_effects_[i]->Finish();
-  }
-}
-
-bool OverscrollGlow::OnOverscrolled(cc::Layer* overscrolling_layer,
-                                    base::TimeTicks current_time,
+bool OverscrollGlow::OnOverscrolled(base::TimeTicks current_time,
                                     gfx::Vector2dF accumulated_overscroll,
                                     gfx::Vector2dF overscroll_delta,
                                     gfx::Vector2dF velocity,
                                     gfx::Vector2dF displacement) {
-  DCHECK(overscrolling_layer);
-
-  if (!enabled_)
-    return false;
-
   // The size of the glow determines the relative effect of the inputs; an
   // empty-sized effect is effectively disabled.
-  if (display_params_.size.IsEmpty())
+  if (viewport_size_.IsEmpty())
     return false;
 
   // Ignore sufficiently small values that won't meaningfuly affect animation.
   overscroll_delta = ZeroSmallComponents(overscroll_delta);
   if (overscroll_delta.IsZero()) {
-    if (initialized_) {
+    if (initialized_)
       Release(current_time);
-      UpdateLayerAttachment(overscrolling_layer);
-    }
-    return NeedsAnimate();
+    return CheckNeedsAnimate();
   }
 
   if (!InitializeIfNecessary())
     return false;
 
   gfx::Vector2dF old_overscroll = accumulated_overscroll - overscroll_delta;
   bool x_overscroll_started =
       !IsApproxZero(overscroll_delta.x()) && IsApproxZero(old_overscroll.x());
   bool y_overscroll_started =
       !IsApproxZero(overscroll_delta.y()) && IsApproxZero(old_overscroll.y());
 
   velocity = ZeroSmallComponents(velocity);
   if (!velocity.IsZero())
     Absorb(current_time, velocity, x_overscroll_started, y_overscroll_started);
   else
     Pull(current_time, overscroll_delta, displacement);
 
-  UpdateLayerAttachment(overscrolling_layer);
-  return NeedsAnimate();
+  return CheckNeedsAnimate();
 }
 
-bool OverscrollGlow::Animate(base::TimeTicks current_time) {
-  if (!NeedsAnimate()) {
+bool OverscrollGlow::Animate(base::TimeTicks current_time,
+                             cc::Layer* parent_layer) {
+  DCHECK(parent_layer);
+  if (!CheckNeedsAnimate())
+    return false;
+
+  UpdateLayerAttachment(parent_layer);
+
+  for (size_t i = 0; i < EDGE_COUNT; ++i) {
+    if (edge_effects_[i]->Update(current_time)) {
+      Edge edge = static_cast<Edge>(i);
+      edge_effects_[i]->ApplyToLayers(
+          ComputeSize(edge, viewport_size_),
+          ComputeTransform(edge, viewport_size_, edge_offsets_[i]));
+    }
+  }
+
+  return CheckNeedsAnimate();
+}
+
+void OverscrollGlow::UpdateDisplay(
+    const gfx::SizeF& viewport_size,
+    const gfx::SizeF& content_size,
+    const gfx::Vector2dF& content_scroll_offset) {
+  viewport_size_ = viewport_size;
+  edge_offsets_[OverscrollGlow::EDGE_TOP] = -content_scroll_offset.y();
+  edge_offsets_[OverscrollGlow::EDGE_LEFT] = -content_scroll_offset.x();
+  edge_offsets_[OverscrollGlow::EDGE_BOTTOM] = content_size.height() -
+                                               content_scroll_offset.y() -
+                                               viewport_size.height();
+  edge_offsets_[OverscrollGlow::EDGE_RIGHT] =
+      content_size.width() - content_scroll_offset.x() - viewport_size.width();
+}
+
+bool OverscrollGlow::CheckNeedsAnimate() {
+  if (!initialized_) {
     Detach();
     return false;
   }
 
   for (size_t i = 0; i < EDGE_COUNT; ++i) {
-    if (edge_effects_[i]->Update(current_time)) {
-      Edge edge = static_cast<Edge>(i);
-      edge_effects_[i]->ApplyToLayers(
-          ComputeSize(edge, display_params_.size),
-          ComputeTransform(
-              edge, display_params_.size, display_params_.edge_offsets[i]));
-    }
-  }
-
-  if (!NeedsAnimate()) {
-    Detach();
-    return false;
-  }
-
-  return true;
-}
-
-void OverscrollGlow::UpdateDisplayParameters(const DisplayParameters& params) {
-  display_params_ = params;
-}
-
-bool OverscrollGlow::NeedsAnimate() const {
-  if (!enabled_ || !initialized_)
-    return false;
-  for (size_t i = 0; i < EDGE_COUNT; ++i) {
     if (!edge_effects_[i]->IsFinished())
       return true;
   }
+
+  Detach();
   return false;
 }
 
 void OverscrollGlow::UpdateLayerAttachment(cc::Layer* parent) {
   DCHECK(parent);
   if (!root_layer_.get())
     return;
 
-  if (!NeedsAnimate()) {
-    Detach();
+  if (!CheckNeedsAnimate())
     return;
-  }
 
   if (root_layer_->parent() != parent)
     parent->AddChild(root_layer_);
 
   for (size_t i = 0; i < EDGE_COUNT; ++i)
     edge_effects_[i]->SetParent(root_layer_.get());
 }
 
 void OverscrollGlow::Detach() {
   if (root_layer_.get())
     root_layer_->RemoveFromParent();
 }
 
 bool OverscrollGlow::InitializeIfNecessary() {
-  DCHECK(enabled_);
   if (initialized_)
     return true;
 
   DCHECK(!root_layer_.get());
   root_layer_ = cc::Layer::Create();
   for (size_t i = 0; i < EDGE_COUNT; ++i) {
     edge_effects_[i] = edge_effect_provider_.Run();
     DCHECK(edge_effects_[i]);
   }
 
   initialized_ = true;
   return true;
 }
 
 void OverscrollGlow::Pull(base::TimeTicks current_time,
                           const gfx::Vector2dF& overscroll_delta,
                           const gfx::Vector2dF& overscroll_location) {
-  DCHECK(enabled_ && initialized_);
+  DCHECK(initialized_);
   DCHECK(!overscroll_delta.IsZero());
-  const float inv_width = 1.f / display_params_.size.width();
-  const float inv_height = 1.f / display_params_.size.height();
+  DCHECK(!viewport_size_.IsEmpty());
+  const float inv_width = 1.f / viewport_size_.width();
+  const float inv_height = 1.f / viewport_size_.height();
 
   gfx::Vector2dF overscroll_pull =
       gfx::ScaleVector2d(overscroll_delta, inv_width, inv_height);
   const float edge_pull[EDGE_COUNT] = {
       min(overscroll_pull.y(), 0.f),  // Top
       min(overscroll_pull.x(), 0.f),  // Left
       max(overscroll_pull.y(), 0.f),  // Bottom
       max(overscroll_pull.x(), 0.f)   // Right
   };
 
@@ skipping 15 matching lines @@
     edge_effects_[i]->Pull(
         current_time, std::abs(edge_pull[i]), edge_displacement[i]);
     GetOppositeEdge(i)->Release(current_time);
   }
 }
 
 void OverscrollGlow::Absorb(base::TimeTicks current_time,
                             const gfx::Vector2dF& velocity,
                             bool x_overscroll_started,
                             bool y_overscroll_started) {
-  DCHECK(enabled_ && initialized_);
+  DCHECK(initialized_);
   DCHECK(!velocity.IsZero());
 
   // Only trigger on initial overscroll at a non-zero velocity
   const float overscroll_velocities[EDGE_COUNT] = {
       y_overscroll_started ? min(velocity.y(), 0.f) : 0,  // Top
       x_overscroll_started ? min(velocity.x(), 0.f) : 0,  // Left
       y_overscroll_started ? max(velocity.y(), 0.f) : 0,  // Bottom
       x_overscroll_started ? max(velocity.x(), 0.f) : 0   // Right
   };
 
@@ skipping 10 matching lines @@
   DCHECK(initialized_);
   for (size_t i = 0; i < EDGE_COUNT; ++i)
     edge_effects_[i]->Release(current_time);
 }
 
 EdgeEffectBase* OverscrollGlow::GetOppositeEdge(int edge_index) {
   DCHECK(initialized_);
   return edge_effects_[(edge_index + 2) % EDGE_COUNT].get();
 }
 
-OverscrollGlow::DisplayParameters::DisplayParameters() {
-  edge_offsets[0] = edge_offsets[1] = edge_offsets[2] = edge_offsets[3] = 0.f;
-}
-
 }  // namespace content