[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/layer.h"
 #include "content/browser/android/edge_effect.h"
-#include "skia/ext/image_operations.h"
-#include "ui/gfx/android/java_bitmap.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();
+}  // 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) {
+  DCHECK(resource_manager_);
+  EdgeEffect::PreloadResources(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_);
+
+  for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
+    edge_effects_[i]->SetParent(root_layer_);
 }
 
 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));
-  }
+  for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
+    edge_effects_[i] = make_scoped_ptr(new EdgeEffect(resource_manager_));
 
   initialized_ = true;
   return true;
 }
 
 void OverscrollGlow::Pull(base::TimeTicks current_time,
                           gfx::Vector2dF overscroll_delta) {
   DCHECK(enabled_ && initialized_);
   overscroll_delta = ZeroSmallComponents(overscroll_delta);
   if (overscroll_delta.IsZero())
@@ skipping 68 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