Add support for multi resolution icons

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 87 matching lines @@
 
   // 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);
+  bool GetBitmapsNamed(int resource_id, std::vector<SkBitmap*>& bitmaps);
 
   // 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);
 
+  // Gets images for the given |resource_id|. This can be used for icons
+  // rendered at multiple resolutions.
+  bool GetImagesNamed(int resource_id, std::vector<gfx::Image*>& images);
+
   // 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.
   //
   // Note that if the same resource has already been loaded in GetImageNamed(),
   // gfx::Image will perform a conversion, rather than using the native image
   // loading code of ResourceBundle.
   gfx::Image& GetNativeImageNamed(int resource_id);
 
   // Loads the raw bytes of a data resource into |bytes|,
@@ skipping 98 matching lines @@
   // Load test resources in given path.
   void LoadTestResources(const FilePath& path);
 
   // Unload the locale specific strings and prepares to load new ones. See
   // comments for ReloadSharedInstance().
   void UnloadLocaleResources();
 
   // Initialize all the gfx::Font members if they haven't yet been initialized.
   void LoadFontsIfNecessary();
 
+  // Gets images from the cache.
+  bool GetImagesFromCacheNamed(int resource_id,
+                               std::vector<gfx::Image*>& images);
+
 #if defined(USE_BASE_DATA_PACK)
   // Returns the full pathname of the main resources file to load.  May return
   // an empty string if no main resources data files are found.
   static FilePath GetResourcesFilePath();
 #endif
 
   // Returns the full pathname of the locale file to load.  May return an empty
   // string if no locale data files are found.
   static FilePath GetLocaleFilePath(const std::string& app_locale);
 
   // Returns a handle to bytes from the resource |module|, without doing any
   // processing or interpretation of the resource. Returns whether we
   // 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);
+  // Creates and returns SkBitmaps given the data file to look in and the
+  // resource id.
+  static bool LoadBitmaps(DataHandle dll_inst, int resource_id,
+                          std::vector<SkBitmap>& bitmaps);
 
   // 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., 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 images and keeps
   // ownership of the pointers.
-  typedef std::map<int, gfx::Image*> ImageMap;
+  typedef std::map<int, std::vector<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_