Update the nine patch layer to use UI resources

cc/layers/nine_patch_layer.h

 // 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.
 
 #ifndef CC_LAYERS_NINE_PATCH_LAYER_H_
 #define CC_LAYERS_NINE_PATCH_LAYER_H_
 
 #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();
   virtual ~NinePatchLayer();
   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.
   gfx::Rect image_aperture_;
 
   DISALLOW_COPY_AND_ASSIGN(NinePatchLayer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_NINE_PATCH_LAYER_H_