Add support for multi resolution icons

ui/base/resource/resource_bundle.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/base/resource/resource_bundle.h"
 
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/codec/tiff_codec.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image.h"
 
 namespace ui {
 
 namespace {
 
 // Font sizes relative to base font.
 #if defined(OS_CHROMEOS) && defined(CROS_FONTS_USING_BCI)
 const int kSmallFontSizeDelta = -3;
@@ skipping 76 matching lines @@
   CHECK(g_shared_instance_ != NULL);
   return *g_shared_instance_;
 }
 
 SkBitmap* ResourceBundle::GetBitmapNamed(int resource_id) {
   const SkBitmap* bitmap =
       static_cast<const SkBitmap*>(GetImageNamed(resource_id));
   return const_cast<SkBitmap*>(bitmap);
 }
 
+bool ResourceBundle::GetBitmapsNamed(int resource_id,
+                                     std::vector<SkBitmap*>& bitmaps) {
+  std::vector<gfx::Image*> images;
+  if (!GetImagesNamed(resource_id, images))
+    return false;
+
+  for (std::vector<gfx::Image*>::iterator it = images.begin();
+       it != images.end(); ++it) {
+    const SkBitmap* bitmap = static_cast<const SkBitmap*>(**it);
+    bitmaps.push_back(const_cast<SkBitmap*>(bitmap));
+  }
+  return true;
+}
+
 gfx::Image& ResourceBundle::GetImageNamed(int resource_id) {
-  // Check to see if the image is already in the cache.
-  {
-    base::AutoLock lock_scope(*lock_);
-    ImageMap::const_iterator found = images_.find(resource_id);
-    if (found != images_.end())
-      return *found->second;
-  }
-
-  scoped_ptr<SkBitmap> bitmap(LoadBitmap(resources_data_, resource_id));
-  if (bitmap.get()) {
-    // The load was successful, so cache the image.
-    base::AutoLock lock_scope(*lock_);
-
-    // Another thread raced the load and has already cached the image.
-    if (images_.count(resource_id))
-      return *images_[resource_id];
-
-    gfx::Image* image = new gfx::Image(bitmap.release());
-    images_[resource_id] = image;
-    return *image;
+  std::vector<gfx::Image*> images;
+  if (GetImagesNamed(resource_id, images)) {
+    if (!images.empty())
+      return **images.begin();
   }
 
   // The load failed to retrieve the image; show a debugging red square.
-  LOG(WARNING) << "Unable to load image with id " << resource_id;
-  NOTREACHED();  // Want to assert in debug mode.
+  NOTREACHED();
   return *GetEmptyImage();
 }
 
+bool ResourceBundle::GetImagesNamed(int resource_id,
+                                    std::vector<gfx::Image*>& images) {
+  // Check to see if the image is already in the cache.
+  if (GetImagesFromCacheNamed(resource_id, images)) {
+    return true;
+  }
+
+  std::vector<SkBitmap> bitmaps;
+  if (LoadBitmaps(resources_data_, resource_id, bitmaps)) {
+    // The load was successful, so cache the images.
+    {
+      base::AutoLock lock_scope(*lock_);
+
+      // Has another thread raced the load and has already cached the image?
+      if (!images_.count(resource_id)) {
+        std::vector<gfx::Image*>* images_ptr = new std::vector<gfx::Image*>;
+        for (std::vector<SkBitmap>::iterator it = bitmaps.begin();
+             it != bitmaps.end(); ++it) {
+          SkBitmap* bitmap = new SkBitmap(*it);
+          gfx::Image* image = new gfx::Image(bitmap);
+          images_ptr->push_back(image);
+          images_[resource_id] = images_ptr;
+        }
+      }
+    }
+    return GetImagesFromCacheNamed(resource_id, images);
+  }
+
+  // The load failed to retrieve the image.
+  LOG(WARNING) << "Unable to load image with id " << resource_id;
+  NOTREACHED();  // Want to assert in debug mode.
+  return false;
+}
+
+bool ResourceBundle::GetImagesFromCacheNamed(int resource_id,
+                                             std::vector<gfx::Image*>& images) {
+  base::AutoLock lock_scope(*lock_);
+
+  ImageMap::const_iterator found = images_.find(resource_id);
+  if (found == images_.end())
+    return false;
+
+  std::vector<gfx::Image*>* found_images = found->second;
+  for (std::vector<gfx::Image*>::const_iterator it = found_images->begin();
+       it != found_images->end(); ++it) {
+    images.push_back(*it);
+  }
+  return true;
+}
+
 #if !defined(OS_MACOSX) && !defined(OS_LINUX)
 // Only Mac and Linux have non-Skia native image types. All other platforms use
 // Skia natively, so just use GetImageNamed().
 gfx::Image& ResourceBundle::GetNativeImageNamed(int resource_id) {
   return GetImageNamed(resource_id);
 }
 #endif
 
 RefCountedStaticMemory* ResourceBundle::LoadDataResourceBytes(
     int resource_id) const {
@@ skipping 37 matching lines @@
   LoadFontsIfNecessary();
 }
 
 ResourceBundle::ResourceBundle()
     : lock_(new base::Lock),
       resources_data_(NULL),
       locale_resources_data_(NULL) {
 }
 
 void ResourceBundle::FreeImages() {
-  STLDeleteContainerPairSecondPointers(images_.begin(),
-                                       images_.end());
-  images_.clear();
+  for (ImageMap::iterator i = images_.begin(); i != images_.end(); ++i) {
+    STLDeleteContainerPointers(i->second->begin(), i->second->end());
+  }
+  STLDeleteValues(&images_);
 }
 
 void ResourceBundle::LoadFontsIfNecessary() {
   lock_->AssertAcquired();
   if (!base_font_.get()) {
     base_font_.reset(new gfx::Font());
 
     bold_font_.reset(new gfx::Font());
     *bold_font_ =
         base_font_->DeriveFont(0, base_font_->GetStyle() | gfx::Font::BOLD);
 
     small_font_.reset(new gfx::Font());
     *small_font_ = base_font_->DeriveFont(kSmallFontSizeDelta);
 
     medium_font_.reset(new gfx::Font());
     *medium_font_ = base_font_->DeriveFont(kMediumFontSizeDelta);
 
     medium_bold_font_.reset(new gfx::Font());
     *medium_bold_font_ =
         base_font_->DeriveFont(kMediumFontSizeDelta,
                                base_font_->GetStyle() | gfx::Font::BOLD);
 
     large_font_.reset(new gfx::Font());
     *large_font_ = base_font_->DeriveFont(kLargeFontSizeDelta);
   }
 }
 
 /* static */
-SkBitmap* ResourceBundle::LoadBitmap(DataHandle data_handle, int resource_id) {
+bool ResourceBundle::LoadBitmaps(DataHandle data_handle, int resource_id,
+                                 std::vector<SkBitmap>& bitmaps) {
   scoped_refptr<RefCountedMemory> memory(
       LoadResourceBytes(data_handle, resource_id));
   if (!memory)
-    return NULL;
+    return false;
 
   SkBitmap bitmap;
-  if (!gfx::PNGCodec::Decode(memory->front(), memory->size(), &bitmap)) {
-    NOTREACHED() << "Unable to decode theme image resource " << resource_id;
-    return NULL;
+  if (gfx::PNGCodec::Decode(memory->front(), memory->size(), &bitmap)) {
+    bitmaps.push_back(bitmap);
+    return true;
   }
 
-  return new SkBitmap(bitmap);
+  if (gfx::TIFFCodec::Decode(memory->front(), memory->size(), bitmaps)) {
+    return true;
+  }
+
+  NOTREACHED() << "Unable to decode theme image resource " << resource_id;
+  return false;
 }
 
 gfx::Image* ResourceBundle::GetEmptyImage() {
   base::AutoLock lock(*lock_);
 
   static gfx::Image* empty_image = NULL;
   if (!empty_image) {
     // The placeholder bitmap is bright red so people notice the problem.
     // This bitmap will be leaked, but this code should never be hit.
     SkBitmap* bitmap = new SkBitmap();
@@ skipping 29 matching lines @@
     int resource_id, base::StringPiece* data) const {
   return data_pack_->GetStringPiece(static_cast<uint32>(resource_id), data);
 }
 
 RefCountedStaticMemory* ResourceBundle::LoadedDataPack::GetStaticMemory(
     int resource_id) const {
   return data_pack_->GetStaticMemory(resource_id);
 }
 
 }  // namespace ui