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

ui/gfx/image/image.h

 // 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.
 
 // An Image wraps an image any flavor, be it platform-native GdkBitmap/NSImage,
 // or a SkBitmap. This also provides easy conversion to other image types
 // through operator overloading. It will cache the converted representations
 // internally to prevent double-conversion.
 //
 // The lifetime of both the initial representation and any converted ones are
@@ skipping 17 matching lines @@
 
 class SkBitmap;
 
 namespace {
 class ImageTest;
 class ImageMacTest;
 }
 
 namespace gfx {
 
+#if defined(TOOLKIT_USES_GTK)
+class CairoCachedSurface;
+#endif
+
 namespace internal {
 class ImageRep;
 class ImageStorage;
 }
 
 class UI_EXPORT Image {
  public:
   enum RepresentationType {
     kImageRepGdk,
     kImageRepCocoa,
     kImageRepSkia,
+    kImageRepCairoCache
   };
 
   typedef std::map<RepresentationType, internal::ImageRep*> RepresentationMap;
 
   // Creates a new image with the default representation. The object will take
   // ownership of the image.
   explicit Image(const SkBitmap* bitmap);
 
   // To create an Image that supports multiple resolutions pass a vector
   // of bitmaps, one for each resolution.
@@ skipping 18 matching lines @@
   // Deletes the image and, if the only owner of the storage, all of its cached
   // representations.
   ~Image();
 
   // Converts the Image to the desired representation and stores it internally.
   // The returned result is a weak pointer owned by and scoped to the life of
   // the Image.
   const SkBitmap* ToSkBitmap() const;
 #if defined(TOOLKIT_USES_GTK)
   GdkPixbuf* ToGdkPixbuf() const;
+  CairoCachedSurface* const ToCairo() const;
 #elif defined(OS_MACOSX)
   NSImage* ToNSImage() const;
 #endif
 
   // Performs a conversion, like above, but returns a copy of the result rather
   // than a weak pointer. The caller is responsible for deleting the result.
   // Note that the result is only a copy in terms of memory management; the
   // backing pixels are shared amongst all copies (a fact of each of the
   // converted representations, rather than a limitation imposed by Image) and
   // so the result should be considered immutable.
   const SkBitmap* CopySkBitmap() const;
 #if defined(TOOLKIT_USES_GTK)
   GdkPixbuf* CopyGdkPixbuf() const;

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

Are there copy semantics for CairoCachedSurface?

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

There could be (there isn't now), but I don't think it would make sense.

So you have an object that's purpose is to reference data in another process.
You can't mutate that data. You could tell the display server to duplicate the
data, but I don't see why you would.

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

Sounds fair.

 #elif defined(OS_MACOSX)
   NSImage* CopyNSImage() const;
 #endif
 
   // DEPRECATED ----------------------------------------------------------------
   // Conversion handlers. These wrap the ToType() variants.
   operator const SkBitmap*() const;
   operator const SkBitmap&() const;
 #if defined(TOOLKIT_USES_GTK)
   operator GdkPixbuf*() const;
@@ skipping 36 matching lines @@
   // be cheaply copied.
   scoped_refptr<internal::ImageStorage> storage_;
 
   friend class ::ImageTest;
   friend class ::ImageMacTest;
 };
 
 }  // namespace gfx
 
 #endif  // UI_GFX_IMAGE_IMAGE_H_