Switch the android overscroll glow to use UIResources.

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 "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "cc/layers/image_layer.h"
+#include "cc/layers/ui_resource_layer.h"
 #include "content/browser/android/edge_effect.h"
 #include "ui/gfx/android/java_bitmap.h"
 
 using std::max;
 using std::min;
 
 namespace content {
 
 namespace {
 
 const float kEpsilon = 1e-3f;
 
-class OverscrollResources {
- public:
-  OverscrollResources() {
-    TRACE_EVENT0("browser", "OverscrollResources::Create");
-    edge_bitmap_ =
-        gfx::CreateSkBitmapFromResource("android:drawable/overscroll_edge",
-                                        gfx::Size(128, 12));
-    glow_bitmap_ =
-        gfx::CreateSkBitmapFromResource("android:drawable/overscroll_glow",
-                                        gfx::Size(128, 64));
-  }
-
-  const SkBitmap& edge_bitmap() { return edge_bitmap_; }
-  const SkBitmap& glow_bitmap() { return glow_bitmap_; }
-
- private:
-  SkBitmap edge_bitmap_;
-  SkBitmap glow_bitmap_;
-
-  DISALLOW_COPY_AND_ASSIGN(OverscrollResources);
-};
-
-// Leaky to allow access from a worker thread.
-base::LazyInstance<OverscrollResources>::Leaky g_overscroll_resources =
-    LAZY_INSTANCE_INITIALIZER;
-
-scoped_refptr<cc::Layer> CreateImageLayer(const SkBitmap& bitmap) {
-  scoped_refptr<cc::ImageLayer> layer = cc::ImageLayer::Create();
-  layer->SetBitmap(bitmap);
-  return layer;
-}
-
 bool IsApproxZero(float value) {
   return std::abs(value) < kEpsilon;
 }
 
 gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
   if (IsApproxZero(vector.x()))
     vector.set_x(0);
   if (IsApproxZero(vector.y()))
     vector.set_y(0);
   return vector;
 }
 
 } // namespace
 
 scoped_ptr<OverscrollGlow> OverscrollGlow::Create(bool enabled,
                                                   gfx::SizeF size) {
-  const SkBitmap& edge = g_overscroll_resources.Get().edge_bitmap();
-  const SkBitmap& glow = g_overscroll_resources.Get().glow_bitmap();
-  if (edge.isNull() || glow.isNull())
-    return scoped_ptr<OverscrollGlow>();
-
-  return make_scoped_ptr(new OverscrollGlow(enabled, size, edge, glow));
-}
-
-void OverscrollGlow::EnsureResources() {
-  g_overscroll_resources.Get();
+  return make_scoped_ptr(new OverscrollGlow(enabled, size));
 }
 
 OverscrollGlow::OverscrollGlow(bool enabled,
-                               gfx::SizeF size,
-                               const SkBitmap& edge,
-                               const SkBitmap& glow)
+                               gfx::SizeF size)
   : enabled_(enabled),
     size_(size),
     horizontal_overscroll_enabled_(true),
     vertical_overscroll_enabled_(true),
-    root_layer_(cc::Layer::Create()) {
+    root_layer_(cc::Layer::Create()),
+    edge_layer_(cc::UIResourceLayer::Create()),
+    glow_layer_(cc::UIResourceLayer::Create()),
+    edge_resource_id_(0),
+    glow_resource_id_(0) {
   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
-    scoped_refptr<cc::Layer> edge_layer = CreateImageLayer(edge);
-    scoped_refptr<cc::Layer> glow_layer = CreateImageLayer(glow);
-    root_layer_->AddChild(edge_layer);
-    root_layer_->AddChild(glow_layer);
-    edge_effects_[i] = make_scoped_ptr(new EdgeEffect(edge_layer, glow_layer));
+    root_layer_->AddChild(edge_layer_);
+    root_layer_->AddChild(glow_layer_);
+    edge_effects_[i] =
+        make_scoped_ptr(new EdgeEffect(edge_layer_, glow_layer_));

[jdduke (slow), 2013/11/26 01:39:54]

There can potentially be >1 EdgeEffects active at any given time (e.g., left +
top), in which case having but one set of layers will result in the properties
(size/opacity/orientation) being overwritten. I could optimize this a bit so
that only one of the {top,bottom} and {left,right} pairs are active at any given
time, but certainly we should allow for, say, left+top to overscroll
simultaneously.

[powei, 2013/11/26 22:17:41]

Done.  My bad for not noticing what's actually going on here.  I switched it
back to 2 layers per effect as before.

   }
 }
 
 OverscrollGlow::~OverscrollGlow() {
   root_layer_->RemoveFromParent();
 }
 
 void OverscrollGlow::OnOverscrolled(base::TimeTicks current_time,
                                     gfx::Vector2dF overscroll,
                                     gfx::Vector2dF velocity) {
@@ skipping 156 matching lines @@
       old_overscroll_.set_y(0);
       old_velocity_.set_y(0);
       break;
   };
 }
 
 EdgeEffect* OverscrollGlow::GetOppositeEdge(int edge_index) {
   return edge_effects_[(edge_index + 2) % EdgeEffect::EDGE_COUNT].get();
 }
 
+void OverscrollGlow::AttachLayerTo(scoped_refptr<cc::Layer> layer) {
+  if (!edge_resource_id_ || !glow_resource_id_)
+    return;
+  layer->AddChild(root_layer_);
+  edge_layer_->SetUIResourceId(edge_resource_id_);
+  edge_layer_->SetBounds(edge_bitmap_size_);
+  glow_layer_->SetUIResourceId(glow_resource_id_);
+  glow_layer_->SetBounds(glow_bitmap_size_);
+}
+
+void OverscrollGlow::RemoveLayer() {
+  root_layer_->RemoveFromParent();
+}
+
+bool OverscrollGlow::IsAttached() const { return root_layer_->parent(); }
+
+bool OverscrollGlow::SetLayerResources(cc::UIResourceId edge_resource_id,
+                                       cc::UIResourceId glow_resource_id,
+                                       gfx::Size edge_bitmap_size,
+                                       gfx::Size glow_bitmap_size) {
+  if (edge_resource_id_ == edge_resource_id &&
+      glow_resource_id_ == glow_resource_id)
+    return false;
+  edge_resource_id_ = edge_resource_id;
+  glow_resource_id_ = glow_resource_id;
+  edge_bitmap_size_ = edge_bitmap_size;
+  glow_bitmap_size_ = glow_bitmap_size;
+  return true;
+}
+
 }  // namespace content
-