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.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 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_;
+  }
+
+  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_refptr<cc::UIResourceLayer> ui_resource_layer_;
+  ui::SystemUIResource::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(

[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() {
   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::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;
   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