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"
 
 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(

[powei, 2014/07/08 19:12:43]

I didn't move this over.  I thought BitmapHelper.decodeDrawableResource already
took care of the size?

[jdduke (slow), 2014/07/08 20:10:11]

Unfortunately no, if you look at the comments, decodeDrawableResource will
downsample to the smallest size still *larger* than the provide dimensions that
preserves the aspect ratio (a very cheap operation).  This last resize is to
reduce it further to the exact desired dimensions (slightly more expensive but
still desirable).  I originally had this resize code in the java_bitmap.cc
source as part of CreateJavaBitmapFromAndroidResource, we could move it back
there if this is the only consumer.

[powei, 2014/07/09 20:41:03]

This is the only consumer.  I can move it to java_bitmap.cc

-      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(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(bool enabled)
     : enabled_(enabled), initialized_(false) {}
 
 OverscrollGlow::~OverscrollGlow() {
   Detach();
 }
 
 void OverscrollGlow::Enable() {
   enabled_ = true;
 }
 
 void OverscrollGlow::Disable() {
   if (!enabled_)
     return;
   enabled_ = false;
   if (!enabled_ && initialized_) {
     Detach();
     for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i)
       edge_effects_[i]->Finish();
   }
 }
 
 bool OverscrollGlow::OnOverscrolled(cc::Layer* overscrolling_layer,
                                     base::TimeTicks current_time,
+                                    cc::UIResourceId edge_ui_resource,
+                                    cc::UIResourceId glow_ui_resource,
                                     gfx::Vector2dF accumulated_overscroll,
                                     gfx::Vector2dF overscroll_delta,
                                     gfx::Vector2dF velocity) {
   DCHECK(overscrolling_layer);
 
   if (!enabled_)
     return false;
 
   // The size of the glow determines the relative effect of the inputs; an
   // empty-sized effect is effectively disabled.
   if (display_params_.size.IsEmpty())
     return false;
 
   // Ignore sufficiently small values that won't meaningfuly affect animation.
   overscroll_delta = ZeroSmallComponents(overscroll_delta);
   if (overscroll_delta.IsZero()) {
     if (initialized_) {
       Release(current_time);
-      UpdateLayerAttachment(overscrolling_layer);
+      UpdateLayerAttachment(
+          overscrolling_layer, edge_ui_resource, glow_ui_resource);
     }
     return NeedsAnimate();
   }
 
   if (!InitializeIfNecessary())
     return false;
 
   gfx::Vector2dF old_overscroll = accumulated_overscroll - overscroll_delta;
   bool x_overscroll_started =
       !IsApproxZero(overscroll_delta.x()) && IsApproxZero(old_overscroll.x());
   bool y_overscroll_started =
       !IsApproxZero(overscroll_delta.y()) && IsApproxZero(old_overscroll.y());
 
   if (x_overscroll_started)
     ReleaseAxis(AXIS_X, current_time);
   if (y_overscroll_started)
     ReleaseAxis(AXIS_Y, current_time);
 
   velocity = ZeroSmallComponents(velocity);
   if (!velocity.IsZero())
     Absorb(current_time, velocity, x_overscroll_started, y_overscroll_started);
   else
     Pull(current_time, overscroll_delta);
 
-  UpdateLayerAttachment(overscrolling_layer);
+  UpdateLayerAttachment(
+      overscrolling_layer, edge_ui_resource, glow_ui_resource);
+
   return NeedsAnimate();
 }
 
 bool OverscrollGlow::Animate(base::TimeTicks current_time) {
   if (!NeedsAnimate()) {
     Detach();
     return false;
   }
 
   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
@@ skipping 22 matching lines @@
 bool OverscrollGlow::NeedsAnimate() const {
   if (!enabled_ || !initialized_)
     return false;
   for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
     if (!edge_effects_[i]->IsFinished())
       return true;
   }
   return false;
 }
 
-void OverscrollGlow::UpdateLayerAttachment(cc::Layer* parent) {
+void OverscrollGlow::UpdateLayerAttachment(cc::Layer* parent,
+                                           cc::UIResourceId edge_ui_resource,
+                                           cc::UIResourceId glow_ui_resource) {
   DCHECK(parent);
   if (!root_layer_)
     return;
 
   if (!NeedsAnimate()) {
     Detach();
     return;
   }
 
   if (root_layer_->parent() != parent)
     parent->AddChild(root_layer_);
+
+  // UIResources addition needs to take place after layer attachment.
+  for (size_t i = 0; i < EdgeEffect::EDGE_COUNT; ++i) {
+    if (edge_effects_[i])
+      edge_effects_[i]->SetUIResources(edge_ui_resource, glow_ui_resource);
+  }
 }
 
 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);
+    scoped_refptr<cc::UIResourceLayer> edge_layer =
+        cc::UIResourceLayer::Create();
+    scoped_refptr<cc::UIResourceLayer> glow_layer =
+        cc::UIResourceLayer::Create();
     root_layer_->AddChild(edge_layer);
     root_layer_->AddChild(glow_layer);
     edge_effects_[i] = make_scoped_ptr(new EdgeEffect(edge_layer, glow_layer));
   }
 
   initialized_ = true;
   return true;
 }
 
 void OverscrollGlow::Pull(base::TimeTicks current_time,
@@ skipping 72 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