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.
GetErrorImageSkia()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:
PNGImageSource()69 PNGImageSource() {}
~PNGImageSource()70 virtual ~PNGImageSource() {}
71
GetImageForScale(float scale)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
size() const94 const gfx::Size size() const {
95 return size_;
96 }
97
AddPNGData(const ImagePNGRep & png_rep)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
ToImageSkiaRep(const ImagePNGRep & png_rep)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 {
operator ()gfx::internal::PNGImageSource::Compare122 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
ImageSkiaFromPNG(const std::vector<ImagePNGRep> & image_png_reps)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
Get1xPNGBytesFromImageSkia(const ImageSkia * image_skia)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:
ImageRep(Image::RepresentationType rep)177 explicit ImageRep(Image::RepresentationType rep) : type_(rep) {}
178
179 // Deletes the associated pixels of an ImageRep.
~ImageRep()180 virtual ~ImageRep() {}
181
182 // Cast helpers ("fake RTTI").
AsImageRepPNG()183 ImageRepPNG* AsImageRepPNG() {
184 CHECK_EQ(type_, Image::kImageRepPNG);
185 return reinterpret_cast<ImageRepPNG*>(this);
186 }
187
AsImageRepSkia()188 ImageRepSkia* AsImageRepSkia() {
189 CHECK_EQ(type_, Image::kImageRepSkia);
190 return reinterpret_cast<ImageRepSkia*>(this);
191 }
192
193 #if defined(OS_IOS)
AsImageRepCocoaTouch()194 ImageRepCocoaTouch* AsImageRepCocoaTouch() {
195 CHECK_EQ(type_, Image::kImageRepCocoaTouch);
196 return reinterpret_cast<ImageRepCocoaTouch*>(this);
197 }
198 #elif defined(OS_MACOSX)
AsImageRepCocoa()199 ImageRepCocoa* AsImageRepCocoa() {
200 CHECK_EQ(type_, Image::kImageRepCocoa);
201 return reinterpret_cast<ImageRepCocoa*>(this);
202 }
203 #endif
204
type() const205 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:
ImageRepPNG()217 ImageRepPNG() : ImageRep(Image::kImageRepPNG) {
218 }
219
ImageRepPNG(const std::vector<ImagePNGRep> & image_png_reps)220 ImageRepPNG(const std::vector<ImagePNGRep>& image_png_reps)
221 : ImageRep(Image::kImageRepPNG),
222 image_png_reps_(image_png_reps) {
223 }
224
~ImageRepPNG()225 virtual ~ImageRepPNG() {
226 }
227
Width() const228 virtual int Width() const OVERRIDE {
229 return Size().width();
230 }
231
Height() const232 virtual int Height() const OVERRIDE {
233 return Size().height();
234 }
235
Size() const236 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
image_reps() const252 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|.
ImageRepSkia(ImageSkia * image)266 explicit ImageRepSkia(ImageSkia* image)
267 : ImageRep(Image::kImageRepSkia),
268 image_(image) {
269 }
270
~ImageRepSkia()271 virtual ~ImageRepSkia() {
272 }
273
Width() const274 virtual int Width() const OVERRIDE {
275 return image_->width();
276 }
277
Height() const278 virtual int Height() const OVERRIDE {
279 return image_->height();
280 }
281
Size() const282 virtual gfx::Size Size() const OVERRIDE {
283 return image_->size();
284 }
285
image()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:
ImageRepCocoaTouch(UIImage * image)297 explicit ImageRepCocoaTouch(UIImage* image)
298 : ImageRep(Image::kImageRepCocoaTouch),
299 image_(image) {
300 CHECK(image);
301 }
302
~ImageRepCocoaTouch()303 virtual ~ImageRepCocoaTouch() {
304 base::mac::NSObjectRelease(image_);
305 image_ = nil;
306 }
307
Width() const308 virtual int Width() const OVERRIDE {
309 return Size().width();
310 }
311
Height() const312 virtual int Height() const OVERRIDE {
313 return Size().height();
314 }
315
Size() const316 virtual gfx::Size Size() const OVERRIDE {
317 return internal::UIImageSize(image_);
318 }
319
image() const320 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:
ImageRepCocoa(NSImage * image)330 explicit ImageRepCocoa(NSImage* image)
331 : ImageRep(Image::kImageRepCocoa),
332 image_(image) {
333 CHECK(image);
334 }
335
~ImageRepCocoa()336 virtual ~ImageRepCocoa() {
337 base::mac::NSObjectRelease(image_);
338 image_ = nil;
339 }
340
Width() const341 virtual int Width() const OVERRIDE {
342 return Size().width();
343 }
344
Height() const345 virtual int Height() const OVERRIDE {
346 return Size().height();
347 }
348
Size() const349 virtual gfx::Size Size() const OVERRIDE {
350 return internal::NSImageSize(image_);
351 }
352
image() const353 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:
ImageStorage(Image::RepresentationType default_type)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
default_representation_type()376 Image::RepresentationType default_representation_type() {
377 return default_representation_type_;
378 }
representations()379 Image::RepresentationMap& representations() { return representations_; }
380
381 #if defined(OS_MACOSX) && !defined(OS_IOS)
set_default_representation_color_space(CGColorSpaceRef color_space)382 void set_default_representation_color_space(CGColorSpaceRef color_space) {
383 default_representation_color_space_ = color_space;
384 }
default_representation_color_space()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
~ImageStorage()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
Image()418 Image::Image() {
419 // |storage_| is NULL for empty Images.
420 }
421
Image(const std::vector<ImagePNGRep> & image_reps)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
Image(const ImageSkia & image)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)
Image(UIImage * image)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)
Image(NSImage * image)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
Image(const Image & other)465 Image::Image(const Image& other) : storage_(other.storage_) {
466 }
467
operator =(const Image & other)468 Image& Image::operator=(const Image& other) {
469 storage_ = other.storage_;
470 return *this;
471 }
472
~Image()473 Image::~Image() {
474 }
475
476 // static
CreateFrom1xBitmap(const SkBitmap & bitmap)477 Image Image::CreateFrom1xBitmap(const SkBitmap& bitmap) {
478 return Image(ImageSkia::CreateFrom1xBitmap(bitmap));
479 }
480
481 // static
CreateFrom1xPNGBytes(const unsigned char * input,size_t input_size)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
CreateFrom1xPNGBytes(const scoped_refptr<base::RefCountedMemory> & input)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
ToSkBitmap() const503 const SkBitmap* Image::ToSkBitmap() const {
504 // Possibly create and cache an intermediate ImageRepSkia.
505 return ToImageSkia()->bitmap();
506 }
507
ToImageSkia() const508 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)
ToUIImage() const547 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)
ToNSImage() const575 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
As1xPNGBytes() const608 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
AsBitmap() const672 SkBitmap Image::AsBitmap() const {
673 return IsEmpty() ? SkBitmap() : *ToSkBitmap();
674 }
675
AsImageSkia() const676 ImageSkia Image::AsImageSkia() const {
677 return IsEmpty() ? ImageSkia() : *ToImageSkia();
678 }
679
680 #if defined(OS_MACOSX) && !defined(OS_IOS)
AsNSImage() const681 NSImage* Image::AsNSImage() const {
682 return IsEmpty() ? nil : ToNSImage();
683 }
684 #endif
685
Copy1xPNGBytes() const686 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
CopyImageSkia() const693 ImageSkia* Image::CopyImageSkia() const {
694 return new ImageSkia(*ToImageSkia());
695 }
696
CopySkBitmap() const697 SkBitmap* Image::CopySkBitmap() const {
698 return new SkBitmap(*ToSkBitmap());
699 }
700
701 #if defined(OS_IOS)
CopyUIImage() const702 UIImage* Image::CopyUIImage() const {
703 UIImage* image = ToUIImage();
704 base::mac::NSObjectRetain(image);
705 return image;
706 }
707 #elif defined(OS_MACOSX)
CopyNSImage() const708 NSImage* Image::CopyNSImage() const {
709 NSImage* image = ToNSImage();
710 base::mac::NSObjectRetain(image);
711 return image;
712 }
713 #endif
714
HasRepresentation(RepresentationType type) const715 bool Image::HasRepresentation(RepresentationType type) const {
716 return storage_.get() && storage_->representations().count(type) != 0;
717 }
718
RepresentationCount() const719 size_t Image::RepresentationCount() const {
720 if (!storage_.get())
721 return 0;
722
723 return storage_->representations().size();
724 }
725
IsEmpty() const726 bool Image::IsEmpty() const {
727 return RepresentationCount() == 0;
728 }
729
Width() const730 int Image::Width() const {
731 if (IsEmpty())
732 return 0;
733 return GetRepresentation(DefaultRepresentationType(), true)->Width();
734 }
735
Height() const736 int Image::Height() const {
737 if (IsEmpty())
738 return 0;
739 return GetRepresentation(DefaultRepresentationType(), true)->Height();
740 }
741
Size() const742 gfx::Size Image::Size() const {
743 if (IsEmpty())
744 return gfx::Size();
745 return GetRepresentation(DefaultRepresentationType(), true)->Size();
746 }
747
SwapRepresentations(Image * other)748 void Image::SwapRepresentations(Image* other) {
749 storage_.swap(other->storage_);
750 }
751
752 #if defined(OS_MACOSX) && !defined(OS_IOS)
SetSourceColorSpace(CGColorSpaceRef color_space)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
DefaultRepresentationType() const759 Image::RepresentationType Image::DefaultRepresentationType() const {
760 CHECK(storage_.get());
761 return storage_->default_representation_type();
762 }
763
GetRepresentation(RepresentationType rep_type,bool must_exist) const764 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
AddRepresentation(internal::ImageRep * rep) const775 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