Revert 223162 "Update the nine patch layer to use UI resources"

trunk/src/cc/layers/nine_patch_layer.cc

 // Copyright 2012 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 "cc/layers/nine_patch_layer.h"
 
 #include "cc/layers/nine_patch_layer_impl.h"
 #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() : fill_center_(false) {}
+NinePatchLayer::NinePatchLayer()
+    : bitmap_dirty_(false) {}
 
 NinePatchLayer::~NinePatchLayer() {}
 
 scoped_ptr<LayerImpl> NinePatchLayer::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return NinePatchLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
-void NinePatchLayer::SetLayerTreeHost(LayerTreeHost* host) {
-  if (host == layer_tree_host())
+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();
+  }
+
+  if (resource_) {
+    resource_->texture()->set_request_priority(
+        PriorityCalculator::UIPriority(true));
+    GLenum texture_format =
+        layer_tree_host()->GetRendererCapabilities().best_texture_format;
+    resource_->texture()->SetDimensions(
+        gfx::Size(bitmap_.width(), bitmap_.height()), texture_format);
+  }
+}
+
+void NinePatchLayer::SetBitmap(const SkBitmap& bitmap, gfx::Rect aperture) {
+  bitmap_ = bitmap;
+  image_aperture_ = aperture;
+  bitmap_dirty_ = true;
+  SetNeedsDisplay();
+}
+
+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;
+  }
+
+  return updated;
+}
+
+void NinePatchLayer::CreateUpdaterIfNeeded() {
+  if (updater_.get())
     return;
 
-  Layer::SetLayerTreeHost(host);
-
-  // Recreate the resource hold against the new LTH.
-  RecreateUIResourceHolder();
+  updater_ = ImageLayerUpdater::Create();
 }
 
-void NinePatchLayer::RecreateUIResourceHolder() {
-  ui_resource_holder_.reset();
-  if (!layer_tree_host() || bitmap_.empty())
-    return;
+void NinePatchLayer::CreateResource() {
+  DCHECK(!bitmap_.isNull());
+  CreateUpdaterIfNeeded();
+  updater_->SetBitmap(bitmap_);
 
-  ui_resource_holder_ =
-    ScopedUIResourceHolder::Create(layer_tree_host(), bitmap_);
-}
-
-void NinePatchLayer::SetBorder(gfx::Rect border) {
-  if (border == border_)
-    return;
-  border_ = border;
-  SetNeedsCommit();
-}
-
-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::SetUIResourceId(UIResourceId resource_id,
-                                     gfx::Rect aperture) {
-  if (ui_resource_holder_ && ui_resource_holder_->id() == resource_id &&
-      image_aperture_ == aperture)
-    return;
-
-  image_aperture_ = aperture;
-  if (resource_id) {
-    ui_resource_holder_ = SharedUIResourceHolder::Create(resource_id);
-  } else {
-    ui_resource_holder_.reset();
+  if (!resource_) {
+    resource_ = updater_->CreateResource(
+        layer_tree_host()->contents_texture_manager());
   }
-
-  SetNeedsCommit();
-}
-
-void NinePatchLayer::SetFillCenter(bool fill_center) {
-  if (fill_center_ == fill_center)
-    return;
-
-  fill_center_ = fill_center;
-  SetNeedsCommit();
 }
 
 bool NinePatchLayer::DrawsContent() const {
-  return ui_resource_holder_ && ui_resource_holder_->id() &&
-         Layer::DrawsContent();
+  bool draws = !bitmap_.isNull() &&
+               Layer::DrawsContent() &&
+               bitmap_.width() &&
+               bitmap_.height();
+  return draws;
 }
 
 void NinePatchLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
   NinePatchLayerImpl* layer_impl = static_cast<NinePatchLayerImpl*>(layer);
 
-  if (!ui_resource_holder_) {
-    layer_impl->SetUIResourceId(0);
-  } else {
-    DCHECK(layer_tree_host());
+  if (resource_) {
+    DCHECK(!bitmap_.isNull());
+    layer_impl->SetResourceId(resource_->texture()->resource_id());
+    layer_impl->SetLayout(
+        gfx::Size(bitmap_.width(), bitmap_.height()), image_aperture_);
+  }
 
-    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_);
-  }
+  // NinePatchLayer must push properties every commit to make sure
+  // NinePatchLayerImpl::resource_id_ is valid.
+  // http://crbug.com/276482
+  needs_push_properties_ = true;
 }
 
 }  // namespace cc