android: Use UIResource for overscroll glow

content/browser/android/overscroll_glow.cc

Index: content/browser/android/overscroll_glow.cc
diff --git a/content/browser/android/overscroll_glow.cc b/content/browser/android/overscroll_glow.cc
index fb491f3ebaacfbd5b4364601e56e10de80b23dbb..715f0f77f1bb9193487663430aa591daf93ae82d 100644
--- a/content/browser/android/overscroll_glow.cc
+++ b/content/browser/android/overscroll_glow.cc
@@ -6,11 +6,11 @@
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
-#include "base/threading/worker_pool.h"
-#include "cc/layers/image_layer.h"
+#include "cc/layers/ui_resource_layer.h"
 #include "content/browser/android/edge_effect.h"
-#include "skia/ext/image_operations.h"
-#include "ui/gfx/android/java_bitmap.h"
+#include "ui/base/android/system_ui_resource.h"
+#include "ui/base/android/system_ui_resource_layer.h"
+#include "ui/base/android/system_ui_resource_manager.h"
 
 using std::max;
 using std::min;
@@ -20,57 +20,9 @@ namespace content {
 namespace {
 
 const float kEpsilon = 1e-3f;
-const int kScaledEdgeHeight = 12;
-const int kScaledGlowHeight = 64;
 const float kEdgeHeightAtMdpi = 12.f;
 const float kGlowHeightAtMdpi = 128.f;
 
-SkBitmap CreateSkBitmapFromAndroidResource(const char* name, gfx::Size size) {
-  base::android::ScopedJavaLocalRef<jobject> jobj =
-      gfx::CreateJavaBitmapFromAndroidResource(name, size);
-  if (jobj.is_null())
-    return SkBitmap();
-
-  SkBitmap bitmap = CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(jobj.obj()));
-  if (bitmap.isNull())
-    return bitmap;
-
-  return skia::ImageOperations::Resize(
-      bitmap, skia::ImageOperations::RESIZE_BOX, size.width(), size.height());
-}
-
-class OverscrollResources {
- public:
-  OverscrollResources() {
-    TRACE_EVENT0("browser", "OverscrollResources::Create");
-    edge_bitmap_ =
-        CreateSkBitmapFromAndroidResource("android:drawable/overscroll_edge",
-                                          gfx::Size(128, kScaledEdgeHeight));
-    glow_bitmap_ =
-        CreateSkBitmapFromAndroidResource("android:drawable/overscroll_glow",
-                                          gfx::Size(128, kScaledGlowHeight));
-  }
-
-  const SkBitmap& edge_bitmap() const { return edge_bitmap_; }
-  const SkBitmap& glow_bitmap() const { 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;
 }
@@ -83,25 +35,56 @@ gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
   return vector;
 }
 
-// Force loading of any necessary resources.  This function is thread-safe.
-void EnsureResources() {
-  g_overscroll_resources.Get();
-}
+class OverscrollGlowLayer : public ui::SystemUIResourceLayer,
+                            public OverscrollGlowLayerWrapper {
+ public:
+  static scoped_ptr<OverscrollGlowLayer> Create(
+      ui::SystemUIResource::Type type,
+      ui::SystemUIResourceManager* resource_manager) {
+    return make_scoped_ptr(new OverscrollGlowLayer(type, resource_manager));
+  }
+
+  // ui::SystemUIResourceLayer implementation
+  virtual void SetUIResourceId(cc::UIResourceId id) OVERRIDE {
+    ui_resource_layer_->SetUIResourceId(id);
+  }
+
+  // OverscrollGlowLayerWrapper implementation
+  virtual scoped_refptr<cc::Layer> layer() OVERRIDE {
+    return ui_resource_layer_;
+  }
 
-} // namespace
+  virtual ~OverscrollGlowLayer() {
+    resource_manager_->Unsubscribe(type_, this);
+    ui_resource_layer_->RemoveFromParent();
+  }
+
+ private:
+  OverscrollGlowLayer(ui::SystemUIResource::Type type,
+                      ui::SystemUIResourceManager* resource_manager)
+      : ui_resource_layer_(cc::UIResourceLayer::Create()),
+        type_(type),
+        resource_manager_(resource_manager) {
+    resource_manager_->Subscribe(type_, this);
+  }
 
-scoped_ptr<OverscrollGlow> OverscrollGlow::Create(bool enabled) {
-  // Don't block the main thread with effect resource loading during creation.
-  // Effect instantiation is deferred until the effect overscrolls, in which
-  // case the main thread may block until the resource has loaded.
-  if (enabled && g_overscroll_resources == NULL)
-    base::WorkerPool::PostTask(FROM_HERE, base::Bind(EnsureResources), true);
+  scoped_refptr<cc::UIResourceLayer> ui_resource_layer_;
+  ui::SystemUIResource::Type type_;
+  ui::SystemUIResourceManager* resource_manager_;
 
-  return make_scoped_ptr(new OverscrollGlow(enabled));
+  DISALLOW_COPY_AND_ASSIGN(OverscrollGlowLayer);
+};
+
+}  // namespace
+
+scoped_ptr<OverscrollGlow> OverscrollGlow::Create(
+    ui::SystemUIResourceManager* resource_manager) {
+  return make_scoped_ptr(new OverscrollGlow(resource_manager));
 }
 
-OverscrollGlow::OverscrollGlow(bool enabled)
-    : enabled_(enabled), initialized_(false) {}
+OverscrollGlow::OverscrollGlow(ui::SystemUIResourceManager* resource_manager)
+    : enabled_(true), initialized_(false), resource_manager_(resource_manager) {
+}
 
 OverscrollGlow::~OverscrollGlow() {
   Detach();
@@ -222,6 +205,13 @@ void OverscrollGlow::UpdateLayerAttachment(cc::Layer* parent) {
 
   if (root_layer_->parent() != parent)
     parent->AddChild(root_layer_);
+
+  // Attempt to attach a valid resource Id to all subscribing layers.  Must
+  // take place after layer attachment.
+  resource_manager_->RefreshResourceOnSubscribers(

[powei, 2014/07/12 00:24:47]

this the hacky part.  We need to call this to update the resource id on the
layer.  The previous id might have been invalidated due to app switch. 
Suggestions are welcomed here.

[jdduke (slow), 2014/07/12 01:01:09]

Hmm, yeah I'll think about this.  

+      ui::SystemUIResource::OVERSCROLL_EDGE);
+  resource_manager_->RefreshResourceOnSubscribers(
+      ui::SystemUIResource::OVERSCROLL_GLOW);
 }
 
 void OverscrollGlow::Detach() {
@@ -234,21 +224,18 @@ bool OverscrollGlow::InitializeIfNecessary() {
   if (initialized_)
     return true;
 
-  const SkBitmap& edge = g_overscroll_resources.Get().edge_bitmap();
-  const SkBitmap& glow = g_overscroll_resources.Get().glow_bitmap();
-  if (edge.isNull() || glow.isNull()) {
-    Disable();
-    return false;
-  }
-
   DCHECK(!root_layer_);
   root_layer_ = cc::Layer::Create();
   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));
+    scoped_ptr<OverscrollGlowLayer> edge_layer = OverscrollGlowLayer::Create(
+        ui::SystemUIResource::OVERSCROLL_EDGE, resource_manager_);
+    scoped_ptr<OverscrollGlowLayer> glow_layer = OverscrollGlowLayer::Create(
+        ui::SystemUIResource::OVERSCROLL_GLOW, resource_manager_);
+    root_layer_->AddChild(edge_layer->layer());
+    root_layer_->AddChild(glow_layer->layer());
+    edge_effects_[i] = make_scoped_ptr(
+        new EdgeEffect(edge_layer.PassAs<OverscrollGlowLayerWrapper>(),
+                       glow_layer.PassAs<OverscrollGlowLayerWrapper>()));
   }
 
   initialized_ = true;