content/browser/android/overscroll_glow.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/android/overscroll_glow.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/threading/worker_pool.h"
  10 #include "cc/layers/image_layer.h"
  11 #include "content/browser/android/edge_effect.h"
  12 #include "ui/gfx/android/java_bitmap.h"
  13
  14 using std::max;
  15 using std::min;
  16
  17 namespace content {
  18
  19 namespace {
  20
  21 const float kEpsilon = 1e-3f;
  22
  23 class OverscrollResources {
  24  public:
  25   OverscrollResources() {
  26     TRACE_EVENT0("browser", "OverscrollResources::Create");
  27     edge_bitmap_ =
  28         gfx::CreateSkBitmapFromResource("android:drawable/overscroll_edge",
  29                                         gfx::Size(128, 12));
  30     glow_bitmap_ =
  31         gfx::CreateSkBitmapFromResource("android:drawable/overscroll_glow",
  32                                         gfx::Size(128, 64));
  33   }
  34
  35   const SkBitmap& edge_bitmap() { return edge_bitmap_; }
  36   const SkBitmap& glow_bitmap() { return glow_bitmap_; }
  37
  38  private:
  39   SkBitmap edge_bitmap_;
  40   SkBitmap glow_bitmap_;
  41
  42   DISALLOW_COPY_AND_ASSIGN(OverscrollResources);
  43 };
  44
  45 // Leaky to allow access from a worker thread.
  46 base::LazyInstance<OverscrollResources>::Leaky g_overscroll_resources =
  47     LAZY_INSTANCE_INITIALIZER;
  48
  49 scoped_refptr<cc::Layer> CreateImageLayer(const SkBitmap& bitmap) {
  50   scoped_refptr<cc::ImageLayer> layer = cc::ImageLayer::Create();
  51   layer->SetBitmap(bitmap);
  52   return layer;
  53 }
  54
  55 bool IsApproxZero(float value) {
  56   return std::abs(value) < kEpsilon;
  57 }
  58
  59 gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
  60   if (IsApproxZero(vector.x()))
  61     vector.set_x(0);
  62   if (IsApproxZero(vector.y()))
  63     vector.set_y(0);
  64   return vector;
  65 }
  66
  67 // Force loading of any necessary resources.  This function is thread-safe.
  68 void EnsureResources() {
  69   g_overscroll_resources.Get();
  70 }
  71
  72 } // namespace
  73
  74 scoped_ptr<OverscrollGlow> OverscrollGlow::Create(bool enabled) {
  75   // Don't block the main thread with effect resource loading during creation.
  76   // Effect instantiation is deferred until the effect overscrolls, in which
  77   // case the main thread may block until the resource has loaded.
  78   if (enabled && g_overscroll_resources == NULL)
  79     base::WorkerPool::PostTask(FROM_HERE, base::Bind(EnsureResources), true);
  80
  81   return make_scoped_ptr(new OverscrollGlow(enabled));
  82 }
  83
  84 OverscrollGlow::OverscrollGlow(bool enabled)
  85   : enabled_(enabled),
  86     initialized_(false),
  87     horizontal_overscroll_enabled_(true),
  88     vertical_overscroll_enabled_(true) {}
  89
  90 OverscrollGlow::~OverscrollGlow() {
  91   Detach();
  92 }
  93
  94 void OverscrollGlow::Enable() {
  95   enabled_ = true;
  96 }
  97
  98 void OverscrollGlow::Disable() {
  99   if (!enabled_)
 100     return;
 101   enabled_ = false;
 102   if (!enabled_ && initialized_) {
 103     Detach();
 104     for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
 105       edge_effects_[i]->Finish();
 106   }
 107 }
 108
 109 bool OverscrollGlow::OnOverscrolled(cc::Layer* overscrolling_layer,
 110                                     base::TimeTicks current_time,
 111                                     gfx::Vector2dF overscroll,
 112                                     gfx::Vector2dF velocity) {
 113   DCHECK(overscrolling_layer);
 114
 115   if (!enabled_)
 116     return false;
 117
 118   // The size of the glow determines the relative effect of the inputs; an
 119   // empty-sized effect is effectively disabled.
 120   if (size_.IsEmpty())
 121     return false;
 122
 123   if (!horizontal_overscroll_enabled_) {
 124     overscroll.set_x(0);
 125     velocity.set_x(0);
 126   }
 127   if (!vertical_overscroll_enabled_) {
 128     overscroll.set_y(0);
 129     velocity.set_y(0);
 130   }
 131
 132   // Ignore sufficiently small values that won't meaningfuly affect animation.
 133   overscroll = ZeroSmallComponents(overscroll);
 134   velocity = ZeroSmallComponents(velocity);
 135
 136   if (overscroll.IsZero()) {
 137     if (initialized_) {
 138       Release(current_time);
 139       UpdateLayerAttachment(overscrolling_layer);
 140     }
 141     return NeedsAnimate();
 142   }
 143
 144   if (!InitializeIfNecessary())
 145     return false;
 146
 147   if (!velocity.IsZero()) {
 148     // Release effects if scrolling has changed directions.
 149     if (velocity.x() * old_velocity_.x() < 0)
 150       ReleaseAxis(AXIS_X, current_time);
 151     if (velocity.y() * old_velocity_.y() < 0)
 152       ReleaseAxis(AXIS_Y, current_time);
 153
 154     Absorb(current_time, velocity, overscroll, old_overscroll_);
 155   } else {
 156     // Release effects when overscroll accumulation violates monotonicity.
 157     if (overscroll.x() * old_overscroll_.x() < 0 ||
 158         std::abs(overscroll.x()) < std::abs(old_overscroll_.x()))
 159       ReleaseAxis(AXIS_X, current_time);
 160     if (overscroll.y() * old_overscroll_.y() < 0 ||
 161         std::abs(overscroll.y()) < std::abs(old_overscroll_.y()))
 162       ReleaseAxis(AXIS_Y, current_time);
 163
 164     Pull(current_time, overscroll - old_overscroll_);
 165   }
 166
 167   old_velocity_ = velocity;
 168   old_overscroll_ = overscroll;
 169
 170   UpdateLayerAttachment(overscrolling_layer);
 171   return NeedsAnimate();
 172 }
 173
 174 bool OverscrollGlow::Animate(base::TimeTicks current_time) {
 175   if (!NeedsAnimate()) {
 176     Detach();
 177     return false;
 178   }
 179
 180   const gfx::SizeF sizes[EdgeEffect::EDGE_COUNT] = {
 181     size_, gfx::SizeF(size_.height(), size_.width()),
 182     size_, gfx::SizeF(size_.height(), size_.width())
 183   };
 184
 185   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 186     if (edge_effects_[i]->Update(current_time)) {
 187       edge_effects_[i]->ApplyToLayers(sizes[i],
 188                                       static_cast<EdgeEffect::Edge>(i));
 189     }
 190   }
 191
 192   if (!NeedsAnimate()) {
 193     Detach();
 194     return false;
 195   }
 196
 197   return true;
 198 }
 199
 200 bool OverscrollGlow::NeedsAnimate() const {
 201   if (!enabled_ || !initialized_)
 202     return false;
 203   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 204     if (!edge_effects_[i]->IsFinished())
 205       return true;
 206   }
 207   return false;
 208 }
 209
 210 void OverscrollGlow::UpdateLayerAttachment(cc::Layer* parent) {
 211   DCHECK(parent);
 212   if (!root_layer_)
 213     return;
 214
 215   if (!NeedsAnimate()) {
 216     Detach();
 217     return;
 218   }
 219
 220   if (root_layer_->parent() != parent)
 221     parent->AddChild(root_layer_);
 222 }
 223
 224 void OverscrollGlow::Detach() {
 225   if (root_layer_)
 226     root_layer_->RemoveFromParent();
 227 }
 228
 229 bool OverscrollGlow::InitializeIfNecessary() {
 230   DCHECK(enabled_);
 231   if (initialized_)
 232     return true;
 233
 234   const SkBitmap& edge = g_overscroll_resources.Get().edge_bitmap();
 235   const SkBitmap& glow = g_overscroll_resources.Get().glow_bitmap();
 236   if (edge.isNull() || glow.isNull()) {
 237     Disable();
 238     return false;
 239   }
 240
 241   DCHECK(!root_layer_);
 242   root_layer_ = cc::Layer::Create();
 243   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 244     scoped_refptr<cc::Layer> edge_layer = CreateImageLayer(edge);
 245     scoped_refptr<cc::Layer> glow_layer = CreateImageLayer(glow);
 246     root_layer_->AddChild(edge_layer);
 247     root_layer_->AddChild(glow_layer);
 248     edge_effects_[i] = make_scoped_ptr(new EdgeEffect(edge_layer, glow_layer));
 249   }
 250
 251   initialized_ = true;
 252   return true;
 253 }
 254
 255 void OverscrollGlow::Pull(base::TimeTicks current_time,
 256                           gfx::Vector2dF overscroll_delta) {
 257   DCHECK(enabled_ && initialized_);
 258   overscroll_delta = ZeroSmallComponents(overscroll_delta);
 259   if (overscroll_delta.IsZero())
 260     return;
 261
 262   gfx::Vector2dF overscroll_pull = gfx::ScaleVector2d(overscroll_delta,
 263                                                       1.f / size_.width(),
 264                                                       1.f / size_.height());
 265   float edge_overscroll_pull[EdgeEffect::EDGE_COUNT] = {
 266     min(overscroll_pull.y(), 0.f), // Top
 267     min(overscroll_pull.x(), 0.f), // Left
 268     max(overscroll_pull.y(), 0.f), // Bottom
 269     max(overscroll_pull.x(), 0.f)  // Right
 270   };
 271
 272   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 273     if (!edge_overscroll_pull[i])
 274       continue;
 275
 276     edge_effects_[i]->Pull(current_time, std::abs(edge_overscroll_pull[i]));
 277     GetOppositeEdge(i)->Release(current_time);
 278   }
 279 }
 280
 281 void OverscrollGlow::Absorb(base::TimeTicks current_time,
 282                             gfx::Vector2dF velocity,
 283                             gfx::Vector2dF overscroll,
 284                             gfx::Vector2dF old_overscroll) {
 285   DCHECK(enabled_ && initialized_);
 286   if (overscroll.IsZero() || velocity.IsZero())
 287     return;
 288
 289   // Only trigger on initial overscroll at a non-zero velocity
 290   const float overscroll_velocities[EdgeEffect::EDGE_COUNT] = {
 291     old_overscroll.y() >= 0 && overscroll.y() < 0 ? min(velocity.y(), 0.f) : 0,
 292     old_overscroll.x() >= 0 && overscroll.x() < 0 ? min(velocity.x(), 0.f) : 0,
 293     old_overscroll.y() <= 0 && overscroll.y() > 0 ? max(velocity.y(), 0.f) : 0,
 294     old_overscroll.x() <= 0 && overscroll.x() > 0 ? max(velocity.x(), 0.f) : 0
 295   };
 296
 297   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 298     if (!overscroll_velocities[i])
 299       continue;
 300
 301     edge_effects_[i]->Absorb(current_time, std::abs(overscroll_velocities[i]));
 302     GetOppositeEdge(i)->Release(current_time);
 303   }
 304 }
 305
 306 void OverscrollGlow::Release(base::TimeTicks current_time) {
 307   DCHECK(initialized_);
 308   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
 309     edge_effects_[i]->Release(current_time);
 310   }
 311   old_overscroll_ = old_velocity_ = gfx::Vector2dF();
 312 }
 313
 314 void OverscrollGlow::ReleaseAxis(Axis axis, base::TimeTicks current_time) {
 315   DCHECK(initialized_);
 316   switch (axis) {
 317     case AXIS_X:
 318       edge_effects_[EdgeEffect::EDGE_LEFT]->Release(current_time);
 319       edge_effects_[EdgeEffect::EDGE_RIGHT]->Release(current_time);
 320       old_overscroll_.set_x(0);
 321       old_velocity_.set_x(0);
 322       break;
 323     case AXIS_Y:
 324       edge_effects_[EdgeEffect::EDGE_TOP]->Release(current_time);
 325       edge_effects_[EdgeEffect::EDGE_BOTTOM]->Release(current_time);
 326       old_overscroll_.set_y(0);
 327       old_velocity_.set_y(0);
 328       break;
 329   };
 330 }
 331
 332 EdgeEffect* OverscrollGlow::GetOppositeEdge(int edge_index) {
 333   DCHECK(initialized_);
 334   return edge_effects_[(edge_index + 2) % EdgeEffect::EDGE_COUNT].get();
 335 }
 336
 337 }  // namespace content
 338