ui/gfx/image/image.cc

   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/stl_util.h"
  12 #include "third_party/skia/include/core/SkBitmap.h"
  13 #include "ui/gfx/geometry/size.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
  18 #if !defined(OS_IOS)
  19 #include "ui/gfx/codec/png_codec.h"
  20 #endif
  21
  22 #if defined(OS_IOS)
  23 #include "base/mac/foundation_util.h"
  24 #include "ui/gfx/image/image_skia_util_ios.h"
  25 #elif defined(OS_MACOSX)
  26 #include "base/mac/foundation_util.h"
  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   ~PNGImageSource() override {}
  70
  71   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   ~ImageRepPNG() override {}
 225
 226   int Width() const override { return Size().width(); }
 227
 228   int Height() const override { return Size().height(); }
 229
 230   gfx::Size Size() const override {
 231     // Read the PNG data to get the image size, caching it.
 232     if (!size_cache_) {
 233       for (std::vector<ImagePNGRep>::const_iterator it = image_reps().begin();
 234            it != image_reps().end(); ++it) {
 235         if (it->scale == 1.0f) {
 236           size_cache_.reset(new gfx::Size(it->Size()));
 237           return *size_cache_;
 238         }
 239       }
 240       size_cache_.reset(new gfx::Size);
 241     }
 242
 243     return *size_cache_;
 244   }
 245
 246   const std::vector<ImagePNGRep>& image_reps() const { return image_png_reps_; }
 247
 248  private:
 249   std::vector<ImagePNGRep> image_png_reps_;
 250
 251   // Cached to avoid having to parse the raw data multiple times.
 252   mutable scoped_ptr<gfx::Size> size_cache_;
 253
 254   DISALLOW_COPY_AND_ASSIGN(ImageRepPNG);
 255 };
 256
 257 class ImageRepSkia : public ImageRep {
 258  public:
 259   // Takes ownership of |image|.
 260   explicit ImageRepSkia(ImageSkia* image)
 261       : ImageRep(Image::kImageRepSkia),
 262         image_(image) {
 263   }
 264
 265   ~ImageRepSkia() override {}
 266
 267   int Width() const override { return image_->width(); }
 268
 269   int Height() const override { return image_->height(); }
 270
 271   gfx::Size Size() const override { return image_->size(); }
 272
 273   ImageSkia* image() { return image_.get(); }
 274
 275  private:
 276   scoped_ptr<ImageSkia> image_;
 277
 278   DISALLOW_COPY_AND_ASSIGN(ImageRepSkia);
 279 };
 280
 281 #if defined(OS_IOS)
 282 class ImageRepCocoaTouch : public ImageRep {
 283  public:
 284   explicit ImageRepCocoaTouch(UIImage* image)
 285       : ImageRep(Image::kImageRepCocoaTouch),
 286         image_(image) {
 287     CHECK(image);
 288   }
 289
 290   ~ImageRepCocoaTouch() override {
 291     base::mac::NSObjectRelease(image_);
 292     image_ = nil;
 293   }
 294
 295   int Width() const override { return Size().width(); }
 296
 297   int Height() const override { return Size().height(); }
 298
 299   gfx::Size Size() const override { return internal::UIImageSize(image_); }
 300
 301   UIImage* image() const { return image_; }
 302
 303  private:
 304   UIImage* image_;
 305
 306   DISALLOW_COPY_AND_ASSIGN(ImageRepCocoaTouch);
 307 };
 308 #elif defined(OS_MACOSX)
 309 class ImageRepCocoa : public ImageRep {
 310  public:
 311   explicit ImageRepCocoa(NSImage* image)
 312       : ImageRep(Image::kImageRepCocoa),
 313         image_(image) {
 314     CHECK(image);
 315   }
 316
 317   ~ImageRepCocoa() override {
 318     base::mac::NSObjectRelease(image_);
 319     image_ = nil;
 320   }
 321
 322   int Width() const override { return Size().width(); }
 323
 324   int Height() const override { return Size().height(); }
 325
 326   gfx::Size Size() const override { return internal::NSImageSize(image_); }
 327
 328   NSImage* image() const { return image_; }
 329
 330  private:
 331   NSImage* image_;
 332
 333   DISALLOW_COPY_AND_ASSIGN(ImageRepCocoa);
 334 };
 335 #endif  // defined(OS_MACOSX)
 336
 337 // The Storage class acts similarly to the pixels in a SkBitmap: the Image
 338 // class holds a refptr instance of Storage, which in turn holds all the
 339 // ImageReps. This way, the Image can be cheaply copied.
 340 class ImageStorage : public base::RefCounted<ImageStorage> {
 341  public:
 342   ImageStorage(Image::RepresentationType default_type)
 343       : default_representation_type_(default_type),
 344 #if defined(OS_MACOSX) && !defined(OS_IOS)
 345         default_representation_color_space_(
 346             base::mac::GetGenericRGBColorSpace()),
 347 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 348         representations_deleter_(&representations_) {
 349   }
 350
 351   Image::RepresentationType default_representation_type() {
 352     return default_representation_type_;
 353   }
 354   Image::RepresentationMap& representations() { return representations_; }
 355
 356 #if defined(OS_MACOSX) && !defined(OS_IOS)
 357   void set_default_representation_color_space(CGColorSpaceRef color_space) {
 358     default_representation_color_space_ = color_space;
 359   }
 360   CGColorSpaceRef default_representation_color_space() {
 361     return default_representation_color_space_;
 362   }
 363 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 364
 365  private:
 366   friend class base::RefCounted<ImageStorage>;
 367
 368   ~ImageStorage() {}
 369
 370   // The type of image that was passed to the constructor. This key will always
 371   // exist in the |representations_| map.
 372   Image::RepresentationType default_representation_type_;
 373
 374 #if defined(OS_MACOSX) && !defined(OS_IOS)
 375   // The default representation's colorspace. This is used for converting to
 376   // NSImage. This field exists to compensate for PNGCodec not writing or
 377   // reading colorspace ancillary chunks. (sRGB, iCCP).
 378   // Not owned.
 379   CGColorSpaceRef default_representation_color_space_;
 380 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 381
 382   // All the representations of an Image. Size will always be at least one, with
 383   // more for any converted representations.
 384   Image::RepresentationMap representations_;
 385
 386   STLValueDeleter<Image::RepresentationMap> representations_deleter_;
 387
 388   DISALLOW_COPY_AND_ASSIGN(ImageStorage);
 389 };
 390
 391 }  // namespace internal
 392
 393 Image::Image() {
 394   // |storage_| is NULL for empty Images.
 395 }
 396
 397 Image::Image(const std::vector<ImagePNGRep>& image_reps) {
 398   // Do not store obviously invalid ImagePNGReps.
 399   std::vector<ImagePNGRep> filtered;
 400   for (size_t i = 0; i < image_reps.size(); ++i) {
 401     if (image_reps[i].raw_data.get() && image_reps[i].raw_data->size())
 402       filtered.push_back(image_reps[i]);
 403   }
 404
 405   if (filtered.empty())
 406     return;
 407
 408   storage_ = new internal::ImageStorage(Image::kImageRepPNG);
 409   AddRepresentation(make_scoped_ptr(new internal::ImageRepPNG(filtered)));
 410 }
 411
 412 Image::Image(const ImageSkia& image) {
 413   if (!image.isNull()) {
 414     storage_ = new internal::ImageStorage(Image::kImageRepSkia);
 415     AddRepresentation(
 416         make_scoped_ptr(new internal::ImageRepSkia(new ImageSkia(image))));
 417   }
 418 }
 419
 420 #if defined(OS_IOS)
 421 Image::Image(UIImage* image)
 422     : storage_(new internal::ImageStorage(Image::kImageRepCocoaTouch)) {
 423   if (image)
 424     AddRepresentation(make_scoped_ptr(new internal::ImageRepCocoaTouch(image)));
 425 }
 426 #elif defined(OS_MACOSX)
 427 Image::Image(NSImage* image) {
 428   if (image) {
 429     storage_ = new internal::ImageStorage(Image::kImageRepCocoa);
 430     AddRepresentation(make_scoped_ptr(new internal::ImageRepCocoa(image)));
 431   }
 432 }
 433 #endif
 434
 435 Image::Image(const Image& other) : storage_(other.storage_) {
 436 }
 437
 438 Image& Image::operator=(const Image& other) {
 439   storage_ = other.storage_;
 440   return *this;
 441 }
 442
 443 Image::~Image() {
 444 }
 445
 446 // static
 447 Image Image::CreateFrom1xBitmap(const SkBitmap& bitmap) {
 448   return Image(ImageSkia::CreateFrom1xBitmap(bitmap));
 449 }
 450
 451 // static
 452 Image Image::CreateFrom1xPNGBytes(const unsigned char* input,
 453                                   size_t input_size) {
 454   if (input_size == 0u)
 455     return Image();
 456
 457   scoped_refptr<base::RefCountedBytes> raw_data(new base::RefCountedBytes());
 458   raw_data->data().assign(input, input + input_size);
 459
 460   return CreateFrom1xPNGBytes(raw_data);
 461 }
 462
 463 Image Image::CreateFrom1xPNGBytes(
 464     const scoped_refptr<base::RefCountedMemory>& input) {
 465   if (!input.get() || input->size() == 0u)
 466     return Image();
 467
 468   std::vector<ImagePNGRep> image_reps;
 469   image_reps.push_back(ImagePNGRep(input, 1.0f));
 470   return Image(image_reps);
 471 }
 472
 473 const SkBitmap* Image::ToSkBitmap() const {
 474   // Possibly create and cache an intermediate ImageRepSkia.
 475   return ToImageSkia()->bitmap();
 476 }
 477
 478 const ImageSkia* Image::ToImageSkia() const {
 479   internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
 480   if (!rep) {
 481     scoped_ptr<internal::ImageRep> scoped_rep;
 482     switch (DefaultRepresentationType()) {
 483       case kImageRepPNG: {
 484         internal::ImageRepPNG* png_rep =
 485             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
 486         scoped_rep.reset(new internal::ImageRepSkia(
 487             internal::ImageSkiaFromPNG(png_rep->image_reps())));
 488         break;
 489       }
 490 #if defined(OS_IOS)
 491       case kImageRepCocoaTouch: {
 492         internal::ImageRepCocoaTouch* native_rep =
 493             GetRepresentation(kImageRepCocoaTouch, true)
 494                 ->AsImageRepCocoaTouch();
 495         scoped_rep.reset(new internal::ImageRepSkia(
 496             new ImageSkia(ImageSkiaFromUIImage(native_rep->image()))));
 497         break;
 498       }
 499 #elif defined(OS_MACOSX)
 500       case kImageRepCocoa: {
 501         internal::ImageRepCocoa* native_rep =
 502             GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
 503         scoped_rep.reset(new internal::ImageRepSkia(
 504             new ImageSkia(ImageSkiaFromNSImage(native_rep->image()))));
 505         break;
 506       }
 507 #endif
 508       default:
 509         NOTREACHED();
 510     }
 511     CHECK(scoped_rep);
 512     rep = scoped_rep.get();
 513     AddRepresentation(scoped_rep.Pass());
 514   }
 515   return rep->AsImageRepSkia()->image();
 516 }
 517
 518 #if defined(OS_IOS)
 519 UIImage* Image::ToUIImage() const {
 520   internal::ImageRep* rep = GetRepresentation(kImageRepCocoaTouch, false);
 521   if (!rep) {
 522     scoped_ptr<internal::ImageRep> scoped_rep;
 523     switch (DefaultRepresentationType()) {
 524       case kImageRepPNG: {
 525         internal::ImageRepPNG* png_rep =
 526             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
 527         scoped_rep.reset(new internal::ImageRepCocoaTouch(
 528             internal::CreateUIImageFromPNG(png_rep->image_reps())));
 529         break;
 530       }
 531       case kImageRepSkia: {
 532         internal::ImageRepSkia* skia_rep =
 533             GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
 534         UIImage* image = UIImageFromImageSkia(*skia_rep->image());
 535         base::mac::NSObjectRetain(image);
 536         scoped_rep.reset(new internal::ImageRepCocoaTouch(image));
 537         break;
 538       }
 539       default:
 540         NOTREACHED();
 541     }
 542     CHECK(scoped_rep);
 543     rep = scoped_rep.get();
 544     AddRepresentation(scoped_rep.Pass());
 545   }
 546   return rep->AsImageRepCocoaTouch()->image();
 547 }
 548 #elif defined(OS_MACOSX)
 549 NSImage* Image::ToNSImage() const {
 550   internal::ImageRep* rep = GetRepresentation(kImageRepCocoa, false);
 551   if (!rep) {
 552     scoped_ptr<internal::ImageRep> scoped_rep;
 553     CGColorSpaceRef default_representation_color_space =
 554         storage_->default_representation_color_space();
 555
 556     switch (DefaultRepresentationType()) {
 557       case kImageRepPNG: {
 558         internal::ImageRepPNG* png_rep =
 559             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
 560         scoped_rep.reset(new internal::ImageRepCocoa(internal::NSImageFromPNG(
 561             png_rep->image_reps(), default_representation_color_space)));
 562         break;
 563       }
 564       case kImageRepSkia: {
 565         internal::ImageRepSkia* skia_rep =
 566             GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
 567         NSImage* image = NSImageFromImageSkiaWithColorSpace(*skia_rep->image(),
 568             default_representation_color_space);
 569         base::mac::NSObjectRetain(image);
 570         scoped_rep.reset(new internal::ImageRepCocoa(image));
 571         break;
 572       }
 573       default:
 574         NOTREACHED();
 575     }
 576     CHECK(scoped_rep);
 577     rep = scoped_rep.get();
 578     AddRepresentation(scoped_rep.Pass());
 579   }
 580   return rep->AsImageRepCocoa()->image();
 581 }
 582 #endif
 583
 584 scoped_refptr<base::RefCountedMemory> Image::As1xPNGBytes() const {
 585   if (IsEmpty())
 586     return new base::RefCountedBytes();
 587
 588   internal::ImageRep* rep = GetRepresentation(kImageRepPNG, false);
 589
 590   if (rep) {
 591     const std::vector<ImagePNGRep>& image_png_reps =
 592         rep->AsImageRepPNG()->image_reps();
 593     for (size_t i = 0; i < image_png_reps.size(); ++i) {
 594       if (image_png_reps[i].scale == 1.0f)
 595         return image_png_reps[i].raw_data;
 596     }
 597     return new base::RefCountedBytes();
 598   }
 599
 600   scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
 601   switch (DefaultRepresentationType()) {
 602 #if defined(OS_IOS)
 603     case kImageRepCocoaTouch: {
 604       internal::ImageRepCocoaTouch* cocoa_touch_rep =
 605           GetRepresentation(kImageRepCocoaTouch, true)
 606               ->AsImageRepCocoaTouch();
 607       png_bytes = internal::Get1xPNGBytesFromUIImage(
 608           cocoa_touch_rep->image());
 609       break;
 610     }
 611 #elif defined(OS_MACOSX)
 612     case kImageRepCocoa: {
 613       internal::ImageRepCocoa* cocoa_rep =
 614           GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
 615       png_bytes = internal::Get1xPNGBytesFromNSImage(cocoa_rep->image());
 616       break;
 617     }
 618 #endif
 619     case kImageRepSkia: {
 620       internal::ImageRepSkia* skia_rep =
 621           GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
 622       png_bytes = internal::Get1xPNGBytesFromImageSkia(skia_rep->image());
 623       break;
 624     }
 625     default:
 626       NOTREACHED();
 627   }
 628   if (!png_bytes.get() || !png_bytes->size()) {
 629     // Add an ImageRepPNG with no data such that the conversion is not
 630     // attempted each time we want the PNG bytes.
 631     AddRepresentation(make_scoped_ptr(new internal::ImageRepPNG()));
 632     return new base::RefCountedBytes();
 633   }
 634
 635   // Do not insert representations for scale factors other than 1x even if
 636   // they are available because:
 637   // - Only the 1x PNG bytes can be accessed.
 638   // - ImageRepPNG is not used as an intermediate type in converting to a
 639   //   final type eg (converting from ImageRepSkia to ImageRepPNG to get an
 640   //   ImageRepCocoa).
 641   std::vector<ImagePNGRep> image_png_reps;
 642   image_png_reps.push_back(ImagePNGRep(png_bytes, 1.0f));
 643   AddRepresentation(make_scoped_ptr(new internal::ImageRepPNG(image_png_reps)));
 644   return png_bytes;
 645 }
 646
 647 SkBitmap Image::AsBitmap() const {
 648   return IsEmpty() ? SkBitmap() : *ToSkBitmap();
 649 }
 650
 651 ImageSkia Image::AsImageSkia() const {
 652   return IsEmpty() ? ImageSkia() : *ToImageSkia();
 653 }
 654
 655 #if defined(OS_MACOSX) && !defined(OS_IOS)
 656 NSImage* Image::AsNSImage() const {
 657   return IsEmpty() ? nil : ToNSImage();
 658 }
 659 #endif
 660
 661 scoped_refptr<base::RefCountedMemory> Image::Copy1xPNGBytes() const {
 662   scoped_refptr<base::RefCountedMemory> original = As1xPNGBytes();
 663   scoped_refptr<base::RefCountedBytes> copy(new base::RefCountedBytes());
 664   copy->data().assign(original->front(), original->front() + original->size());
 665   return copy;
 666 }
 667
 668 ImageSkia* Image::CopyImageSkia() const {
 669   return new ImageSkia(*ToImageSkia());
 670 }
 671
 672 SkBitmap* Image::CopySkBitmap() const {
 673   return new SkBitmap(*ToSkBitmap());
 674 }
 675
 676 #if defined(OS_IOS)
 677 UIImage* Image::CopyUIImage() const {
 678   UIImage* image = ToUIImage();
 679   base::mac::NSObjectRetain(image);
 680   return image;
 681 }
 682 #elif defined(OS_MACOSX)
 683 NSImage* Image::CopyNSImage() const {
 684   NSImage* image = ToNSImage();
 685   base::mac::NSObjectRetain(image);
 686   return image;
 687 }
 688 #endif
 689
 690 bool Image::HasRepresentation(RepresentationType type) const {
 691   return storage_.get() && storage_->representations().count(type) != 0;
 692 }
 693
 694 size_t Image::RepresentationCount() const {
 695   if (!storage_.get())
 696     return 0;
 697
 698   return storage_->representations().size();
 699 }
 700
 701 bool Image::IsEmpty() const {
 702   return RepresentationCount() == 0;
 703 }
 704
 705 int Image::Width() const {
 706   if (IsEmpty())
 707     return 0;
 708   return GetRepresentation(DefaultRepresentationType(), true)->Width();
 709 }
 710
 711 int Image::Height() const {
 712   if (IsEmpty())
 713     return 0;
 714   return GetRepresentation(DefaultRepresentationType(), true)->Height();
 715 }
 716
 717 gfx::Size Image::Size() const {
 718   if (IsEmpty())
 719     return gfx::Size();
 720   return GetRepresentation(DefaultRepresentationType(), true)->Size();
 721 }
 722
 723 void Image::SwapRepresentations(Image* other) {
 724   storage_.swap(other->storage_);
 725 }
 726
 727 #if defined(OS_MACOSX)  && !defined(OS_IOS)
 728 void Image::SetSourceColorSpace(CGColorSpaceRef color_space) {
 729   if (storage_.get())
 730     storage_->set_default_representation_color_space(color_space);
 731 }
 732 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 733
 734 Image::RepresentationType Image::DefaultRepresentationType() const {
 735   CHECK(storage_.get());
 736   return storage_->default_representation_type();
 737 }
 738
 739 internal::ImageRep* Image::GetRepresentation(
 740     RepresentationType rep_type, bool must_exist) const {
 741   CHECK(storage_.get());
 742   RepresentationMap::iterator it = storage_->representations().find(rep_type);
 743   if (it == storage_->representations().end()) {
 744     CHECK(!must_exist);
 745     return NULL;
 746   }
 747   return it->second;
 748 }
 749
 750 void Image::AddRepresentation(scoped_ptr<internal::ImageRep> rep) const {
 751   CHECK(storage_.get());
 752   RepresentationType type = rep->type();
 753   storage_->representations().insert(std::make_pair(type, rep.release()));
 754 }
 755
 756 }  // namespace gfx