Integrate gfx::Image into the ResourceBundle.

ui/base/resource/resource_bundle.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.
 
 #ifndef UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_
 #define UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_
 #pragma once
 
 #include "build/build_config.h"
 
@@ skipping 15 matching lines @@
 class SkBitmap;
 typedef uint32 SkColor;
 
 namespace base {
 class Lock;
 class StringPiece;
 }
 
 namespace gfx {
 class Font;
+class Image;
 }
 
 #if defined(OS_MACOSX)
 #ifdef __OBJC__
 @class NSImage;
 #else
 class NSImage;
 #endif  // __OBJC__
 #endif  // defined(OS_MACOSX)
 
@@ skipping 45 matching lines @@
 
   // Delete the ResourceBundle for this process if it exists.
   static void CleanupSharedInstance();
 
   // Return the global resource loader instance.
   static ResourceBundle& GetSharedInstance();
 
   // Gets the bitmap with the specified resource_id from the current module
   // data. Returns a pointer to a shared instance of the SkBitmap. This shared
   // bitmap is owned by the resource bundle and should not be freed.
+  //
+  // !! THIS IS DEPRECATED. PLEASE USE THE METHOD BELOW. !!
   SkBitmap* GetBitmapNamed(int resource_id);
 
+  // Gets an image resource from the current module data. This will load the
+  // image in Skia format by default. The ResourceBundle owns this.
+  gfx::Image& GetImageNamed(int resource_id);
+
+  // Similar to GetImageNamed, but rather than loading the image in Skia format,
+  // it will load in the native platform type. This can avoid conversion from
+  // one image type to another. ResourceBundle owns the result.

[TVL, 2011/02/18 21:19:12]

so this isn't completely true.  It might not go through a skia format, but if
the image was already loaded in skia format, then it does do the convert.

[Robert Sesek, 2011/02/18 21:48:17]

Added a comment.

+  gfx::Image& GetNativeImageNamed(int resource_id);
+
   // Loads the raw bytes of a data resource into |bytes|,
   // without doing any processing or interpretation of
   // the resource. Returns whether we successfully read the resource.
   RefCountedStaticMemory* LoadDataResourceBytes(int resource_id) const;
 
   // Return the contents of a resource in a StringPiece given the resource id.
   base::StringPiece GetRawDataResource(int resource_id) const;
 
   // Get a localized string given a message id.  Returns an empty
   // string if the message_id is not found.
   string16 GetLocalizedString(int message_id);
 
   // Returns the font for the specified style.
   const gfx::Font& GetFont(FontStyle style);
 
-  // Returns the gfx::NativeImage, the native platform type, named resource.
-  // Internally, this makes use of GetNSImageNamed(), GetPixbufNamed(), or
-  // GetBitmapNamed() depending on the platform (see gfx/native_widget_types.h).
-  // NOTE: On Mac the returned resource is autoreleased.
-  gfx::NativeImage GetNativeImageNamed(int resource_id);
-
 #if defined(OS_WIN)
   // Loads and returns an icon from the app module.
   HICON LoadThemeIcon(int icon_id);
 
   // Loads and returns a cursor from the app module.
   HCURSOR LoadCursor(int cursor_id);
-#elif defined(OS_MACOSX)
- private:
-  // Wrapper for GetBitmapNamed. Converts the bitmap to an autoreleased NSImage.
-  // TODO(rsesek): Move implementation into GetNativeImageNamed().
-  NSImage* GetNSImageNamed(int resource_id);
- public:
 #elif defined(USE_X11)
   // Gets the GdkPixbuf with the specified resource_id from the main data pak
   // file. Returns a pointer to a shared instance of the GdkPixbuf.  This
   // shared GdkPixbuf is owned by the resource bundle and should not be freed.
   //
   // The bitmap is assumed to exist. This function will log in release, and
   // assert in debug mode if it does not. On failure, this will return a
   // pointer to a shared empty placeholder bitmap so it will be visible what
   // is missing.
   GdkPixbuf* GetPixbufNamed(int resource_id);
 
   // As above, but flips it in RTL locales.
   GdkPixbuf* GetRTLEnabledPixbufNamed(int resource_id);
 
  private:
   // Shared implementation for the above two functions.
-  GdkPixbuf* GetPixbufImpl(int resource_id, bool rtl_enabled);
+  gfx::Image* GetPixbufImpl(int resource_id, bool rtl_enabled);
 
  public:
 #endif
 
   // TODO(glen): Move these into theme provider (dialogs still depend on
   //    ResourceBundle).
   static const SkColor frame_color;
   static const SkColor frame_color_inactive;
   static const SkColor frame_color_app_panel;
   static const SkColor frame_color_app_panel_inactive;
@@ skipping 30 matching lines @@
   typedef DataPack* DataHandle;
 #endif
 
   // Ctor/dtor are private, since we're a singleton.
   ResourceBundle();
   ~ResourceBundle();
 
   // Free skia_images_.
   void FreeImages();
 
-#if defined(USE_X11)
-  // Free gdkPixbufs_.
-  void FreeGdkPixBufs();
-#endif
-
   // Load the main resources.
   void LoadCommonResources();
 
   // Try to load the locale specific strings from an external data module.
   // Returns the locale that is loaded.
   std::string LoadLocaleResources(const std::string& pref_locale);
 
   // Unload the locale specific strings and prepares to load new ones. See
   // comments for ReloadSharedInstance().
   void UnloadLocaleResources();
@@ skipping 16 matching lines @@
   // successfully read the resource.  Caller does not own the data returned
   // through this method and must not modify the data pointed to by |bytes|.
   static RefCountedStaticMemory* LoadResourceBytes(DataHandle module,
                                                    int resource_id);
 
   // Creates and returns a new SkBitmap given the data file to look in and the
   // resource id.  It's up to the caller to free the returned bitmap when
   // done.
   static SkBitmap* LoadBitmap(DataHandle dll_inst, int resource_id);
 
+  // Returns an empty image for when a resource cannot be loaded. This is a
+  // bright red bitmap.
+  gfx::Image* GetEmptyImage();
+
   // Class level lock.  Used to protect internal data structures that may be
-  // accessed from other threads (e.g., skia_images_).
+  // accessed from other threads (e.g., images_).
   scoped_ptr<base::Lock> lock_;
 
   // Handles for data sources.
   DataHandle resources_data_;
   DataHandle locale_resources_data_;
 
   // References to extra data packs loaded via AddDataPackToSharedInstance.
   std::vector<LoadedDataPack*> data_packs_;
 
-  // Cached images. The ResourceBundle caches all retrieved bitmaps and keeps
+  // Cached images. The ResourceBundle caches all retrieved images and keeps
   // ownership of the pointers.
-  typedef std::map<int, SkBitmap*> SkImageMap;
-  SkImageMap skia_images_;
-#if defined(USE_X11)
-  typedef std::map<int, GdkPixbuf*> GdkPixbufMap;
-  GdkPixbufMap gdk_pixbufs_;
-#endif
+  typedef std::map<int, gfx::Image*> ImageMap;
+  ImageMap images_;
 
   // The various fonts used. Cached to avoid repeated GDI creation/destruction.
   scoped_ptr<gfx::Font> base_font_;
   scoped_ptr<gfx::Font> bold_font_;
   scoped_ptr<gfx::Font> small_font_;
   scoped_ptr<gfx::Font> medium_font_;
   scoped_ptr<gfx::Font> medium_bold_font_;
   scoped_ptr<gfx::Font> large_font_;
   scoped_ptr<gfx::Font> web_font_;
 
   static ResourceBundle* g_shared_instance_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceBundle);
 };
 
 }  // namespace ui
 
 // TODO(beng): Someday, maybe, get rid of this.
 using ui::ResourceBundle;
 
 #endif  // UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_