Delete the GTK+ port of Chrome.

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 "base/stl_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image_png_rep.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/gfx/canvas.h"
-#include "ui/gfx/gtk_util.h"
-#include "ui/gfx/image/cairo_cached_surface.h"
-#include "ui/gfx/scoped_gobject.h"
-#elif defined(OS_IOS)
+#if 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)
-const ImageSkia ImageSkiaFromGdkPixbuf(GdkPixbuf* pixbuf) {
-  CHECK(pixbuf);
-  gfx::Canvas canvas(gfx::Size(gdk_pixbuf_get_width(pixbuf),
-                               gdk_pixbuf_get_height(pixbuf)),
-                     1.0f,
-                     false);
-  skia::ScopedPlatformPaint scoped_platform_paint(canvas.sk_canvas());
-  cairo_t* cr = scoped_platform_paint.GetPlatformSurface();
-  gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0);
-  cairo_paint(cr);
-  return ImageSkia(canvas.ExtractImageRep());
-}
-
-// Returns a 16x16 red pixbuf to visually show error in decoding PNG.
-// Also logs error to console.
-GdkPixbuf* GetErrorPixbuf() {
-  LOG(ERROR) << "Unable to decode PNG.";
-  GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, 16, 16);
-  gdk_pixbuf_fill(pixbuf, 0xff0000ff);
-  return pixbuf;
-}
-
-GdkPixbuf* GdkPixbufFromPNG(
-    const std::vector<gfx::ImagePNGRep>& image_png_reps) {
-  scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
-  for (size_t i = 0; i < image_png_reps.size(); ++i) {
-    if (image_png_reps[i].scale == 1.0f)
-      png_bytes = image_png_reps[i].raw_data;
-  }
-
-  if (!png_bytes.get())
-    return GetErrorPixbuf();
-
-  GdkPixbuf* pixbuf = NULL;
-  ui::ScopedGObject<GdkPixbufLoader>::Type loader(gdk_pixbuf_loader_new());
-
-  bool ok = gdk_pixbuf_loader_write(loader.get(),
-      reinterpret_cast<const guint8*>(png_bytes->front()), png_bytes->size(),
-      NULL);
-
-  // Calling gdk_pixbuf_loader_close forces the data to be parsed by the
-  // loader. This must be done before calling gdk_pixbuf_loader_get_pixbuf.
-  if (ok)
-    ok = gdk_pixbuf_loader_close(loader.get(), NULL);
-  if (ok)
-    pixbuf = gdk_pixbuf_loader_get_pixbuf(loader.get());
-
-  if (pixbuf) {
-    // The pixbuf is owned by the scoped loader which will delete its ref when
-    // it goes out of scope. Add a ref so that the pixbuf still exists.
-    g_object_ref(pixbuf);
-  } else {
-    return GetErrorPixbuf();
-  }
-
-  return pixbuf;
-}
-
-scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromPixbuf(
-    GdkPixbuf* pixbuf) {
-  gchar* image = NULL;
-  gsize image_size;
-  GError* error = NULL;
-  CHECK(gdk_pixbuf_save_to_buffer(
-      pixbuf, &image, &image_size, "png", &error, NULL));
-  scoped_refptr<base::RefCountedBytes> png_bytes(
-      new base::RefCountedBytes());
-  png_bytes->data().assign(image, image + image_size);
-  g_free(image);
-  return png_bytes;
-}
-
-#endif // defined(TOOLKIT_GTK)
-
 #if defined(OS_IOS)
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromUIImage(
     UIImage* uiimage);
 // Caller takes ownership of the returned UIImage.
 UIImage* CreateUIImageFromPNG(
     const std::vector<gfx::ImagePNGRep>& image_png_reps);
 gfx::Size UIImageSize(UIImage* image);
 #elif defined(OS_MACOSX)
 scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromNSImage(
     NSImage* nsimage);
@@ skipping 80 matching lines @@
   ImageRepPNG* AsImageRepPNG() {
     CHECK_EQ(type_, Image::kImageRepPNG);
     return reinterpret_cast<ImageRepPNG*>(this);
   }
 
   ImageRepSkia* AsImageRepSkia() {
     CHECK_EQ(type_, Image::kImageRepSkia);
     return reinterpret_cast<ImageRepSkia*>(this);
   }
 
-#if defined(TOOLKIT_GTK)
-  ImageRepGdk* AsImageRepGdk() {
-    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_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);
   }
@@ skipping 81 matching lines @@
   }
 
   ImageSkia* image() { return image_.get(); }
 
  private:
   scoped_ptr<ImageSkia> image_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepSkia);
 };
 
-#if defined(TOOLKIT_GTK)
-class ImageRepGdk : public ImageRep {
- public:
-  explicit ImageRepGdk(GdkPixbuf* pixbuf)
-      : ImageRep(Image::kImageRepGdk),
-        pixbuf_(pixbuf) {
-    CHECK(pixbuf);
-  }
-
-  virtual ~ImageRepGdk() {
-    if (pixbuf_) {
-      g_object_unref(pixbuf_);
-      pixbuf_ = NULL;
-    }
-  }
-
-  virtual int Width() const OVERRIDE {
-    return gdk_pixbuf_get_width(pixbuf_);
-  }
-
-  virtual int Height() const OVERRIDE {
-    return gdk_pixbuf_get_height(pixbuf_);
-  }
-
-  virtual gfx::Size Size() const OVERRIDE {
-    return gfx::Size(Width(), Height());
-  }
-
-  GdkPixbuf* pixbuf() const { return pixbuf_; }
-
- private:
-  GdkPixbuf* pixbuf_;
-
-  DISALLOW_COPY_AND_ASSIGN(ImageRepGdk);
-};
-
-// Represents data that lives on the display server instead of in the client.
-class ImageRepCairo : public ImageRep {
- public:
-  explicit ImageRepCairo(GdkPixbuf* pixbuf)
-      : ImageRep(Image::kImageRepCairo),
-        cairo_cache_(new CairoCachedSurface) {
-    CHECK(pixbuf);
-    cairo_cache_->UsePixbuf(pixbuf);
-  }
-
-  virtual ~ImageRepCairo() {
-    delete cairo_cache_;
-  }
-
-  virtual int Width() const OVERRIDE {
-    return cairo_cache_->Width();
-  }
-
-  virtual int Height() const OVERRIDE {
-    return cairo_cache_->Height();
-  }
-
-  virtual gfx::Size Size() const OVERRIDE {
-    return gfx::Size(Width(), Height());
-  }
-
-  CairoCachedSurface* surface() const { return cairo_cache_; }
-
- private:
-  CairoCachedSurface* cairo_cache_;
-
-  DISALLOW_COPY_AND_ASSIGN(ImageRepCairo);
-};
-#endif  // defined(TOOLKIT_GTK)
-
 #if defined(OS_IOS)
 class ImageRepCocoaTouch : public ImageRep {
  public:
   explicit ImageRepCocoaTouch(UIImage* image)
       : ImageRep(Image::kImageRepCocoaTouch),
         image_(image) {
     CHECK(image);
   }
 
   virtual ~ImageRepCocoaTouch() {
@@ skipping 133 matching lines @@
 
 Image::Image(const ImageSkia& image) {
   if (!image.isNull()) {
     storage_ = new internal::ImageStorage(Image::kImageRepSkia);
     internal::ImageRepSkia* rep = new internal::ImageRepSkia(
         new ImageSkia(image));
     AddRepresentation(rep);
   }
 }
 
-#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_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) {
@@ skipping 52 matching lines @@
   internal::ImageRep* rep = GetRepresentation(kImageRepSkia, false);
   if (!rep) {
     switch (DefaultRepresentationType()) {
       case kImageRepPNG: {
         internal::ImageRepPNG* png_rep =
             GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
         rep = new internal::ImageRepSkia(
             internal::ImageSkiaFromPNG(png_rep->image_reps()));
         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)
+#if 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:
         NOTREACHED();
     }
     CHECK(rep);
     AddRepresentation(rep);
   }
   return rep->AsImageRepSkia()->image();
 }
 
-#if defined(TOOLKIT_GTK)
-GdkPixbuf* Image::ToGdkPixbuf() const {
-  internal::ImageRep* rep = GetRepresentation(kImageRepGdk, false);
-  if (!rep) {
-    switch (DefaultRepresentationType()) {
-      case kImageRepPNG: {
-        internal::ImageRepPNG* png_rep =
-            GetRepresentation(kImageRepPNG, true)->AsImageRepPNG();
-        rep = new internal::ImageRepGdk(internal::GdkPixbufFromPNG(
-            png_rep->image_reps()));
-        break;
-      }
-      case kImageRepSkia: {
-        internal::ImageRepSkia* skia_rep =
-            GetRepresentation(kImageRepSkia, true)->AsImageRepSkia();
-        rep = new internal::ImageRepGdk(gfx::GdkPixbufFromSkBitmap(
-            *skia_rep->image()->bitmap()));
-        break;
-      }
-      default:
-        NOTREACHED();
-    }
-    CHECK(rep);
-    AddRepresentation(rep);
-  }
-  return rep->AsImageRepGdk()->pixbuf();
-}
-
-CairoCachedSurface* const Image::ToCairo() const {
-  internal::ImageRep* rep = GetRepresentation(kImageRepCairo, false);
-  if (!rep) {
-    // 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_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_reps()));
@@ skipping 60 matching lines @@
         rep->AsImageRepPNG()->image_reps();
     for (size_t i = 0; i < image_png_reps.size(); ++i) {
       if (image_png_reps[i].scale == 1.0f)
         return image_png_reps[i].raw_data;
     }
     return new base::RefCountedBytes();
   }
 
   scoped_refptr<base::RefCountedMemory> png_bytes(NULL);
   switch (DefaultRepresentationType()) {
-#if defined(TOOLKIT_GTK)
-    case kImageRepGdk: {
-      internal::ImageRepGdk* gdk_rep =
-          GetRepresentation(kImageRepGdk, true)->AsImageRepGdk();
-      png_bytes = internal::Get1xPNGBytesFromPixbuf(gdk_rep->pixbuf());
-      break;
-    }
-#elif defined(OS_IOS)
+#if defined(OS_IOS)
     case kImageRepCocoaTouch: {
       internal::ImageRepCocoaTouch* cocoa_touch_rep =
           GetRepresentation(kImageRepCocoaTouch, true)
               ->AsImageRepCocoaTouch();
       png_bytes = internal::Get1xPNGBytesFromUIImage(
           cocoa_touch_rep->image());
       break;
     }
 #elif defined(OS_MACOSX)
     case kImageRepCocoa: {
@@ skipping 54 matching lines @@
 }
 
 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_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);
@@ skipping 64 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