android: Use UIResource for overscroll glow

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 "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_layer.h"
+#include "ui/base/android/system_ui_resource_manager.h"
 
 using std::max;
 using std::min;
 
 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;
 }
 
 gfx::Vector2dF ZeroSmallComponents(gfx::Vector2dF vector) {
   if (IsApproxZero(vector.x()))
     vector.set_x(0);
   if (IsApproxZero(vector.y()))
     vector.set_y(0);
   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 EdgeEffect::LayerWrapper {
+ public:
+  static scoped_ptr<OverscrollGlowLayer> Create(
+      ui::SystemUIResourceManager::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);
+  }
+
+  // EdgeEffect::LayerWrapper implementation
+  virtual cc::Layer* layer() OVERRIDE {
+    return ui_resource_layer_.get();
+  }
+
+  virtual ~OverscrollGlowLayer() {
+    resource_manager_->Unsubscribe(type_, this);
+    ui_resource_layer_->RemoveFromParent();
+  }
+
+ private:
+  OverscrollGlowLayer(ui::SystemUIResourceManager::Type type,
+                      ui::SystemUIResourceManager* resource_manager)
+      : ui_resource_layer_(cc::UIResourceLayer::Create()),
+        type_(type),
+        resource_manager_(resource_manager) {
+    resource_manager_->Subscribe(type_, this);
+  }
+
+  scoped_refptr<cc::UIResourceLayer> ui_resource_layer_;
+  ui::SystemUIResourceManager::Type type_;
+  ui::SystemUIResourceManager* resource_manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(OverscrollGlowLayer);
+};
+
+}  // namespace
+
+scoped_ptr<OverscrollGlow> OverscrollGlow::Create(
+    ui::SystemUIResourceManager* resource_manager) {
+  return make_scoped_ptr(new OverscrollGlow(resource_manager));
 }
 
-} // namespace
-
-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);
-
-  return make_scoped_ptr(new OverscrollGlow(enabled));
+OverscrollGlow::OverscrollGlow(ui::SystemUIResourceManager* resource_manager)
+    : enabled_(true), initialized_(false), resource_manager_(resource_manager) {
 }
 
-OverscrollGlow::OverscrollGlow(bool enabled)
-    : enabled_(enabled), initialized_(false) {}
-
 OverscrollGlow::~OverscrollGlow() {
   Detach();
 }
 
 void OverscrollGlow::Enable() {
   enabled_ = true;
 }
 
 void OverscrollGlow::Disable() {
   if (!enabled_)
@@ skipping 99 matching lines @@
   if (!root_layer_)
     return;
 
   if (!NeedsAnimate()) {
     Detach();
     return;
   }
 
   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(
+      ui::SystemUIResourceManager::OVERSCROLL_EDGE);
+  resource_manager_->RefreshResourceOnSubscribers(
+      ui::SystemUIResourceManager::OVERSCROLL_GLOW);
 }
 
 void OverscrollGlow::Detach() {
   if (root_layer_)
     root_layer_->RemoveFromParent();
 }
 
 bool OverscrollGlow::InitializeIfNecessary() {
   DCHECK(enabled_);
   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::SystemUIResourceManager::OVERSCROLL_EDGE, resource_manager_);
+    scoped_ptr<OverscrollGlowLayer> glow_layer = OverscrollGlowLayer::Create(
+        ui::SystemUIResourceManager::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<EdgeEffect::LayerWrapper>(),
+                       glow_layer.PassAs<EdgeEffect::LayerWrapper>()));
   }
 
   initialized_ = true;
   return true;
 }
 
 void OverscrollGlow::Pull(base::TimeTicks current_time,
                           gfx::Vector2dF overscroll_delta) {
   DCHECK(enabled_ && initialized_);
   overscroll_delta = ZeroSmallComponents(overscroll_delta);
@@ skipping 69 matching lines @@
   DCHECK(initialized_);
   return edge_effects_[(edge_index + 2) % EdgeEffect::EDGE_COUNT].get();
 }
 
 OverscrollGlow::DisplayParameters::DisplayParameters()
     : device_scale_factor(1) {
   edge_offsets[0] = edge_offsets[1] = edge_offsets[2] = edge_offsets[3] = 0.f;
 }
 
 }  // namespace content