Integrate gfx::Image into the ResourceBundle.

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/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;
 const int kMediumFontSizeDelta = 2;
 const int kLargeFontSizeDelta = 7;
@@ skipping 61 matching lines @@
 }
 
 /* static */
 ResourceBundle& ResourceBundle::GetSharedInstance() {
   // Must call InitSharedInstance before this function.
   CHECK(g_shared_instance_ != NULL);
   return *g_shared_instance_;
 }
 
 SkBitmap* ResourceBundle::GetBitmapNamed(int resource_id) {
-  // Check to see if we already have the Skia image in the cache.
+  const SkBitmap* bitmap =
+      static_cast<const SkBitmap*>(GetImageNamed(resource_id));
+  return const_cast<SkBitmap*>(bitmap);
+}
+
+gfx::Image& ResourceBundle::GetImageNamed(int resource_id) {
+  // Check to see if the image is already in the cache.
   {
     base::AutoLock lock_scope(*lock_);
-    SkImageMap::const_iterator found = skia_images_.find(resource_id);
-    if (found != skia_images_.end())
-      return found->second;
+    ImageMap::const_iterator found = images_.find(resource_id);
+    if (found != images_.end())
+      return *found->second;
   }
 
-  scoped_ptr<SkBitmap> bitmap;
-
-  bitmap.reset(LoadBitmap(resources_data_, resource_id));
-
+  scoped_ptr<SkBitmap> bitmap(LoadBitmap(resources_data_, resource_id));
   if (bitmap.get()) {
-    // We loaded successfully.  Cache the Skia version of the bitmap.
+    // The load was successful, so cache the image.
     base::AutoLock lock_scope(*lock_);
 
-    // Another thread raced us, and has already cached the skia image.
-    if (skia_images_.count(resource_id))
-      return skia_images_[resource_id];
+    // Another thread raced the load and has already cached the image.
+    if (images_.count(resource_id))
+      return *images_[resource_id];
 
-    skia_images_[resource_id] = bitmap.get();
-    return bitmap.release();
+    gfx::Image* image = new gfx::Image(bitmap.release());
+    images_[resource_id] = image;
+    return *image;
   }
 
-  // We failed to retrieve the bitmap, show a debugging red square.
-  {
-    LOG(WARNING) << "Unable to load bitmap with id " << resource_id;
-    NOTREACHED();  // Want to assert in debug mode.
+  // 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.
+  return *GetEmptyImage();
+}
 
-    base::AutoLock lock_scope(*lock_);  // Guard empty_bitmap initialization.
-
-    static SkBitmap* empty_bitmap = NULL;
-    if (!empty_bitmap) {
-      // The placeholder bitmap is bright red so people notice the problem.
-      // This bitmap will be leaked, but this code should never be hit.
-      empty_bitmap = new SkBitmap();
-      empty_bitmap->setConfig(SkBitmap::kARGB_8888_Config, 32, 32);
-      empty_bitmap->allocPixels();
-      empty_bitmap->eraseARGB(255, 255, 0, 0);
-    }
-    return empty_bitmap;
-  }
+#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 {
   RefCountedStaticMemory* bytes =
       LoadResourceBytes(resources_data_, resource_id);
 
   // Check all our additional data packs for the resources if it wasn't loaded
   // from our main source.
   for (std::vector<LoadedDataPack*>::const_iterator it = data_packs_.begin();
        !bytes && it != data_packs_.end(); ++it) {
@@ skipping 14 matching lines @@
       return *medium_font_;
     case MediumBoldFont:
       return *medium_bold_font_;
     case LargeFont:
       return *large_font_;
     default:
       return *base_font_;
   }
 }
 
-gfx::NativeImage ResourceBundle::GetNativeImageNamed(int resource_id) {
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-#if defined(OS_MACOSX)
-  return rb.GetNSImageNamed(resource_id);
-#elif defined(USE_X11) && !defined(TOOLKIT_VIEWS)
-  return rb.GetPixbufNamed(resource_id);
-#else
-  return rb.GetBitmapNamed(resource_id);
-#endif
-}
-
 ResourceBundle::ResourceBundle()
     : lock_(new base::Lock),
       resources_data_(NULL),
       locale_resources_data_(NULL) {
 }
 
 void ResourceBundle::FreeImages() {
-  STLDeleteContainerPairSecondPointers(skia_images_.begin(),
-                                       skia_images_.end());
-  skia_images_.clear();
+  STLDeleteContainerPairSecondPointers(images_.begin(),
+                                       images_.end());
+  images_.clear();
 }
 
 void ResourceBundle::LoadFontsIfNecessary() {
   base::AutoLock lock_scope(*lock_);
   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);
@@ skipping 23 matching lines @@
 
   SkBitmap bitmap;
   if (!gfx::PNGCodec::Decode(memory->front(), memory->size(), &bitmap)) {
     NOTREACHED() << "Unable to decode theme image resource " << resource_id;
     return NULL;
   }
 
   return new SkBitmap(bitmap);
 }
 
+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();
+    bitmap->setConfig(SkBitmap::kARGB_8888_Config, 32, 32);
+    bitmap->allocPixels();
+    bitmap->eraseARGB(255, 255, 0, 0);
+    empty_image = new gfx::Image(bitmap);
+  }
+  return empty_image;
+}
 
 // LoadedDataPack -------------------------------------------------------------
 
 ResourceBundle::LoadedDataPack::LoadedDataPack(const FilePath& path)
     : path_(path) {
   // Always preload the data packs so we can maintain constness.
   Load();
 }
 
 ResourceBundle::LoadedDataPack::~LoadedDataPack() {
@@ skipping 12 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