Unix ifdefs patch for ui/ and webkit/

ui/gfx/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.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
-#if defined(OS_LINUX)
+#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"
 #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(OS_LINUX)
+#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;
@@ skipping 11 matching lines @@
 
   // 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(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
   ImageRepGdk* AsImageRepGdk() {
     CHECK_EQ(type_, Image::kImageRepGdk);
     return reinterpret_cast<ImageRepGdk*>(this);
   }
 #endif
 
 #if defined(OS_MACOSX)
   ImageRepCocoa* AsImageRepCocoa() {
     CHECK_EQ(type_, Image::kImageRepCocoa);
     return reinterpret_cast<ImageRepCocoa*>(this);
@@ skipping 27 matching lines @@
   const SkBitmap* bitmap() const { return bitmaps_[0]; }
 
   const std::vector<const SkBitmap*>& bitmaps() const { return bitmaps_; }
 
  private:
   std::vector<const SkBitmap*> bitmaps_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageRepSkia);
 };
 
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
 class ImageRepGdk : public ImageRep {
  public:
   explicit ImageRepGdk(GdkPixbuf* pixbuf)
       : ImageRep(Image::kImageRepGdk),
         pixbuf_(pixbuf) {
     CHECK(pixbuf);
   }
 
   virtual ~ImageRepGdk() {
     if (pixbuf_) {
@@ skipping 76 matching lines @@
   internal::ImageRepSkia* rep = new internal::ImageRepSkia(bitmap);
   AddRepresentation(rep);
 }
 
 Image::Image(const std::vector<const SkBitmap*>& bitmaps)
     : storage_(new internal::ImageStorage(Image::kImageRepSkia)) {
   internal::ImageRepSkia* rep = new internal::ImageRepSkia(bitmaps);
   AddRepresentation(rep);
 }
 
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
 Image::Image(GdkPixbuf* pixbuf)
     : storage_(new internal::ImageStorage(Image::kImageRepGdk)) {
   internal::ImageRepGdk* rep = new internal::ImageRepGdk(pixbuf);
   AddRepresentation(rep);
 }
 #endif
 
 #if defined(OS_MACOSX)
 Image::Image(NSImage* image)
     : storage_(new internal::ImageStorage(Image::kImageRepCocoa)) {
@@ skipping 15 matching lines @@
 
 Image::operator const SkBitmap*() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepSkia);
   return rep->AsImageRepSkia()->bitmap();
 }
 
 Image::operator const SkBitmap&() const {
   return *(this->operator const SkBitmap*());
 }
 
-#if defined(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
 Image::operator GdkPixbuf*() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepGdk);
   return rep->AsImageRepGdk()->pixbuf();
 }
 #endif
 
 #if defined(OS_MACOSX)
 Image::operator NSImage*() const {
   internal::ImageRep* rep = GetRepresentation(Image::kImageRepCocoa);
   return rep->AsImageRepCocoa()->image();
@@ skipping 31 matching lines @@
   RepresentationMap::iterator it = storage_->representations().find(rep_type);
   if (it != storage_->representations().end())
     return it->second;
 
   // At this point, the requested rep does not exist, so it must be converted
   // from the default rep.
 
   // Handle native-to-Skia conversion.
   if (rep_type == Image::kImageRepSkia) {
     internal::ImageRepSkia* rep = NULL;
-#if defined(OS_LINUX)
+#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()));
     }
 #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(OS_LINUX)
+#if defined(TOOLKIT_USES_GTK)
     if (rep_type == Image::kImageRepGdk) {
       GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(skia_rep->bitmap());
       native_rep = new internal::ImageRepGdk(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);
     }
@@ skipping 15 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