Home | History | Annotate | Download | only in image 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "ui/gfx/image/image.h"
      6 
      7 #include <algorithm>
      8 #include <set>
      9 
     10 #include "base/logging.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/stl_util.h"
     13 #include "third_party/skia/include/core/SkBitmap.h"
     14 #include "ui/gfx/image/image_png_rep.h"
     15 #include "ui/gfx/image/image_skia.h"
     16 #include "ui/gfx/image/image_skia_source.h"
     17 #include "ui/gfx/size.h"
     18 
     19 #if !defined(OS_IOS)
     20 #include "ui/gfx/codec/png_codec.h"
     21 #endif
     22 
     23 #if defined(OS_IOS)
     24 #include "base/mac/foundation_util.h"
     25 #include "ui/gfx/image/image_skia_util_ios.h"
     26 #elif defined(OS_MACOSX)
     27 #include "base/mac/mac_util.h"
     28 #include "ui/gfx/image/image_skia_util_mac.h"
     29 #endif
     30 
     31 namespace gfx {
     32 
     33 namespace internal {
     34 
     35 #if defined(OS_IOS)
     36 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromUIImage(
     37     UIImage* uiimage);
     38 // Caller takes ownership of the returned UIImage.
     39 UIImage* CreateUIImageFromPNG(
     40     const std::vector<ImagePNGRep>& image_png_reps);
     41 gfx::Size UIImageSize(UIImage* image);
     42 #elif defined(OS_MACOSX)
     43 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromNSImage(
     44     NSImage* nsimage);
     45 // Caller takes ownership of the returned NSImage.
     46 NSImage* NSImageFromPNG(const std::vector<ImagePNGRep>& image_png_reps,
     47                         CGColorSpaceRef color_space);
     48 gfx::Size NSImageSize(NSImage* image);
     49 #endif // defined(OS_MACOSX)
     50 
     51 #if defined(OS_IOS)
     52 ImageSkia* ImageSkiaFromPNG(
     53     const std::vector<ImagePNGRep>& image_png_reps);
     54 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
     55     const ImageSkia* skia);
     56 #else
     57 // Returns a 16x16 red image to visually show error in decoding PNG.
     58 // Caller takes ownership of returned ImageSkia.
     59 ImageSkia* GetErrorImageSkia() {
     60   SkBitmap bitmap;
     61   bitmap.allocN32Pixels(16, 16);
     62   bitmap.eraseARGB(0xff, 0xff, 0, 0);
     63   return new ImageSkia(ImageSkiaRep(bitmap, 1.0f));
     64 }
     65 
     66 class PNGImageSource : public ImageSkiaSource {
     67  public:
     68   PNGImageSource() {}
     69   virtual ~PNGImageSource() {}
     70 
     71   virtual ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
     72     if (image_skia_reps_.empty())
     73       return ImageSkiaRep();
     74 
     75     const ImageSkiaRep* rep = NULL;
     76     // gfx::ImageSkia passes one of the resource scale factors. The source
     77     // should return:
     78     // 1) The ImageSkiaRep with the highest scale if all available
     79     // scales are smaller than |scale|.
     80     // 2) The ImageSkiaRep with the smallest one that is larger than |scale|.
     81     for (ImageSkiaRepSet::const_iterator iter = image_skia_reps_.begin();
     82          iter != image_skia_reps_.end(); ++iter) {
     83       if ((*iter).scale() == scale)
     84         return (*iter);
     85       if (!rep || rep->scale() < (*iter).scale())
     86         rep = &(*iter);
     87       if (rep->scale() >= scale)
     88         break;
     89     }
     90     return rep ? *rep : ImageSkiaRep();
     91   }
     92 
     93   const gfx::Size size() const {
     94     return size_;
     95   }
     96 
     97   bool AddPNGData(const ImagePNGRep& png_rep) {
     98     const gfx::ImageSkiaRep rep = ToImageSkiaRep(png_rep);
     99     if (rep.is_null())
    100       return false;
    101     if (size_.IsEmpty())
    102       size_ = gfx::Size(rep.GetWidth(), rep.GetHeight());
    103     image_skia_reps_.insert(rep);
    104     return true;
    105   }
    106 
    107   static ImageSkiaRep ToImageSkiaRep(const ImagePNGRep& png_rep) {
    108     scoped_refptr<base::RefCountedMemory> raw_data = png_rep.raw_data;
    109     CHECK(raw_data.get());
    110     SkBitmap bitmap;
    111     if (!PNGCodec::Decode(raw_data->front(), raw_data->size(),
    112                                &bitmap)) {
    113       LOG(ERROR) << "Unable to decode PNG for " << png_rep.scale << ".";
    114       return ImageSkiaRep();
    115     }
    116     return ImageSkiaRep(bitmap, png_rep.scale);
    117   }
    118 
    119  private:
    120   struct Compare {
    121     bool operator()(const ImageSkiaRep& rep1, const ImageSkiaRep& rep2) {
    122       return rep1.scale() < rep2.scale();
    123     }
    124   };
    125 
    126   typedef std::set<ImageSkiaRep, Compare> ImageSkiaRepSet;
    127   ImageSkiaRepSet image_skia_reps_;
    128   gfx::Size size_;
    129 
    130   DISALLOW_COPY_AND_ASSIGN(PNGImageSource);
    131 };
    132 
    133 ImageSkia* ImageSkiaFromPNG(
    134     const std::vector<ImagePNGRep>& image_png_reps) {
    135   if (image_png_reps.empty())
    136     return GetErrorImageSkia();
    137   scoped_ptr<PNGImageSource> image_source(new PNGImageSource);
    138 
    139   for (size_t i = 0; i < image_png_reps.size(); ++i) {
    140     if (!image_source->AddPNGData(image_png_reps[i]))
    141       return GetErrorImageSkia();
    142   }
    143   const gfx::Size& size = image_source->size();
    144   DCHECK(!size.IsEmpty());
    145   if (size.IsEmpty())
    146     return GetErrorImageSkia();
    147   return new ImageSkia(image_source.release(), size);
    148 }
    149 
    150 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
    151     const ImageSkia* image_skia) {
    152   ImageSkiaRep image_skia_rep = image_skia->GetRepresentation(1.0f);
    153 
    154   scoped_refptr<base::RefCountedBytes> png_bytes(new base::RefCountedBytes());
    155   if (image_skia_rep.scale() != 1.0f ||
    156       !PNGCodec::EncodeBGRASkBitmap(image_skia_rep.sk_bitmap(), false,
    157           &png_bytes->data())) {
    158     return NULL;
    159   }
    160   return png_bytes;
    161 }
    162 #endif
    163 
    164 class ImageRepPNG;
    165 class ImageRepSkia;
    166 class ImageRepCocoa;
    167 class ImageRepCocoaTouch;
    168 
    169 // An ImageRep is the object that holds the backing memory for an Image. Each
    170 // RepresentationType has an ImageRep subclass that is responsible for freeing
    171 // the memory that the ImageRep holds. When an ImageRep is created, it expects
    172 // to take ownership of the image, without having to retain it or increase its
    173 // reference count.
    174 class ImageRep {
    175  public:
    176   explicit ImageRep(Image::RepresentationType rep) : type_(rep) {}
    177 
    178   // Deletes the associated pixels of an ImageRep.
    179   virtual ~ImageRep() {}
    180 
    181   // Cast helpers ("fake RTTI").
    182   ImageRepPNG* AsImageRepPNG() {
    183     CHECK_EQ(type_, Image::kImageRepPNG);
    184     return reinterpret_cast<ImageRepPNG*>(this);
    185   }
    186 
    187   ImageRepSkia* AsImageRepSkia() {
    188     CHECK_EQ(type_, Image::kImageRepSkia);
    189     return reinterpret_cast<ImageRepSkia*>(this);
    190   }
    191 
    192 #if defined(OS_IOS)
    193   ImageRepCocoaTouch* AsImageRepCocoaTouch() {
    194     CHECK_EQ(type_, Image::kImageRepCocoaTouch);
    195     return reinterpret_cast<ImageRepCocoaTouch*>(this);
    196   }
    197 #elif defined(OS_MACOSX)
    198   ImageRepCocoa* AsImageRepCocoa() {
    199     CHECK_EQ(type_, Image::kImageRepCocoa);
    200     return reinterpret_cast<ImageRepCocoa*>(this);
    201   }
    202 #endif
    203 
    204   Image::RepresentationType type() const { return type_; }
    205 
    206   virtual int Width() const = 0;
    207   virtual int Height() const = 0;
    208   virtual gfx::Size Size() const = 0;
    209 
    210  private:
    211   Image::RepresentationType type_;
    212 };
    213 
    214 class ImageRepPNG : public ImageRep {
    215  public:
    216   ImageRepPNG() : ImageRep(Image::kImageRepPNG) {
    217   }
    218 
    219   ImageRepPNG(const std::vector<ImagePNGRep>& image_png_reps)
    220       : ImageRep(Image::kImageRepPNG),
    221         image_png_reps_(image_png_reps) {
    222   }
    223 
    224   virtual ~ImageRepPNG() {
    225   }
    226 
    227   virtual int Width() const OVERRIDE {
    228     return Size().width();
    229   }
    230 
    231   virtual int Height() const OVERRIDE {
    232     return Size().height();
    233   }
    234 
    235   virtual gfx::Size Size() const OVERRIDE {
    236     // Read the PNG data to get the image size, caching it.
    237     if (!size_cache_) {
    238       for (std::vector<ImagePNGRep>::const_iterator it = image_reps().begin();
    239            it != image_reps().end(); ++it) {
    240         if (it->scale == 1.0f) {
    241           size_cache_.reset(new gfx::Size(it->Size()));
    242           return *size_cache_;
    243         }
    244       }
    245       size_cache_.reset(new gfx::Size);
    246     }
    247 
    248     return *size_cache_;
    249   }
    250 
    251   const std::vector<ImagePNGRep>& image_reps() const { return image_png_reps_; }
    252 
    253  private:
    254   std::vector<ImagePNGRep> image_png_reps_;
    255 
    256   // Cached to avoid having to parse the raw data multiple times.
    257   mutable scoped_ptr<gfx::Size> size_cache_;
    258 
    259   DISALLOW_COPY_AND_ASSIGN(ImageRepPNG);
    260 };
    261 
    262 class ImageRepSkia : public ImageRep {
    263  public:
    264   // Takes ownership of |image|.
    265   explicit ImageRepSkia(ImageSkia* image)
    266       : ImageRep(Image::kImageRepSkia),
    267         image_(image) {
    268   }
    269 
    270   virtual ~ImageRepSkia() {
    271   }
    272 
    273   virtual int Width() const OVERRIDE {
    274     return image_->width();
    275   }
    276 
    277   virtual int Height() const OVERRIDE {
    278     return image_->height();
    279   }
    280 
    281   virtual gfx::Size Size() const OVERRIDE {
    282     return image_->size();
    283   }
    284 
    285   ImageSkia* image() { return image_.get(); }
    286 
    287  private:
    288   scoped_ptr<ImageSkia> image_;
    289 
    290   DISALLOW_COPY_AND_ASSIGN(ImageRepSkia);
    291 };
    292 
    293 #if defined(OS_IOS)
    294 class ImageRepCocoaTouch : public ImageRep {
    295  public:
    296   explicit ImageRepCocoaTouch(UIImage* image)
    297       : ImageRep(Image::kImageRepCocoaTouch),
    298         image_(image) {
    299     CHECK(image);
    300   }
    301 
    302   virtual ~ImageRepCocoaTouch() {
    303     base::mac::NSObjectRelease(image_);
    304     image_ = nil;
    305   }
    306 
    307   virtual int Width() const OVERRIDE {
    308     return Size().width();
    309   }
    310 
    311   virtual int Height() const OVERRIDE {
    312     return Size().height();
    313   }
    314 
    315   virtual gfx::Size Size() const OVERRIDE {
    316     return internal::UIImageSize(image_);
    317   }
    318 
    319   UIImage* image() const { return image_; }
    320 
    321  private:
    322   UIImage* image_;
    323 
    324   DISALLOW_COPY_AND_ASSIGN(ImageRepCocoaTouch);
    325 };
    326 #elif defined(OS_MACOSX)
    327 class ImageRepCocoa : public ImageRep {
    328  public:
    329   explicit ImageRepCocoa(NSImage* image)
    330       : ImageRep(Image::kImageRepCocoa),
    331         image_(image) {
    332     CHECK(image);
    333   }
    334 
    335   virtual ~ImageRepCocoa() {
    336     base::mac::NSObjectRelease(image_);
    337     image_ = nil;
    338   }
    339 
    340   virtual int Width() const OVERRIDE {
    341     return Size().width();
    342   }
    343 
    344   virtual int Height() const OVERRIDE {
    345     return Size().height();
    346   }
    347 
    348   virtual gfx::Size Size() const OVERRIDE {
    349     return internal::NSImageSize(image_);
    350   }
    351 
    352   NSImage* image() const { return image_; }
    353 
    354  private:
    355   NSImage* image_;
    356 
    357   DISALLOW_COPY_AND_ASSIGN(ImageRepCocoa);
    358 };
    359 #endif  // defined(OS_MACOSX)
    360 
    361 // The Storage class acts similarly to the pixels in a SkBitmap: the Image
    362 // class holds a refptr instance of Storage, which in turn holds all the
    363 // ImageReps. This way, the Image can be cheaply copied.
    364 class ImageStorage : public base::RefCounted<ImageStorage> {
    365  public:
    366   ImageStorage(Image::RepresentationType default_type)
    367       : default_representation_type_(default_type),
    368 #if defined(OS_MACOSX) && !defined(OS_IOS)
    369         default_representation_color_space_(
    370             base::mac::GetGenericRGBColorSpace()),
    371 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
    372         representations_deleter_(&representations_) {
    373   }
    374 
    375   Image::RepresentationType default_representation_type() {
    376     return default_representation_type_;
    377   }
    378   Image::RepresentationMap& representations() { return representations_; }
    379 
    380 #if defined(OS_MACOSX) && !defined(OS_IOS)
    381   void set_default_representation_color_space(CGColorSpaceRef color_space) {
    382     default_representation_color_space_ = color_space;
    383   }
    384   CGColorSpaceRef default_representation_color_space() {
    385     return default_representation_color_space_;
    386   }
    387 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
    388 
    389  private:
    390   friend class base::RefCounted<ImageStorage>;
    391 
    392   ~ImageStorage() {}
    393 
    394   // The type of image that was passed to the constructor. This key will always
    395   // exist in the |representations_| map.
    396   Image::RepresentationType default_representation_type_;
    397 
    398 #if defined(OS_MACOSX) && !defined(OS_IOS)
    399   // The default representation's colorspace. This is used for converting to
    400   // NSImage. This field exists to compensate for PNGCodec not writing or
    401   // reading colorspace ancillary chunks. (sRGB, iCCP).
    402   // Not owned.
    403   CGColorSpaceRef default_representation_color_space_;
    404 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
    405 
    406   // All the representations of an Image. Size will always be at least one, with
    407   // more for any converted representations.
    408   Image::RepresentationMap representations_;
    409 
    410   STLValueDeleter<Image::RepresentationMap> representations_deleter_;
    411 
    412   DISALLOW_COPY_AND_ASSIGN(ImageStorage);
    413 };
    414 
    415 }  // namespace internal
    416 
    417 Image::Image() {
    418   // |storage_| is NULL for empty Images.
    419 }
    420 
    421 Image::Image(const std::vector<ImagePNGRep>& image_reps) {
    422   // Do not store obviously invalid ImagePNGReps.
    423   std::vector<ImagePNGRep> filtered;
    424   for (size_t i = 0; i < image_reps.size(); ++i) {
    425     if (image_reps[i].raw_data.get() && image_reps[i].raw_data->size())
    426       filtered.push_back(image_reps[i]);
    427   }
    428 
    429   if (filtered.empty())
    430     return;
    431 
    432   storage_ = new internal::ImageStorage(Image::kImageRepPNG);
    433   internal::ImageRepPNG* rep = new internal::ImageRepPNG(filtered);
    434   AddRepresentation(rep);
    435 }
    436 
    437 Image::Image(const ImageSkia& image) {
    438   if (!image.isNull()) {
    439     storage_ = new internal::ImageStorage(Image::kImageRepSkia);
    440     internal::ImageRepSkia* rep = new internal::ImageRepSkia(
    441         new ImageSkia(image));
    442     AddRepresentation(rep);
    443   }
    444 }
    445 
    446 #if defined(OS_IOS)
    447 Image::Image(UIImage* image)
    448     : storage_(new internal::ImageStorage(Image::kImageRepCocoaTouch)) {
    449   if (image) {
    450     internal::ImageRepCocoaTouch* rep = new internal::ImageRepCocoaTouch(image);
    451     AddRepresentation(rep);
    452   }
    453 }
    454 #elif defined(OS_MACOSX)
    455 Image::Image(NSImage* image) {
    456   if (image) {
    457     storage_ = new internal::ImageStorage(Image::kImageRepCocoa);
    458     internal::ImageRepCocoa* rep = new internal::ImageRepCocoa(image);
    459     AddRepresentation(rep);
    460   }
    461 }
    462 #endif
    463 
    464 Image::Image(const Image& other) : storage_(other.storage_) {
    465 }
    466 
    467 Image& Image::operator=(const Image& other) {
    468   storage_ = other.storage_;
    469   return *this;
    470 }
    471 
    472 Image::~Image() {
    473 }
    474 
    475 // static
    476 Image Image::CreateFrom1xBitmap(const SkBitmap& bitmap) {
    477   return Image(ImageSkia::CreateFrom1xBitmap(bitmap));
    478 }
    479 
    480 // static
    481 Image Image::CreateFrom1xPNGBytes(const unsigned char* input,
    482                                   size_t input_size) {
    483   if (input_size == 0u)
    484     return Image();
    485 
    486   scoped_refptr<base::RefCountedBytes> raw_data(new base::RefCountedBytes());
    487   raw_data->data().assign(input, input + input_size);
    488 
    489   return CreateFrom1xPNGBytes(raw_data);
    490 }
    491 
    492 Image Image::CreateFrom1xPNGBytes(
    493     const scoped_refptr<base::RefCountedMemory>& input) {
    494   if (!input.get() || input->size() == 0u)
    495     return Image();
    496 
    497   std::vector<ImagePNGRep> image_reps;
    498   image_reps.push_back(ImagePNGRep(input, 1.0f));
    499   return Image(image_reps);
    500 }
    501 
    502 const SkBitmap* Image::ToSkBitmap() const {
    503   // Possibly create and cache an intermediate ImageRepSkia.
    504   return ToImageSkia()->bitmap();
    505 }
    506 
    507 const ImageSkia* Image::ToImageSkia() const {
    508   internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
    509   if (!rep) {
    510     switch (DefaultRepresentationType()) {
    511       case kImageRepPNG: {
    512         internal::ImageRepPNG* png_rep =
    513             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
    514         rep = new internal::ImageRepSkia(
    515             internal::ImageSkiaFromPNG(png_rep->image_reps()));
    516         break;
    517       }
    518 #if defined(OS_IOS)
    519       case kImageRepCocoaTouch: {
    520         internal::ImageRepCocoaTouch* native_rep =
    521             GetRepresentation(kImageRepCocoaTouch, true)
    522                 ->AsImageRepCocoaTouch();
    523         rep = new internal::ImageRepSkia(new ImageSkia(
    524             ImageSkiaFromUIImage(native_rep->image())));
    525         break;
    526       }
    527 #elif defined(OS_MACOSX)
    528       case kImageRepCocoa: {
    529         internal::ImageRepCocoa* native_rep =
    530             GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
    531         rep = new internal::ImageRepSkia(new ImageSkia(
    532             ImageSkiaFromNSImage(native_rep->image())));
    533         break;
    534       }
    535 #endif
    536       default:
    537         NOTREACHED();
    538     }
    539     CHECK(rep);
    540     AddRepresentation(rep);
    541   }
    542   return rep->AsImageRepSkia()->image();
    543 }
    544 
    545 #if defined(OS_IOS)
    546 UIImage* Image::ToUIImage() const {
    547   internal::ImageRep* rep = GetRepresentation(kImageRepCocoaTouch, false);
    548   if (!rep) {
    549     switch (DefaultRepresentationType()) {
    550       case kImageRepPNG: {
    551         internal::ImageRepPNG* png_rep =
    552             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
    553         rep = new internal::ImageRepCocoaTouch(internal::CreateUIImageFromPNG(
    554             png_rep->image_reps()));
    555         break;
    556       }
    557       case kImageRepSkia: {
    558         internal::ImageRepSkia* skia_rep =
    559             GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
    560         UIImage* image = UIImageFromImageSkia(*skia_rep->image());
    561         base::mac::NSObjectRetain(image);
    562         rep = new internal::ImageRepCocoaTouch(image);
    563         break;
    564       }
    565       default:
    566         NOTREACHED();
    567     }
    568     CHECK(rep);
    569     AddRepresentation(rep);
    570   }
    571   return rep->AsImageRepCocoaTouch()->image();
    572 }
    573 #elif defined(OS_MACOSX)
    574 NSImage* Image::ToNSImage() const {
    575   internal::ImageRep* rep = GetRepresentation(kImageRepCocoa, false);
    576   if (!rep) {
    577     CGColorSpaceRef default_representation_color_space =
    578         storage_->default_representation_color_space();
    579 
    580     switch (DefaultRepresentationType()) {
    581       case kImageRepPNG: {
    582         internal::ImageRepPNG* png_rep =
    583             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
    584         rep = new internal::ImageRepCocoa(internal::NSImageFromPNG(
    585             png_rep->image_reps(), default_representation_color_space));
    586         break;
    587       }
    588       case kImageRepSkia: {
    589         internal::ImageRepSkia* skia_rep =
    590             GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
    591         NSImage* image = NSImageFromImageSkiaWithColorSpace(*skia_rep->image(),
    592             default_representation_color_space);
    593         base::mac::NSObjectRetain(image);
    594         rep = new internal::ImageRepCocoa(image);
    595         break;
    596       }
    597       default:
    598         NOTREACHED();
    599     }
    600     CHECK(rep);
    601     AddRepresentation(rep);
    602   }
    603   return rep->AsImageRepCocoa()->image();
    604 }
    605 #endif
    606 
    607 scoped_refptr<base::RefCountedMemory> Image::As1xPNGBytes() const {
    608   if (IsEmpty())
    609     return new base::RefCountedBytes();
    610 
    611   internal::ImageRep* rep = GetRepresentation(kImageRepPNG, false);
    612 
    613   if (rep) {
    614     const std::vector<ImagePNGRep>& image_png_reps =
    615         rep->AsImageRepPNG()->image_reps();
    616     for (size_t i = 0; i < image_png_reps.size(); ++i) {
    617       if (image_png_reps[i].scale == 1.0f)
    618         return image_png_reps[i].raw_data;
    619     }
    620     return new base::RefCountedBytes();
    621   }
    622 
    623   scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
    624   switch (DefaultRepresentationType()) {
    625 #if defined(OS_IOS)
    626     case kImageRepCocoaTouch: {
    627       internal::ImageRepCocoaTouch* cocoa_touch_rep =
    628           GetRepresentation(kImageRepCocoaTouch, true)
    629               ->AsImageRepCocoaTouch();
    630       png_bytes = internal::Get1xPNGBytesFromUIImage(
    631           cocoa_touch_rep->image());
    632       break;
    633     }
    634 #elif defined(OS_MACOSX)
    635     case kImageRepCocoa: {
    636       internal::ImageRepCocoa* cocoa_rep =
    637           GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
    638       png_bytes = internal::Get1xPNGBytesFromNSImage(cocoa_rep->image());
    639       break;
    640     }
    641 #endif
    642     case kImageRepSkia: {
    643       internal::ImageRepSkia* skia_rep =
    644           GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
    645       png_bytes = internal::Get1xPNGBytesFromImageSkia(skia_rep->image());
    646       break;
    647     }
    648     default:
    649       NOTREACHED();
    650   }
    651   if (!png_bytes.get() || !png_bytes->size()) {
    652     // Add an ImageRepPNG with no data such that the conversion is not
    653     // attempted each time we want the PNG bytes.
    654     AddRepresentation(new internal::ImageRepPNG());
    655     return new base::RefCountedBytes();
    656   }
    657 
    658   // Do not insert representations for scale factors other than 1x even if
    659   // they are available because:
    660   // - Only the 1x PNG bytes can be accessed.
    661   // - ImageRepPNG is not used as an intermediate type in converting to a
    662   //   final type eg (converting from ImageRepSkia to ImageRepPNG to get an
    663   //   ImageRepCocoa).
    664   std::vector<ImagePNGRep> image_png_reps;
    665   image_png_reps.push_back(ImagePNGRep(png_bytes, 1.0f));
    666   rep = new internal::ImageRepPNG(image_png_reps);
    667   AddRepresentation(rep);
    668   return png_bytes;
    669 }
    670 
    671 SkBitmap Image::AsBitmap() const {
    672   return IsEmpty() ? SkBitmap() : *ToSkBitmap();
    673 }
    674 
    675 ImageSkia Image::AsImageSkia() const {
    676   return IsEmpty() ? ImageSkia() : *ToImageSkia();
    677 }
    678 
    679 #if defined(OS_MACOSX) && !defined(OS_IOS)
    680 NSImage* Image::AsNSImage() const {
    681   return IsEmpty() ? nil : ToNSImage();
    682 }
    683 #endif
    684 
    685 scoped_refptr<base::RefCountedMemory> Image::Copy1xPNGBytes() const {
    686   scoped_refptr<base::RefCountedMemory> original = As1xPNGBytes();
    687   scoped_refptr<base::RefCountedBytes> copy(new base::RefCountedBytes());
    688   copy->data().assign(original->front(), original->front() + original->size());
    689   return copy;
    690 }
    691 
    692 ImageSkia* Image::CopyImageSkia() const {
    693   return new ImageSkia(*ToImageSkia());
    694 }
    695 
    696 SkBitmap* Image::CopySkBitmap() const {
    697   return new SkBitmap(*ToSkBitmap());
    698 }
    699 
    700 #if defined(OS_IOS)
    701 UIImage* Image::CopyUIImage() const {
    702   UIImage* image = ToUIImage();
    703   base::mac::NSObjectRetain(image);
    704   return image;
    705 }
    706 #elif defined(OS_MACOSX)
    707 NSImage* Image::CopyNSImage() const {
    708   NSImage* image = ToNSImage();
    709   base::mac::NSObjectRetain(image);
    710   return image;
    711 }
    712 #endif
    713 
    714 bool Image::HasRepresentation(RepresentationType type) const {
    715   return storage_.get() && storage_->representations().count(type) != 0;
    716 }
    717 
    718 size_t Image::RepresentationCount() const {
    719   if (!storage_.get())
    720     return 0;
    721 
    722   return storage_->representations().size();
    723 }
    724 
    725 bool Image::IsEmpty() const {
    726   return RepresentationCount() == 0;
    727 }
    728 
    729 int Image::Width() const {
    730   if (IsEmpty())
    731     return 0;
    732   return GetRepresentation(DefaultRepresentationType(), true)->Width();
    733 }
    734 
    735 int Image::Height() const {
    736   if (IsEmpty())
    737     return 0;
    738   return GetRepresentation(DefaultRepresentationType(), true)->Height();
    739 }
    740 
    741 gfx::Size Image::Size() const {
    742   if (IsEmpty())
    743     return gfx::Size();
    744   return GetRepresentation(DefaultRepresentationType(), true)->Size();
    745 }
    746 
    747 void Image::SwapRepresentations(Image* other) {
    748   storage_.swap(other->storage_);
    749 }
    750 
    751 #if defined(OS_MACOSX)  && !defined(OS_IOS)
    752 void Image::SetSourceColorSpace(CGColorSpaceRef color_space) {
    753   if (storage_.get())
    754     storage_->set_default_representation_color_space(color_space);
    755 }
    756 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
    757 
    758 Image::RepresentationType Image::DefaultRepresentationType() const {
    759   CHECK(storage_.get());
    760   return storage_->default_representation_type();
    761 }
    762 
    763 internal::ImageRep* Image::GetRepresentation(
    764     RepresentationType rep_type, bool must_exist) const {
    765   CHECK(storage_.get());
    766   RepresentationMap::iterator it = storage_->representations().find(rep_type);
    767   if (it == storage_->representations().end()) {
    768     CHECK(!must_exist);
    769     return NULL;
    770   }
    771   return it->second;
    772 }
    773 
    774 void Image::AddRepresentation(internal::ImageRep* rep) const {
    775   CHECK(storage_.get());
    776   storage_->representations().insert(std::make_pair(rep->type(), rep));
    777 }
    778 
    779 }  // namespace gfx
    780