android: move overscroll effects to ui/

content/browser/android/edge_effect.cc

Index: content/browser/android/edge_effect.cc
diff --git a/content/browser/android/edge_effect.cc b/content/browser/android/edge_effect.cc
deleted file mode 100644
index df84c3f277517eaac89415baefd9618c92d735d3..0000000000000000000000000000000000000000
--- a/content/browser/android/edge_effect.cc
+++ /dev/null
@@ -1,360 +0,0 @@
-// 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/edge_effect.h"
-
-#include "cc/layers/layer.h"
-#include "cc/layers/ui_resource_layer.h"
-#include "content/browser/android/animation_utils.h"
-#include "content/public/browser/android/compositor.h"
-#include "ui/android/resources/resource_manager.h"
-#include "ui/android/resources/system_ui_resource_type.h"
-
-namespace content {
-
-namespace {
-
-const ui::SystemUIResourceType kEdgeResourceId = ui::OVERSCROLL_EDGE;
-const ui::SystemUIResourceType kGlowResourceId = ui::OVERSCROLL_GLOW;
-
-// Time it will take the effect to fully recede in ms
-const int kRecedeTimeMs = 1000;
-
-// Time it will take before a pulled glow begins receding in ms
-const int kPullTimeMs = 167;
-
-// Time it will take in ms for a pulled glow to decay before release
-const int kPullDecayTimeMs = 1000;
-
-const float kMaxAlpha = 1.f;
-const float kHeldEdgeScaleY = .5f;
-
-const float kMaxGlowHeight = 4.f;
-
-const float kPullGlowBegin = 1.f;
-const float kPullEdgeBegin = 0.6f;
-
-// Min/max velocity that will be absorbed
-const float kMinVelocity = 100.f;
-const float kMaxVelocity = 10000.f;
-
-const float kEpsilon = 0.001f;
-
-const float kGlowHeightWidthRatio = 0.25f;
-
-// How much dragging should effect the height of the edge image.
-// Number determined by user testing.
-const int kPullDistanceEdgeFactor = 7;
-
-// How much dragging should effect the height of the glow image.
-// Number determined by user testing.
-const int kPullDistanceGlowFactor = 7;
-const float kPullDistanceAlphaGlowFactor = 1.1f;
-
-const int kVelocityEdgeFactor = 8;
-const int kVelocityGlowFactor = 12;
-
-const float kEdgeHeightAtMdpi = 12.f;
-const float kGlowHeightAtMdpi = 128.f;
-
-}  // namespace
-
-class EdgeEffect::EffectLayer {
- public:
-  EffectLayer(ui::SystemUIResourceType resource_type,
-              ui::ResourceManager* resource_manager)
-      : ui_resource_layer_(
-            cc::UIResourceLayer::Create(Compositor::LayerSettings())),
-        resource_type_(resource_type),
-        resource_manager_(resource_manager) {}
-
-  ~EffectLayer() { ui_resource_layer_->RemoveFromParent(); }
-
-  void SetParent(cc::Layer* parent) {
-    if (ui_resource_layer_->parent() != parent)
-      parent->AddChild(ui_resource_layer_);
-  }
-
-  void Disable() { ui_resource_layer_->SetIsDrawable(false); }
-
-  void Update(const gfx::Size& size,
-              const gfx::Transform& transform,
-              float opacity) {
-    ui_resource_layer_->SetUIResourceId(resource_manager_->GetUIResourceId(
-        ui::ANDROID_RESOURCE_TYPE_SYSTEM, resource_type_));
-    ui_resource_layer_->SetIsDrawable(true);
-    ui_resource_layer_->SetTransformOrigin(
-        gfx::Point3F(size.width() * 0.5f, 0, 0));
-    ui_resource_layer_->SetTransform(transform);
-    ui_resource_layer_->SetBounds(size);
-    ui_resource_layer_->SetOpacity(Clamp(opacity, 0.f, 1.f));
-  }
-
-  scoped_refptr<cc::UIResourceLayer> ui_resource_layer_;
-  ui::SystemUIResourceType resource_type_;
-  ui::ResourceManager* resource_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(EffectLayer);
-};
-
-EdgeEffect::EdgeEffect(ui::ResourceManager* resource_manager,
-                       float device_scale_factor)
-    : edge_(new EffectLayer(kEdgeResourceId, resource_manager)),
-      glow_(new EffectLayer(kGlowResourceId, resource_manager)),
-      base_edge_height_(kEdgeHeightAtMdpi * device_scale_factor),
-      base_glow_height_(kGlowHeightAtMdpi * device_scale_factor),
-      edge_alpha_(0),
-      edge_scale_y_(0),
-      glow_alpha_(0),
-      glow_scale_y_(0),
-      edge_alpha_start_(0),
-      edge_alpha_finish_(0),
-      edge_scale_y_start_(0),
-      edge_scale_y_finish_(0),
-      glow_alpha_start_(0),
-      glow_alpha_finish_(0),
-      glow_scale_y_start_(0),
-      glow_scale_y_finish_(0),
-      state_(STATE_IDLE),
-      pull_distance_(0) {
-}
-
-EdgeEffect::~EdgeEffect() {
-}
-
-bool EdgeEffect::IsFinished() const {
-  return state_ == STATE_IDLE;
-}
-
-void EdgeEffect::Finish() {
-  edge_->Disable();
-  glow_->Disable();
-  pull_distance_ = 0;
-  state_ = STATE_IDLE;
-}
-
-void EdgeEffect::Pull(base::TimeTicks current_time,
-                      float delta_distance,
-                      float displacement) {
-  if (state_ == STATE_PULL_DECAY && current_time - start_time_ < duration_) {
-    return;
-  }
-  if (state_ != STATE_PULL) {
-    glow_scale_y_ = kPullGlowBegin;
-  }
-  state_ = STATE_PULL;
-
-  start_time_ = current_time;
-  duration_ = base::TimeDelta::FromMilliseconds(kPullTimeMs);
-
-  float abs_delta_distance = std::abs(delta_distance);
-  pull_distance_ += delta_distance;
-  float distance = std::abs(pull_distance_);
-
-  edge_alpha_ = edge_alpha_start_ = Clamp(distance, kPullEdgeBegin, kMaxAlpha);
-  edge_scale_y_ = edge_scale_y_start_ =
-      Clamp(distance * kPullDistanceEdgeFactor, kHeldEdgeScaleY, 1.f);
-
-  glow_alpha_ = glow_alpha_start_ =
-      std::min(kMaxAlpha,
-               glow_alpha_ + abs_delta_distance * kPullDistanceAlphaGlowFactor);
-
-  float glow_change = abs_delta_distance;
-  if (delta_distance > 0 && pull_distance_ < 0)
-    glow_change = -glow_change;
-  if (pull_distance_ == 0)
-    glow_scale_y_ = 0;
-
-  // Do not allow glow to get larger than kMaxGlowHeight.
-  glow_scale_y_ = glow_scale_y_start_ =
-      Clamp(glow_scale_y_ + glow_change * kPullDistanceGlowFactor,
-            0.f,
-            kMaxGlowHeight);
-
-  edge_alpha_finish_ = edge_alpha_;
-  edge_scale_y_finish_ = edge_scale_y_;
-  glow_alpha_finish_ = glow_alpha_;
-  glow_scale_y_finish_ = glow_scale_y_;
-}
-
-void EdgeEffect::Release(base::TimeTicks current_time) {
-  pull_distance_ = 0;
-
-  if (state_ != STATE_PULL && state_ != STATE_PULL_DECAY)
-    return;
-
-  state_ = STATE_RECEDE;
-  edge_alpha_start_ = edge_alpha_;
-  edge_scale_y_start_ = edge_scale_y_;
-  glow_alpha_start_ = glow_alpha_;
-  glow_scale_y_start_ = glow_scale_y_;
-
-  edge_alpha_finish_ = 0.f;
-  edge_scale_y_finish_ = 0.f;
-  glow_alpha_finish_ = 0.f;
-  glow_scale_y_finish_ = 0.f;
-
-  start_time_ = current_time;
-  duration_ = base::TimeDelta::FromMilliseconds(kRecedeTimeMs);
-}
-
-void EdgeEffect::Absorb(base::TimeTicks current_time, float velocity) {
-  state_ = STATE_ABSORB;
-  velocity = Clamp(std::abs(velocity), kMinVelocity, kMaxVelocity);
-
-  start_time_ = current_time;
-  // This should never be less than 1 millisecond.
-  duration_ = base::TimeDelta::FromMilliseconds(0.15f + (velocity * 0.02f));
-
-  // The edge should always be at least partially visible, regardless
-  // of velocity.
-  edge_alpha_start_ = 0.f;
-  edge_scale_y_ = edge_scale_y_start_ = 0.f;
-  // The glow depends more on the velocity, and therefore starts out
-  // nearly invisible.
-  glow_alpha_start_ = 0.3f;
-  glow_scale_y_start_ = 0.f;
-
-  // Factor the velocity by 8. Testing on device shows this works best to
-  // reflect the strength of the user's scrolling.
-  edge_alpha_finish_ = Clamp(velocity * kVelocityEdgeFactor, 0.f, 1.f);
-  // Edge should never get larger than the size of its asset.
-  edge_scale_y_finish_ =
-      Clamp(velocity * kVelocityEdgeFactor, kHeldEdgeScaleY, 1.f);
-
-  // Growth for the size of the glow should be quadratic to properly
-  // respond
-  // to a user's scrolling speed. The faster the scrolling speed, the more
-  // intense the effect should be for both the size and the saturation.
-  glow_scale_y_finish_ =
-      std::min(0.025f + (velocity * (velocity / 100) * 0.00015f), 1.75f);
-  // Alpha should change for the glow as well as size.
-  glow_alpha_finish_ = Clamp(
-      glow_alpha_start_, velocity * kVelocityGlowFactor * .00001f, kMaxAlpha);
-}
-
-bool EdgeEffect::Update(base::TimeTicks current_time) {
-  if (IsFinished())
-    return false;
-
-  const double dt = (current_time - start_time_).InMilliseconds();
-  const double t = std::min(dt / duration_.InMilliseconds(), 1.);
-  const float interp = static_cast<float>(Damp(t, 1.));
-
-  edge_alpha_ = Lerp(edge_alpha_start_, edge_alpha_finish_, interp);
-  edge_scale_y_ = Lerp(edge_scale_y_start_, edge_scale_y_finish_, interp);
-  glow_alpha_ = Lerp(glow_alpha_start_, glow_alpha_finish_, interp);
-  glow_scale_y_ = Lerp(glow_scale_y_start_, glow_scale_y_finish_, interp);
-
-  if (t >= 1.f - kEpsilon) {
-    switch (state_) {
-      case STATE_ABSORB:
-        state_ = STATE_RECEDE;
-        start_time_ = current_time;
-        duration_ = base::TimeDelta::FromMilliseconds(kRecedeTimeMs);
-
-        edge_alpha_start_ = edge_alpha_;
-        edge_scale_y_start_ = edge_scale_y_;
-        glow_alpha_start_ = glow_alpha_;
-        glow_scale_y_start_ = glow_scale_y_;
-
-        // After absorb, the glow and edge should fade to nothing.
-        edge_alpha_finish_ = 0.f;
-        edge_scale_y_finish_ = 0.f;
-        glow_alpha_finish_ = 0.f;
-        glow_scale_y_finish_ = 0.f;
-        break;
-      case STATE_PULL:
-        state_ = STATE_PULL_DECAY;
-        start_time_ = current_time;
-        duration_ = base::TimeDelta::FromMilliseconds(kPullDecayTimeMs);
-
-        edge_alpha_start_ = edge_alpha_;
-        edge_scale_y_start_ = edge_scale_y_;
-        glow_alpha_start_ = glow_alpha_;
-        glow_scale_y_start_ = glow_scale_y_;
-
-        // After pull, the glow and edge should fade to nothing.
-        edge_alpha_finish_ = 0.f;
-        edge_scale_y_finish_ = 0.f;
-        glow_alpha_finish_ = 0.f;
-        glow_scale_y_finish_ = 0.f;
-        break;
-      case STATE_PULL_DECAY: {
-        // When receding, we want edge to decrease more slowly
-        // than the glow.
-        const float factor =
-            glow_scale_y_finish_
-                ? 1 / (glow_scale_y_finish_ * glow_scale_y_finish_)
-                : std::numeric_limits<float>::max();
-        edge_scale_y_ =
-            edge_scale_y_start_ +
-            (edge_scale_y_finish_ - edge_scale_y_start_) * interp * factor;
-        state_ = STATE_RECEDE;
-      } break;
-      case STATE_RECEDE:
-        Finish();
-        break;
-      default:
-        break;
-    }
-  }
-
-  if (state_ == STATE_RECEDE && glow_scale_y_ <= 0 && edge_scale_y_ <= 0)
-    Finish();
-
-  return !IsFinished();
-}
-
-float EdgeEffect::GetAlpha() const {
-  return IsFinished() ? 0.f : std::max(glow_alpha_, edge_alpha_);
-}
-
-void EdgeEffect::ApplyToLayers(Edge edge,
-                               const gfx::SizeF& viewport_size,
-                               float offset) {
-  if (IsFinished())
-    return;
-
-  // An empty window size, while meaningless, is also relatively harmless, and
-  // will simply prevent any drawing of the layers.
-  if (viewport_size.IsEmpty()) {
-    edge_->Disable();
-    glow_->Disable();
-    return;
-  }
-
-  gfx::SizeF size = ComputeOrientedSize(edge, viewport_size);
-  gfx::Transform transform = ComputeTransform(edge, viewport_size, offset);
-
-  // Glow
-  const int scaled_glow_height = static_cast<int>(
-      std::min(base_glow_height_ * glow_scale_y_ * kGlowHeightWidthRatio * 0.6f,
-               base_glow_height_ * kMaxGlowHeight) +
-      0.5f);
-  const gfx::Size glow_size(size.width(), scaled_glow_height);
-  glow_->Update(glow_size, transform, glow_alpha_);
-
-  // Edge
-  const int scaled_edge_height =
-      static_cast<int>(base_edge_height_ * edge_scale_y_);
-  const gfx::Size edge_size(size.width(), scaled_edge_height);
-  edge_->Update(edge_size, transform, edge_alpha_);
-}
-
-void EdgeEffect::SetParent(cc::Layer* parent) {
-  edge_->SetParent(parent);
-  glow_->SetParent(parent);
-}
-
-// static
-void EdgeEffect::PreloadResources(ui::ResourceManager* resource_manager) {
-  DCHECK(resource_manager);
-  resource_manager->PreloadResource(ui::ANDROID_RESOURCE_TYPE_SYSTEM,
-                                    kEdgeResourceId);
-  resource_manager->PreloadResource(ui::ANDROID_RESOURCE_TYPE_SYSTEM,
-                                    kGlowResourceId);
-}
-
-}  // namespace content