Expose array of bitmaps contained by gfx::Image similar to NSImage

ui/gfx/image/image.cc

 // Copyright (c) 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 "ui/gfx/image/image.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
-#include "base/stl_util.h"
+#include "base/memory/scoped_ptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/size.h"
 
 #if defined(TOOLKIT_GTK)
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gdk/gdk.h>
 #include <glib-object.h>
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/image/cairo_cached_surface.h"
 #elif defined(OS_MACOSX)
@@ skipping 67 matching lines @@
 #endif
 
   Image::RepresentationType type() const { return type_; }
 
  private:
   Image::RepresentationType type_;
 };
 
 class ImageRepSkia : public ImageRep {
  public:
-  explicit ImageRepSkia(const SkBitmap* bitmap)
-      : ImageRep(Image::kImageRepSkia) {
-    CHECK(bitmap);
-    // TODO(rohitrao): Add a CHECK to ensure that !bitmap->isNull().
-    bitmaps_.push_back(bitmap);
-  }
-
-  explicit ImageRepSkia(const std::vector<const SkBitmap*>& bitmaps)
+  explicit ImageRepSkia(ImageSkia* image)
       : ImageRep(Image::kImageRepSkia),
-        bitmaps_(bitmaps) {
-    CHECK(!bitmaps_.empty());
-    // TODO(rohitrao): Add a CHECK to ensure that !bitmap->isNull() for each
-    // vector element.
+        image_(image) {
   }
 
   virtual ~ImageRepSkia() {
-    STLDeleteElements(&bitmaps_);
   }
 
-  const SkBitmap* bitmap() const { return bitmaps_[0]; }
-
-  const std::vector<const SkBitmap*>& bitmaps() const { return bitmaps_; }
+  ImageSkia* image() { return image_.get(); }
 
  private:
-  std::vector<const SkBitmap*> bitmaps_;
+  scoped_ptr<ImageSkia> image_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepSkia);
 };
 
 #if defined(TOOLKIT_GTK)
 class ImageRepGdk : public ImageRep {
  public:
   explicit ImageRepGdk(GdkPixbuf* pixbuf)
       : ImageRep(Image::kImageRepGdk),
         pixbuf_(pixbuf) {
@@ skipping 97 matching lines @@
 };
 
 }  // namespace internal
 
 Image::Image() {
   // |storage_| is NULL for empty Images.
 }
 
 Image::Image(const SkBitmap* bitmap)
     : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
-  internal::ImageRepSkia* rep = new internal::ImageRepSkia(bitmap);
+  internal::ImageRepSkia* rep = new internal::ImageRepSkia(
+      new ImageSkia(bitmap));
   AddRepresentation(rep);
 }
 
 Image::Image(const SkBitmap& bitmap)
     : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
   internal::ImageRepSkia* rep =
-      new internal::ImageRepSkia(new SkBitmap(bitmap));
+      new internal::ImageRepSkia(new ImageSkia(new SkBitmap(bitmap)));
   AddRepresentation(rep);
 }
 
 Image::Image(const std::vector<const SkBitmap*>& bitmaps)
     : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
-  internal::ImageRepSkia* rep = new internal::ImageRepSkia(bitmaps);
+  internal::ImageRepSkia* rep = new internal::ImageRepSkia(
+    new ImageSkia(bitmaps));
   AddRepresentation(rep);
 }
 
 #if defined(TOOLKIT_GTK)
 Image::Image(GdkPixbuf* pixbuf)
     : storage_(new internal::ImageStorage(Image::kImageRepGdk)) {
   internal::ImageRepGdk* rep = new internal::ImageRepGdk(pixbuf);
   AddRepresentation(rep);
 }
 #endif
@@ skipping 12 matching lines @@
 Image& Image::operator=(const Image& other) {
   storage_ = other.storage_;
   return *this;
 }
 
 Image::~Image() {
 }
 
 const SkBitmap* Image::ToSkBitmap() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepSkia);
-  return rep->AsImageRepSkia()->bitmap();
+  return rep->AsImageRepSkia()->image()->bitmaps()[0];
+}
+
+const ImageSkia* Image::ToImageSkia() const {
+  internal::ImageRep* rep = GetRepresentation(Image::kImageRepSkia);
+  return rep->AsImageRepSkia()->image();
 }
 
 #if defined(TOOLKIT_GTK)
 GdkPixbuf* Image::ToGdkPixbuf() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepGdk);
   return rep->AsImageRepGdk()->pixbuf();
 }
 
 CairoCachedSurface* const Image::ToCairo() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepCairoCache);
@@ skipping 77 matching lines @@
 
   // At this point, the requested rep does not exist, so it must be converted
   // from the default rep.
 
   // Handle native-to-Skia conversion.
   if (rep_type == Image::kImageRepSkia) {
     internal::ImageRepSkia* rep = NULL;
 #if defined(TOOLKIT_GTK)
     if (storage_->default_representation_type() == Image::kImageRepGdk) {
       internal::ImageRepGdk* pixbuf_rep = default_rep->AsImageRepGdk();
-      rep = new internal::ImageRepSkia(
-          internal::GdkPixbufToSkBitmap(pixbuf_rep->pixbuf()));
+      rep = new internal::ImageRepSkia(new ImageSkia(
+          internal::GdkPixbufToSkBitmap(pixbuf_rep->pixbuf())));
     }
     // We don't do conversions from CairoCachedSurfaces to Skia because the
     // data lives on the display server and we'll always have a GdkPixbuf if we
     // have a CairoCachedSurface.
 #elif defined(OS_MACOSX)
     if (storage_->default_representation_type() == Image::kImageRepCocoa) {
       internal::ImageRepCocoa* nsimage_rep = default_rep->AsImageRepCocoa();
       std::vector<const SkBitmap*> bitmaps;
       CHECK(internal::NSImageToSkBitmaps(nsimage_rep->image(), &bitmaps));
-      rep = new internal::ImageRepSkia(bitmaps);
+      rep = new internal::ImageRepSkia(new ImageSkia(bitmaps));
     }
 #endif
     CHECK(rep);
     AddRepresentation(rep);
     return rep;
   }
 #if defined(TOOLKIT_GTK)
   else if (rep_type == Image::kImageRepCairoCache) {
     // Handle any-to-Cairo conversion. This may recursively create an
     // intermediate pixbuf before we send the data to the display server.
     internal::ImageRep* rep = GetRepresentation(Image::kImageRepGdk);
     internal::ImageRepCairoCached* native_rep =
         new internal::ImageRepCairoCached(rep->AsImageRepGdk()->pixbuf());
 
     CHECK(native_rep);
     AddRepresentation(native_rep);
     return native_rep;
   }
 #endif
 
   // Handle Skia-to-native conversions.
   if (default_rep->type() == Image::kImageRepSkia) {
     internal::ImageRep* native_rep = NULL;
 #if defined(USE_AURA)
     NOTIMPLEMENTED();
 #elif defined(TOOLKIT_GTK)
     if (rep_type == Image::kImageRepGdk) {
       GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(
-          default_rep->AsImageRepSkia()->bitmap());
+          default_rep->AsImageRepSkia()->image()->bitmaps()[0]);
       native_rep = new internal::ImageRepGdk(pixbuf);
     }
 #elif defined(OS_MACOSX)
     if (rep_type == Image::kImageRepCocoa) {
       NSImage* image = gfx::SkBitmapsToNSImage(
-          default_rep->AsImageRepSkia()->bitmaps());
+          default_rep->AsImageRepSkia()->image()->bitmaps());
       base::mac::NSObjectRetain(image);
       native_rep = new internal::ImageRepCocoa(image);
     }
 #endif
     CHECK(native_rep);
     AddRepresentation(native_rep);
     return native_rep;
   }
 
   // Something went seriously wrong...
   return NULL;
 }
 
 void Image::AddRepresentation(internal::ImageRep* rep) const {
   CHECK(storage_.get());
   storage_->representations().insert(std::make_pair(rep->type(), rep));
 }
 
-size_t Image::GetNumberOfSkBitmaps() const  {
-  return GetRepresentation(Image::kImageRepSkia)->AsImageRepSkia()->
-      bitmaps().size();
-}
-
-const SkBitmap* Image::GetSkBitmapAtIndex(size_t index) const {
-  return GetRepresentation(Image::kImageRepSkia)->AsImageRepSkia()->
-      bitmaps()[index];
-}
-
 }  // namespace gfx