Update the nine patch layer to use UI resources

cc/layers/nine_patch_layer.cc

Index: cc/layers/nine_patch_layer.cc
diff --git a/cc/layers/nine_patch_layer.cc b/cc/layers/nine_patch_layer.cc
index b500798242a29d79c716e1236b9c49e389b861c7..5e000072f2880a40454480821373ba8d5b41eac7 100644
--- a/cc/layers/nine_patch_layer.cc
+++ b/cc/layers/nine_patch_layer.cc
@@ -8,16 +8,55 @@
 #include "cc/resources/prioritized_resource.h"
 #include "cc/resources/resource_update.h"
 #include "cc/resources/resource_update_queue.h"
+#include "cc/resources/scoped_ui_resource.h"
+#include "cc/resources/ui_resource_bitmap.h"
 #include "cc/trees/layer_tree_host.h"
 
 namespace cc {
 
+
+namespace {
+
+class ScopedUIResourceHolder : public NinePatchLayer::UIResourceHolder {
+ public:
+  static scoped_ptr<ScopedUIResourceHolder> Create(LayerTreeHost* host,
+                                            const SkBitmap& skbitmap) {
+    return make_scoped_ptr(new ScopedUIResourceHolder(host, skbitmap));
+  }
+  virtual UIResourceId id() OVERRIDE { return resource_->id(); }
+
+ private:
+  ScopedUIResourceHolder(LayerTreeHost* host, const SkBitmap& skbitmap) {
+    resource_ = ScopedUIResource::Create(host, UIResourceBitmap(skbitmap));
+  }
+
+  scoped_ptr<ScopedUIResource> resource_;
+};
+
+class SharedUIResourceHolder : public NinePatchLayer::UIResourceHolder {
+ public:
+  static scoped_ptr<SharedUIResourceHolder> Create(UIResourceId id) {
+    return make_scoped_ptr(new SharedUIResourceHolder(id));
+  }
+
+  virtual UIResourceId id() OVERRIDE { return id_; }
+
+ private:
+  explicit SharedUIResourceHolder(UIResourceId id) : id_(id) {}
+
+  UIResourceId id_;
+};
+
+}  // anonymous namespace
+
+
+NinePatchLayer::UIResourceHolder::~UIResourceHolder() {}
+
 scoped_refptr<NinePatchLayer> NinePatchLayer::Create() {
   return make_scoped_refptr(new NinePatchLayer());
 }
 
-NinePatchLayer::NinePatchLayer()
-    : bitmap_dirty_(false) {}
+NinePatchLayer::NinePatchLayer() : fill_center_(false) {}
 
 NinePatchLayer::~NinePatchLayer() {}
 
@@ -26,96 +65,90 @@ scoped_ptr<LayerImpl> NinePatchLayer::CreateLayerImpl(
   return NinePatchLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
-void NinePatchLayer::SetTexturePriorities(
-    const PriorityCalculator& priority_calc) {
-  if (resource_ && !resource_->texture()->resource_manager()) {
-    // Release the resource here, as it is no longer tied to a resource manager.
-    resource_.reset();
-    if (!bitmap_.isNull())
-      CreateResource();
-  } else if (bitmap_dirty_ && DrawsContent()) {
-    CreateResource();
-  }
+void NinePatchLayer::SetLayerTreeHost(LayerTreeHost* host) {
+  if (host == layer_tree_host())
+    return;
 
-  if (resource_) {
-    resource_->texture()->set_request_priority(
-        PriorityCalculator::UIPriority(true));
-    resource_->texture()->SetDimensions(
-        gfx::Size(bitmap_.width(), bitmap_.height()),
-        layer_tree_host()->GetRendererCapabilities().best_texture_format);
-  }
-}
+  Layer::SetLayerTreeHost(host);
 
-void NinePatchLayer::SetBitmap(const SkBitmap& bitmap, gfx::Rect aperture) {
-  bitmap_ = bitmap;
-  image_aperture_ = aperture;
-  bitmap_dirty_ = true;
-  SetNeedsDisplay();
+  // Recreate the resource hold against the new LTH.
+  RecreateUIResourceHolder();
 }
 
-bool NinePatchLayer::Update(ResourceUpdateQueue* queue,
-                            const OcclusionTracker* occlusion) {
-  bool updated = Layer::Update(queue, occlusion);
-
-  CreateUpdaterIfNeeded();
-
-  if (resource_ &&
-      (bitmap_dirty_ || resource_->texture()->resource_id() == 0)) {
-    gfx::Rect content_rect(0, 0, bitmap_.width(), bitmap_.height());
-    ResourceUpdate upload = ResourceUpdate::Create(resource_->texture(),
-                                                   &bitmap_,
-                                                   content_rect,
-                                                   content_rect,
-                                                   gfx::Vector2d());
-    queue->AppendFullUpload(upload);
-    bitmap_dirty_ = false;
-    updated = true;
-  }
+void NinePatchLayer::RecreateUIResourceHolder() {
+  ui_resource_holder_.reset();
+  if (!layer_tree_host() || bitmap_.empty())
+    return;
 
-  return updated;
+  ui_resource_holder_ =
+    ScopedUIResourceHolder::Create(layer_tree_host(), bitmap_);
 }
 
-void NinePatchLayer::CreateUpdaterIfNeeded() {
-  if (updater_.get())
+void NinePatchLayer::SetBorder(gfx::Rect border) {
+  if (border == border_)
     return;
+  border_ = border;
+  SetNeedsCommit();
+}
 
-  updater_ = ImageLayerUpdater::Create();
+void NinePatchLayer::SetBitmap(const SkBitmap& skbitmap, gfx::Rect aperture) {
+  image_aperture_ = aperture;
+  bitmap_ = skbitmap;
+
+  // TODO(ccameron): Remove this. This provides the default border that was
+  // provided before borders were required to be explicitly provided. Once Blink
+  // fixes its callers to call SetBorder, this can be removed.
+  SetBorder(gfx::Rect(aperture.x(),
+                      aperture.y(),
+                      skbitmap.width() - aperture.width(),
+                      skbitmap.height() - aperture.height()));
+  RecreateUIResourceHolder();
+  SetNeedsCommit();
 }
 
-void NinePatchLayer::CreateResource() {
-  DCHECK(!bitmap_.isNull());
-  CreateUpdaterIfNeeded();
-  updater_->SetBitmap(bitmap_);
+void NinePatchLayer::SetUIResourceId(UIResourceId resource_id,
+                                     gfx::Rect aperture) {
+  if (ui_resource_holder_ && ui_resource_holder_->id() == resource_id &&
+      image_aperture_ == aperture)
+    return;
 
-  if (!resource_) {
-    resource_ = updater_->CreateResource(
-        layer_tree_host()->contents_texture_manager());
+  image_aperture_ = aperture;
+  if (resource_id) {
+    ui_resource_holder_ = SharedUIResourceHolder::Create(resource_id);
+  } else {
+    ui_resource_holder_.reset();
   }
+
+  SetNeedsCommit();
+}
+
+void NinePatchLayer::SetFillCenter(bool fill_center) {
+  if (fill_center_ == fill_center)
+    return;
+
+  fill_center_ = fill_center;
+  SetNeedsCommit();
 }
 
 bool NinePatchLayer::DrawsContent() const {
-  bool draws = !bitmap_.isNull() &&
-               Layer::DrawsContent() &&
-               bitmap_.width() &&
-               bitmap_.height();
-  return draws;
+  return ui_resource_holder_ && ui_resource_holder_->id() &&
+         Layer::DrawsContent();
 }
 
 void NinePatchLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
   NinePatchLayerImpl* layer_impl = static_cast<NinePatchLayerImpl*>(layer);
 
-  if (resource_) {
-    DCHECK(!bitmap_.isNull());
-    layer_impl->SetResourceId(resource_->texture()->resource_id());
-    layer_impl->SetLayout(
-        gfx::Size(bitmap_.width(), bitmap_.height()), image_aperture_);
-  }
+  if (!ui_resource_holder_) {
+    layer_impl->SetUIResourceId(0);
+  } else {
+    DCHECK(layer_tree_host());
 
-  // NinePatchLayer must push properties every commit to make sure
-  // NinePatchLayerImpl::resource_id_ is valid.
-  // http://crbug.com/276482
-  needs_push_properties_ = true;
+    gfx::Size image_size =
+        layer_tree_host()->GetUIResourceSize(ui_resource_holder_->id());
+    layer_impl->SetUIResourceId(ui_resource_holder_->id());
+    layer_impl->SetLayout(image_size, image_aperture_, border_, fill_center_);
+  }
 }
 
 }  // namespace cc