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 ImageRepCocoa;
+class ImageRepCairoCached;

[Robert Sesek, 2011/12/01 19:30:35]

nit: put below ImageRepGdk

 
 // 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);
 };
+
+// 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);
+};
+

[Robert Sesek, 2011/12/01 19:30:35]

nit: remove blank line

 #endif

[Robert Sesek, 2011/12/01 19:30:35]

  // defined(TOOLKIT_USES_GTK)

 
 #if defined(OS_MACOSX)
 class ImageRepCocoa : public ImageRep {
  public:
   explicit ImageRepCocoa(NSImage* image)
       : ImageRep(Image::kImageRepCocoa),
         image_(image) {
     CHECK(image);
   }
 
@@ skipping 90 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 72 matching lines @@
   // from the default rep.
 
   // 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()));
     }

[Robert Sesek, 2011/12/01 19:30:35]

What about going from Cairo to Skia?

[Elliot Glaysher, 2011/12/01 20:30:11]

We shouldn't allow this; it doesn't make sense. 

We'll never form a CairoCachedSurface unless we already have a GdkPixbuf (since
the cached surface takes a GdkPixbuf and sends the data to the display server
(X11, Wayland, etc)). And we already handle GdkPixbuf to Skia.

(We can actually can read data off the display server, but  removing round trips
is why I'm adding this patch.)

[Robert Sesek, 2011/12/01 20:56:14]

Can you add a comment here to that effect so that it appears deliberate?

 #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;
   }
 
   // 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) {
       GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(skia_rep->bitmap());
       native_rep = new internal::ImageRepGdk(pixbuf);
+    } else if (rep_type == Image::kImageRepCairoCache) {
+      // Send the data that we have in process right now to the display server.
+      internal::ImageRep* rep = GetRepresentation(Image::kImageRepGdk);
+      native_rep = new internal::ImageRepCairoCached(
+          rep->AsImageRepGdk()->pixbuf());
     }
 #elif defined(OS_MACOSX)
     if (rep_type == Image::kImageRepCocoa) {
       NSImage* image = gfx::SkBitmapsToNSImage(skia_rep->bitmaps());
       base::mac::NSObjectRetain(image);
       native_rep = new internal::ImageRepCocoa(image);
     }
 #endif
     CHECK(native_rep);
     AddRepresentation(native_rep);
@@ skipping 12 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