Update the nine patch layer to use UI resources

cc/layers/nine_patch_layer.h

Index: cc/layers/nine_patch_layer.h
diff --git a/cc/layers/nine_patch_layer.h b/cc/layers/nine_patch_layer.h
index 35d08812cff817e9a26247ef13e71683ba05463c..732e68aa90a2f5596cce8bf3804cdde57d460c58 100644
--- a/cc/layers/nine_patch_layer.h
+++ b/cc/layers/nine_patch_layer.h
@@ -8,32 +8,63 @@
 #include "base/memory/scoped_ptr.h"
 #include "cc/base/cc_export.h"
 #include "cc/layers/layer.h"
-#include "cc/resources/image_layer_updater.h"
-#include "third_party/skia/include/core/SkBitmap.h"
+#include "cc/resources/ui_resource_client.h"
 #include "ui/gfx/rect.h"
 
 namespace cc {
-
-class ResourceUpdateQueue;
+class LayerTreeHost;
+class ScopedUIResource;
 
 class CC_EXPORT NinePatchLayer : public Layer {
+ private:
+  class Resource {

[aelias_OOO_until_Jul13, 2013/08/28 22:28:29]

Rename this UIResourceHolder and put it in the below private: area.

[powei, 2013/08/30 05:17:15]

Renamed it.  

Correct me if I'm wrong, but if the two implementations are to be contained in
the .cc, then UIResourceHolder needs to be public.  Or all three class
definitions can be private as before.  

+   public:
+    virtual UIResourceId id() = 0;

[aelias_OOO_until_Jul13, 2013/08/28 22:28:29]

This should have a virtual destructor as well.

[powei, 2013/08/30 05:17:15]

Done.

+  };
+
+  class ScopedResource : public Resource {

[aelias_OOO_until_Jul13, 2013/08/28 22:28:29]

These two implementation classes can go in the .cc file in an anonymous
namespace.

[powei, 2013/08/30 05:17:15]

Done.

+   public:
+    static scoped_ptr<ScopedResource> Create(LayerTreeHost* host,
+                                             const SkBitmap& skbitmap);
+    virtual UIResourceId id() OVERRIDE;
+
+   private:
+    ScopedResource(LayerTreeHost* host, const SkBitmap& skbitmap);
+    scoped_ptr<ScopedUIResource> resource_;
+  };
+
+  class SharedResource : public Resource {
+   public:
+    static scoped_ptr<SharedResource> Create(UIResourceId id);
+    virtual UIResourceId id() OVERRIDE;
+
+   private:
+    explicit SharedResource(UIResourceId id);
+    UIResourceId id_;
+  };
+
  public:
   static scoped_refptr<NinePatchLayer> Create();
 
   virtual bool DrawsContent() const OVERRIDE;
-  virtual void SetTexturePriorities(const PriorityCalculator& priority_calc)
-      OVERRIDE;
-  virtual bool Update(ResourceUpdateQueue* queue,
-                      const OcclusionTracker* occlusion) OVERRIDE;
+
   virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
 
+  virtual void SetLayerTreeHost(LayerTreeHost* host) OVERRIDE;
+
+  void SetBorder(gfx::Rect border);

[aelias_OOO_until_Jul13, 2013/08/28 22:28:29]

Please write a comment explaining this.

[powei, 2013/08/30 05:17:15]

Done.

   // aperture is in the pixel space of the bitmap resource and refers to
   // the center patch of the ninepatch (which is unused in this
   // implementation). We split off eight rects surrounding it and stick them
   // on the edges of the layer. The corners are unscaled, the top and bottom
   // rects are x-stretched to fit, and the left and right rects are
   // y-stretched to fit.
-  void SetBitmap(const SkBitmap& bitmap, gfx::Rect aperture);
+  void SetBitmap(const SkBitmap& skbitmap, gfx::Rect aperture);
+
+  // An alternative way of setting bitmap to allow for sharing of resources.
+  void SetSharedBitmap(UIResourceId resource_id,

[aelias_OOO_until_Jul13, 2013/08/28 22:28:29]

Rename to SetUIResourceId

[powei, 2013/08/30 05:17:15]

Done.

+                       gfx::Rect aperture,
+                       bool fill_center);
 
  private:
   NinePatchLayer();
@@ -41,14 +72,9 @@ class CC_EXPORT NinePatchLayer : public Layer {
   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
       OVERRIDE;
 
-  void CreateUpdaterIfNeeded();
-  void CreateResource();
-
-  scoped_refptr<ImageLayerUpdater> updater_;
-  scoped_ptr<LayerUpdater::Resource> resource_;
-
-  SkBitmap bitmap_;
-  bool bitmap_dirty_;
+  gfx::Rect border_;
+  bool fill_center_;
+  scoped_ptr<Resource> resource_;
 
   // The transparent center region that shows the parent layer's contents in
   // image space.