GTK: Move CairoCachedSurface from being owned by GtkThemeService to gfx::Image.

ui/gfx/image/image.cc

 // Copyright (c) 2011 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/stl_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <glib-object.h>
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/gtk_util.h"
+#include "ui/gfx/image/cairo_cached_surface.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #include "skia/ext/skia_utils_mac.h"
 #endif
 
 namespace gfx {
 
 namespace internal {
 
 #if defined(OS_MACOSX)
 // This is a wrapper around gfx::NSImageToSkBitmap() because this cross-platform
 // file cannot include the [square brackets] of ObjC.
 bool NSImageToSkBitmaps(NSImage* image, std::vector<const SkBitmap*>* bitmaps);
 #endif
 
 #if defined(TOOLKIT_USES_GTK)
 const SkBitmap* GdkPixbufToSkBitmap(GdkPixbuf* pixbuf) {
   gfx::CanvasSkia canvas(gdk_pixbuf_get_width(pixbuf),
                          gdk_pixbuf_get_height(pixbuf),
                          /*is_opaque=*/false);
   canvas.DrawGdkPixbuf(pixbuf, 0, 0);
   return new SkBitmap(canvas.ExtractBitmap());
 }
 #endif
 
 class ImageRepSkia;
 class ImageRepGdk;
+class ImageRepCairoCached;
 class ImageRepCocoa;
 
 // 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) {}
 
   // Deletes the associated pixels of an ImageRep.
   virtual ~ImageRep() {}
 
   // Cast helpers ("fake RTTI").
   ImageRepSkia* AsImageRepSkia() {
     CHECK_EQ(type_, Image::kImageRepSkia);
     return reinterpret_cast<ImageRepSkia*>(this);
   }
 
 #if defined(TOOLKIT_USES_GTK)
   ImageRepGdk* AsImageRepGdk() {
     CHECK_EQ(type_, Image::kImageRepGdk);
     return reinterpret_cast<ImageRepGdk*>(this);
   }
+
+  ImageRepCairoCached* AsImageRepCairo() {
+    CHECK_EQ(type_, Image::kImageRepCairoCache);
+    return reinterpret_cast<ImageRepCairoCached*>(this);
+  }
 #endif
 
 #if defined(OS_MACOSX)
   ImageRepCocoa* AsImageRepCocoa() {
     CHECK_EQ(type_, Image::kImageRepCocoa);
     return reinterpret_cast<ImageRepCocoa*>(this);
   }
 #endif
 
   Image::RepresentationType type() const { return type_; }
@@ skipping 46 matching lines @@
     }
   }
 
   GdkPixbuf* pixbuf() const { return pixbuf_; }
 
  private:
   GdkPixbuf* pixbuf_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepGdk);
 };
-#endif
+
+// Represents data that lives on the display server instead of in the client.
+class ImageRepCairoCached : public ImageRep {
+ public:
+  explicit ImageRepCairoCached(GdkPixbuf* pixbuf)
+      : ImageRep(Image::kImageRepCairoCache),
+        cairo_cache_(new CairoCachedSurface) {
+    CHECK(pixbuf);
+    cairo_cache_->UsePixbuf(pixbuf);
+  }
+
+  virtual ~ImageRepCairoCached() {
+    delete cairo_cache_;
+  }
+
+  CairoCachedSurface* surface() const { return cairo_cache_; }
+
+ private:
+  CairoCachedSurface* cairo_cache_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImageRepCairoCached);
+};
+#endif  // defined(TOOLKIT_USES_GTK)
 
 #if 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_);
     image_ = nil;
   }
 
   NSImage* image() const { return image_; }
 
  private:
   NSImage* image_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepCocoa);
 };
-#endif
+#endif  // defined(OS_MACOSX)
 
 // The Storage class acts similarly to the pixels in a SkBitmap: the Image
 // class holds a refptr instance of Storage, which in turn holds all the
 // ImageReps. This way, the Image can be cheaply copied.
 class ImageStorage : public base::RefCounted<ImageStorage> {
  public:
   ImageStorage(gfx::Image::RepresentationType default_type)
       : default_representation_type_(default_type) {
   }
 
@@ skipping 67 matching lines @@
 const SkBitmap* Image::ToSkBitmap() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepSkia);
   return rep->AsImageRepSkia()->bitmap();
 }
 
 #if defined(TOOLKIT_USES_GTK)
 GdkPixbuf* Image::ToGdkPixbuf() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepGdk);
   return rep->AsImageRepGdk()->pixbuf();
 }
+
+CairoCachedSurface* const Image::ToCairo() const {
+  internal::ImageRep* rep = GetRepresentation(Image::kImageRepCairoCache);
+  return rep->AsImageRepCairo()->surface();
+}
 #endif
 
 #if defined(OS_MACOSX)
 NSImage* Image::ToNSImage() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepCocoa);
   return rep->AsImageRepCocoa()->image();
 }
 #endif
 
 const SkBitmap* Image::CopySkBitmap() const {
@@ skipping 73 matching lines @@
 
   // Handle native-to-Skia conversion.
   if (rep_type == Image::kImageRepSkia) {
     internal::ImageRepSkia* rep = NULL;
 #if defined(TOOLKIT_USES_GTK)
     if (storage_->default_representation_type() == Image::kImageRepGdk) {
       internal::ImageRepGdk* pixbuf_rep = default_rep->AsImageRepGdk();
       rep = new internal::ImageRepSkia(
           internal::GdkPixbufToSkBitmap(pixbuf_rep->pixbuf()));
     }
+    // We don't do conversions from CairoCachedSurfaces to Skia because the
+    // data lives on the display server and we'll always have a GdkPixbuf if we
+    // have a CairoCachedSurface.
 #elif defined(OS_MACOSX)
     if (storage_->default_representation_type() == Image::kImageRepCocoa) {
       internal::ImageRepCocoa* nsimage_rep = default_rep->AsImageRepCocoa();
       std::vector<const SkBitmap*> bitmaps;
       CHECK(internal::NSImageToSkBitmaps(nsimage_rep->image(), &bitmaps));
       rep = new internal::ImageRepSkia(bitmaps);
     }
 #endif
     CHECK(rep);
     AddRepresentation(rep);
     return rep;
   }
+#if defined(TOOLKIT_USES_GTK)
+  else if (rep_type == Image::kImageRepCairoCache) {
+    // Handle any-to-Cairo conversion. This may recursively create an
+    // intermediate pixbuf before we send the data to the display server.
+    internal::ImageRep* rep = GetRepresentation(Image::kImageRepGdk);
+    internal::ImageRepCairoCached* native_rep =
+        new internal::ImageRepCairoCached(rep->AsImageRepGdk()->pixbuf());
+
+    CHECK(native_rep);
+    AddRepresentation(native_rep);
+    return native_rep;
+  }
+#endif
 
   // Handle Skia-to-native conversions.
   if (default_rep->type() == Image::kImageRepSkia) {
     internal::ImageRepSkia* skia_rep = default_rep->AsImageRepSkia();
     internal::ImageRep* native_rep = NULL;
 #if defined(USE_AURA)
     static_cast<void>(skia_rep);
     NOTIMPLEMENTED();
 #elif defined(TOOLKIT_USES_GTK)
     if (rep_type == Image::kImageRepGdk) {
@@ skipping 24 matching lines @@
   return GetRepresentation(Image::kImageRepSkia)->AsImageRepSkia()->
       bitmaps().size();
 }
 
 const SkBitmap* Image::GetSkBitmapAtIndex(size_t index) const {
   return GetRepresentation(Image::kImageRepSkia)->AsImageRepSkia()->
       bitmaps()[index];
 }
 
 }  // namespace gfx