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