Adds an iOS implementation of gfx::Image.

ui/gfx/image/image.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/image/image.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/skia/include/core/SkBitmap.h"
-#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/size.h"
 
+#if !defined(OS_IOS)
+#include "ui/gfx/codec/png_codec.h"
+#endif
+
 #if defined(TOOLKIT_GTK)
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <gdk/gdk.h>
 #include <glib-object.h>
 #include "ui/base/gtk/scoped_gobject.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/image/cairo_cached_surface.h"
+#elif defined(OS_IOS)
+#include "base/mac/foundation_util.h"
+#include "ui/gfx/image/image_skia_util_ios.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "ui/gfx/image/image_skia_util_mac.h"
 #endif
 
 namespace gfx {
 
 namespace internal {
 
 #if defined(TOOLKIT_GTK)
@@ skipping 43 matching lines @@
   gsize image_size;
   GError* error = NULL;
   CHECK(gdk_pixbuf_save_to_buffer(
       pixbuf, &image, &image_size, "png", &error, NULL));
   png->assign(image, image + image_size);
   g_free(image);
 }
 
 #endif // defined(TOOLKIT_GTK)
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+void PNGFromUIImage(UIImage* nsimage, std::vector<unsigned char>* png);
+UIImage* CreateUIImageFromPNG(const std::vector<unsigned char>& png);
+#elif defined(OS_MACOSX)
 void PNGFromNSImage(NSImage* nsimage, std::vector<unsigned char>* png);
 NSImage* NSImageFromPNG(const std::vector<unsigned char>& png);
 #endif // defined(OS_MACOSX)
 
+#if defined(OS_IOS)
+ImageSkia* ImageSkiaFromPNG(const std::vector<unsigned char>& png);
+void PNGFromImageSkia(const ImageSkia* skia, std::vector<unsigned char>* png);
+#else
 ImageSkia* ImageSkiaFromPNG(const std::vector<unsigned char>& png) {
   SkBitmap bitmap;
   if (!gfx::PNGCodec::Decode(&png.front(), png.size(), &bitmap)) {
     LOG(WARNING) << "Unable to decode PNG.";
     // Return a 16x16 red image to visually show error.
     bitmap.setConfig(SkBitmap::kARGB_8888_Config, 16, 16);
     bitmap.allocPixels();
     bitmap.eraseRGB(0xff, 0, 0);
   }
   return new ImageSkia(bitmap);
 }
 
 void PNGFromImageSkia(const ImageSkia* skia, std::vector<unsigned char>* png) {
   CHECK(gfx::PNGCodec::EncodeBGRASkBitmap(*skia->bitmap(), false, png));
 }
+#endif
 
 class ImageRepPNG;
 class ImageRepSkia;
 class ImageRepGdk;
 class ImageRepCairo;
 class ImageRepCocoa;
+class ImageRepCocoaTouch;
 
 // An ImageRep is the object that holds the backing memory for an Image. Each
 // RepresentationType has an ImageRep subclass that is responsible for freeing
 // the memory that the ImageRep holds. When an ImageRep is created, it expects
 // to take ownership of the image, without having to retain it or increase its
 // reference count.
 class ImageRep {
  public:
   explicit ImageRep(Image::RepresentationType rep) : type_(rep) {}
 
@@ skipping 16 matching lines @@
     CHECK_EQ(type_, Image::kImageRepGdk);
     return reinterpret_cast<ImageRepGdk*>(this);
   }
 
   ImageRepCairo* AsImageRepCairo() {
     CHECK_EQ(type_, Image::kImageRepCairo);
     return reinterpret_cast<ImageRepCairo*>(this);
   }
 #endif
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+  ImageRepCocoaTouch* AsImageRepCocoaTouch() {
+    CHECK_EQ(type_, Image::kImageRepCocoaTouch);
+    return reinterpret_cast<ImageRepCocoaTouch*>(this);
+  }
+#elif defined(OS_MACOSX)
   ImageRepCocoa* AsImageRepCocoa() {
     CHECK_EQ(type_, Image::kImageRepCocoa);
     return reinterpret_cast<ImageRepCocoa*>(this);
   }
 #endif
 
   Image::RepresentationType type() const { return type_; }
 
  private:
   Image::RepresentationType type_;
@@ skipping 78 matching lines @@
 
   CairoCachedSurface* surface() const { return cairo_cache_; }
 
  private:
   CairoCachedSurface* cairo_cache_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepCairo);
 };
 #endif  // defined(TOOLKIT_GTK)
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+class ImageRepCocoaTouch : public ImageRep {
+ public:
+  explicit ImageRepCocoaTouch(UIImage* image)
+      : ImageRep(Image::kImageRepCocoaTouch),
+        image_(image) {
+    CHECK(image);
+  }
+
+  virtual ~ImageRepCocoaTouch() {
+    base::mac::NSObjectRelease(image_);
+    image_ = nil;
+  }
+
+  UIImage* image() const { return image_; }
+
+ private:
+  UIImage* image_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageRepCocoaTouch);
+};
+#elif defined(OS_MACOSX)
 class ImageRepCocoa : public ImageRep {
  public:
   explicit ImageRepCocoa(NSImage* image)
       : ImageRep(Image::kImageRepCocoa),
         image_(image) {
     CHECK(image);
   }
 
   virtual ~ImageRepCocoa() {
     base::mac::NSObjectRelease(image_);
@@ skipping 77 matching lines @@
 #if defined(TOOLKIT_GTK)
 Image::Image(GdkPixbuf* pixbuf) {
   if (pixbuf) {
     storage_ = new internal::ImageStorage(Image::kImageRepGdk);
     internal::ImageRepGdk* rep = new internal::ImageRepGdk(pixbuf);
     AddRepresentation(rep);
   }
 }
 #endif
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+Image::Image(UIImage* image)
+    : storage_(new internal::ImageStorage(Image::kImageRepCocoaTouch)) {
+  if (image) {
+    internal::ImageRepCocoaTouch* rep = new internal::ImageRepCocoaTouch(image);
+    AddRepresentation(rep);
+  }
+}
+#elif defined(OS_MACOSX)
 Image::Image(NSImage* image) {
   if (image) {
     storage_ = new internal::ImageStorage(Image::kImageRepCocoa);
     internal::ImageRepCocoa* rep = new internal::ImageRepCocoa(image);
     AddRepresentation(rep);
   }
 }
 #endif
 
 Image::Image(const Image& other) : storage_(other.storage_) {
@@ skipping 12 matching lines @@
   if (!rep) {
     internal::ImageRepPNG* png_rep = new internal::ImageRepPNG();
     switch (DefaultRepresentationType()) {
 #if defined(TOOLKIT_GTK)
       case kImageRepGdk: {
         internal::ImageRepGdk* gdk_rep =
             GetRepresentation(kImageRepGdk, true)->AsImageRepGdk();
         internal::PNGFromGdkPixbuf(gdk_rep->pixbuf(), png_rep->image());
         break;
       }
+#elif defined(OS_IOS)
+      case kImageRepCocoaTouch: {
+        internal::ImageRepCocoaTouch* cocoa_touch_rep =
+            GetRepresentation(kImageRepCocoaTouch, true)
+                ->AsImageRepCocoaTouch();
+        internal::PNGFromUIImage(cocoa_touch_rep->image(), png_rep->image());
+        break;
+      }
 #elif defined(OS_MACOSX)
       case kImageRepCocoa: {
         internal::ImageRepCocoa* cocoa_rep =
             GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
         internal::PNGFromNSImage(cocoa_rep->image(), png_rep->image());
         break;
       }
 #endif
       case kImageRepSkia: {
         internal::ImageRepSkia* skia_rep =
@@ skipping 28 matching lines @@
         break;
       }
 #if defined(TOOLKIT_GTK)
       case kImageRepGdk: {
         internal::ImageRepGdk* native_rep =
             GetRepresentation(kImageRepGdk, true)->AsImageRepGdk();
         rep = new internal::ImageRepSkia(new ImageSkia(
             internal::ImageSkiaFromGdkPixbuf(native_rep->pixbuf())));
         break;
       }
+#elif defined(OS_IOS)
+      case kImageRepCocoaTouch: {
+        internal::ImageRepCocoaTouch* native_rep =
+            GetRepresentation(kImageRepCocoaTouch, true)
+                ->AsImageRepCocoaTouch();
+        rep = new internal::ImageRepSkia(new ImageSkia(
+            ImageSkiaFromUIImage(native_rep->image())));
+        break;
+      }
 #elif defined(OS_MACOSX)
       case kImageRepCocoa: {
         internal::ImageRepCocoa* native_rep =
             GetRepresentation(kImageRepCocoa, true)->AsImageRepCocoa();
         rep = new internal::ImageRepSkia(new ImageSkia(
             ImageSkiaFromNSImage(native_rep->image())));
         break;
       }
 #endif
       default:
@@ skipping 39 matching lines @@
     // Handle any-to-Cairo conversion. This may create and cache an intermediate
     // pixbuf before sending the data to the display server.
     rep = new internal::ImageRepCairo(ToGdkPixbuf());
     CHECK(rep);
     AddRepresentation(rep);
   }
   return rep->AsImageRepCairo()->surface();
 }
 #endif
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+UIImage* Image::ToUIImage() const {
+  internal::ImageRep* rep = GetRepresentation(kImageRepCocoaTouch, false);
+  if (!rep) {
+    switch (DefaultRepresentationType()) {
+      case kImageRepPNG: {
+        internal::ImageRepPNG* png_rep =
+            GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
+        rep = new internal::ImageRepCocoaTouch(internal::CreateUIImageFromPNG(
+            *png_rep->image()));
+        break;
+      }
+      case kImageRepSkia: {
+        internal::ImageRepSkia* skia_rep =
+            GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
+        UIImage* image = UIImageFromImageSkia(*skia_rep->image());
+        base::mac::NSObjectRetain(image);
+        rep = new internal::ImageRepCocoaTouch(image);
+        break;
+      }
+      default:
+        NOTREACHED();
+    }
+    CHECK(rep);
+    AddRepresentation(rep);
+  }
+  return rep->AsImageRepCocoaTouch()->image();
+}
+#elif defined(OS_MACOSX)
 NSImage* Image::ToNSImage() const {
   internal::ImageRep* rep = GetRepresentation(kImageRepCocoa, false);
   if (!rep) {
     switch (DefaultRepresentationType()) {
       case kImageRepPNG: {
         internal::ImageRepPNG* png_rep =
             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
         rep = new internal::ImageRepCocoa(internal::NSImageFromPNG(
             *png_rep->image()));
         break;
@@ skipping 21 matching lines @@
 }
 
 SkBitmap Image::AsBitmap() const {
   return IsEmpty() ? SkBitmap() : *ToSkBitmap();
 }
 
 ImageSkia Image::AsImageSkia() const {
   return IsEmpty() ? ImageSkia() : *ToImageSkia();
 }
 
-#if defined(OS_MACOSX)
+#if defined(OS_MACOSX) && !defined(OS_IOS)
 NSImage* Image::AsNSImage() const {
   return IsEmpty() ? nil : ToNSImage();
 }
 #endif
 
 ImageSkia* Image::CopyImageSkia() const {
   return new ImageSkia(*ToImageSkia());
 }
 
 SkBitmap* Image::CopySkBitmap() const {
   return new SkBitmap(*ToSkBitmap());
 }
 
 #if defined(TOOLKIT_GTK)
 GdkPixbuf* Image::CopyGdkPixbuf() const {
   GdkPixbuf* pixbuf = ToGdkPixbuf();
   g_object_ref(pixbuf);
   return pixbuf;
 }
 #endif
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+UIImage* Image::CopyUIImage() const {
+  UIImage* image = ToUIImage();
+  base::mac::NSObjectRetain(image);
+  return image;
+}
+#elif defined(OS_MACOSX)
 NSImage* Image::CopyNSImage() const {
   NSImage* image = ToNSImage();
   base::mac::NSObjectRetain(image);
   return image;
 }
 #endif
 
-#if defined(OS_MACOSX)
+#if defined(OS_IOS)
+Image::operator UIImage*() const {
+  return ToUIImage();
+}
+#elif defined(OS_MACOSX)
 Image::operator NSImage*() const {
   return ToNSImage();
 }
 #endif
 
 bool Image::HasRepresentation(RepresentationType type) const {
   return storage_.get() && storage_->representations().count(type) != 0;
 }
 
 size_t Image::RepresentationCount() const {
@@ skipping 30 matching lines @@
   }
   return it->second;
 }
 
 void Image::AddRepresentation(internal::ImageRep* rep) const {
   CHECK(storage_.get());
   storage_->representations().insert(std::make_pair(rep->type(), rep));
 }
 
 }  // namespace gfx