Makes ImageSkia more like SkBitmap

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/memory/scoped_ptr.h"
@@ skipping 13 matching lines @@
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 namespace gfx {
 
 namespace internal {
 
 #if defined(OS_MACOSX)
 // This is a wrapper around gfx::NSImageToSkBitmap() because this cross-platform
 // file cannot include the [square brackets] of ObjC.
-bool NSImageToSkBitmaps(NSImage* image, std::vector<const SkBitmap*>* bitmaps);
+ImageSkia NSImageToImageSkia(NSImage* image);
+NSImage* ImageSkiaToNSImage(const ImageSkia* image);
 #endif
 
 #if defined(TOOLKIT_GTK)
 const SkBitmap* GdkPixbufToSkBitmap(GdkPixbuf* pixbuf) {
   CHECK(pixbuf);
   gfx::Canvas canvas(gfx::Size(gdk_pixbuf_get_width(pixbuf),
                                gdk_pixbuf_get_height(pixbuf)), false);
   skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
   cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
   gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
@@ skipping 45 matching lines @@
 #endif
 
   Image::RepresentationType type() const { return type_; }
 
  private:
   Image::RepresentationType type_;
 };
 
 class ImageRepSkia : public ImageRep {
  public:
+  // Takes ownership of |image|.
   explicit ImageRepSkia(ImageSkia* image)
       : ImageRep(Image::kImageRepSkia),
         image_(image) {
   }
 
   virtual ~ImageRepSkia() {
   }
 
   ImageSkia* image() { return image_.get(); }
 
@@ skipping 107 matching lines @@
 
   friend class base::RefCounted<ImageStorage>;
 };
 
 }  // namespace internal
 
 Image::Image() {
   // |storage_| is NULL for empty Images.
 }
 
+Image::Image(const ImageSkia& image)
+    : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
+  internal::ImageRepSkia* rep = new internal::ImageRepSkia(
+      new ImageSkia(image));
+  AddRepresentation(rep);
+}
+
 Image::Image(const SkBitmap& bitmap)
     : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
   internal::ImageRepSkia* rep =
-      new internal::ImageRepSkia(new ImageSkia(new SkBitmap(bitmap)));
+      new internal::ImageRepSkia(new ImageSkia(bitmap));
   AddRepresentation(rep);
 }
 
-Image::Image(const std::vector<const SkBitmap*>& bitmaps)
-    : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
-  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
 
 #if defined(OS_MACOSX)
 Image::Image(NSImage* image)
     : storage_(new internal::ImageStorage(Image::kImageRepCocoa)) {
   internal::ImageRepCocoa* rep = new internal::ImageRepCocoa(image);
   AddRepresentation(rep);
 }
 #endif
 
 Image::Image(const Image& other) : storage_(other.storage_) {
 }
 
 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()->image()->bitmaps()[0];
+  return rep->AsImageRepSkia()->image()->bitmap();
 }
 
 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);
   return rep->AsImageRepCairo()->surface();
 }
 #endif
 
 #if defined(OS_MACOSX)
 NSImage* Image::ToNSImage() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepCocoa);
   return rep->AsImageRepCocoa()->image();
 }
 #endif
 
+ImageSkia* Image::CopyImageSkia() const {
+  return new ImageSkia(*ToImageSkia());
+}
+
 SkBitmap* Image::CopySkBitmap() const {
   return new SkBitmap(*ToSkBitmap());
 }
 
 #if defined(TOOLKIT_GTK)
 GdkPixbuf* Image::CopyGdkPixbuf() const {
   GdkPixbuf* pixbuf = ToGdkPixbuf();
   g_object_ref(pixbuf);
   return pixbuf;
 }
@@ skipping 56 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(new ImageSkia(
-          internal::GdkPixbufToSkBitmap(pixbuf_rep->pixbuf())));
+      scoped_ptr<const SkBitmap> bitmap(
+          internal::GdkPixbufToSkBitmap(pixbuf_rep->pixbuf()));
+      rep = new internal::ImageRepSkia(new ImageSkia(*bitmap));
     }
     // 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(new ImageSkia(bitmaps));
+      ImageSkia image_skia = internal::NSImageToImageSkia(nsimage_rep->image());
+      rep = new internal::ImageRepSkia(new ImageSkia(image_skia));
     }
 #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()->image()->bitmaps()[0]);
+          default_rep->AsImageRepSkia()->image()->bitmap());
       native_rep = new internal::ImageRepGdk(pixbuf);
     }
 #elif defined(OS_MACOSX)
     if (rep_type == Image::kImageRepCocoa) {
-      NSImage* image = gfx::SkBitmapsToNSImage(
-          default_rep->AsImageRepSkia()->image()->bitmaps());
+      NSImage* image = internal::ImageSkiaToNSImage(
+          default_rep->AsImageRepSkia()->image());
       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));
 }
 
 }  // namespace gfx