Load 2x resources on demand

ui/base/resource/resource_bundle.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_skia.h"
+#include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/skbitmap_operations.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;
 #else
 const int kSmallFontSizeDelta = -2;
 const int kMediumFontSizeDelta = 3;
 const int kLargeFontSizeDelta = 8;
 #endif
 
+ResourceBundle* g_shared_instance_ = NULL;
+
 // Returns the actual scale factor of |bitmap| given the image representations
 // which have already been added to |image|.
 // TODO(pkotwicz): Remove this once we are no longer loading 1x resources
 // as part of 2x data packs.
 ui::ScaleFactor GetActualScaleFactor(const gfx::ImageSkia& image,
                                      const SkBitmap& bitmap,
                                      ui::ScaleFactor data_pack_scale_factor) {
   if (image.empty())
     return data_pack_scale_factor;
 
   return ui::GetScaleFactorFromScale(
       static_cast<float>(bitmap.width()) / image.width());
 }
 
-// If 2x resource is missing from |image| or is the incorrect size,
-// logs the resource id and creates a 2x version of the resource.
-// Blends the created resource with red to make it distinguishable from
-// bitmaps in the resource pak.
-void Create2xResourceIfMissing(gfx::ImageSkia image, int idr) {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(
-          switches::kHighlightMissing2xResources) &&
-      command_line->HasSwitch(switches::kLoad2xResources) &&
-      !image.HasRepresentation(ui::SCALE_FACTOR_200P)) {
-    gfx::ImageSkiaRep image_rep = image.GetRepresentation(SCALE_FACTOR_200P);
-
-    if (image_rep.scale_factor() == ui::SCALE_FACTOR_100P)
-      LOG(INFO) << "Missing 2x resource with id " << idr;
-    else
-      LOG(INFO) << "Incorrectly sized 2x resource with id " << idr;
-
-    SkBitmap bitmap2x = skia::ImageOperations::Resize(image_rep.sk_bitmap(),
-        skia::ImageOperations::RESIZE_LANCZOS3,
-        image.width() * 2, image.height() * 2);
-
-    SkBitmap mask;
-    mask.setConfig(SkBitmap::kARGB_8888_Config,
-                   bitmap2x.width(),
-                   bitmap2x.height());
-    mask.allocPixels();
-    mask.eraseColor(SK_ColorRED);
-    SkBitmap result = SkBitmapOperations::CreateBlendedBitmap(bitmap2x, mask,
-                                                              0.2);
-    image.AddRepresentation(gfx::ImageSkiaRep(result, SCALE_FACTOR_200P));
-  }
+bool ShouldHighlightMissing2xResources() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kHighlightMissing2xResources);
 }
 
 }  // namespace
 
-ResourceBundle* ResourceBundle::g_shared_instance_ = NULL;
+class ResourceBundle::ResourceBundleImageSource : public gfx::ImageSkiaSource {
+ public:
+  ResourceBundleImageSource(int resource_id, const gfx::Size size_in_dip)
+      : resource_id_(resource_id),
+        size_in_dip_(size_in_dip) {
+  }
+  virtual ~ResourceBundleImageSource() {}
+
+  // gfx::ImageSkiaSource overrides:
+  virtual gfx::ImageSkiaRep GetImageForScale(ui::ScaleFactor scale_factor) {
+    ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+
+    scoped_ptr<SkBitmap> result(rb.LoadBitmap(resource_id_, scale_factor));
+    gfx::Size size_in_pixel =
+        size_in_dip_.Scale(ui::GetScaleFactorScale(scale_factor));
+
+    if (scale_factor == SCALE_FACTOR_200P &&
+        (!result.get() ||
+         result->width() != size_in_pixel.width() ||
+         result->height() != size_in_pixel.height())) {
+
+      // If 2x resource is missing from |image| or is the incorrect
+      // size and --highlight-missing-2x-resources is specified, logs
+      // the resource id and creates a 2x version of the resource.
+      // Blends the created resource with red to make it
+      // distinguishable from bitmaps in the resource pak.
+      if (ShouldHighlightMissing2xResources()) {
+        if (!result.get())
+          LOG(ERROR) << "Missing 2x resource. id=" << resource_id_;
+        else
+          LOG(ERROR) << "Incorrectly sized 2x resource. id=" << resource_id_;
+
+        SkBitmap bitmap1x = *(rb.LoadBitmap(resource_id_, SCALE_FACTOR_100P));
+        SkBitmap bitmap2x = skia::ImageOperations::Resize(
+            bitmap1x,
+            skia::ImageOperations::RESIZE_LANCZOS3,
+            bitmap1x.width() * 2, bitmap1x.height() * 2);
+
+        SkBitmap mask;
+        mask.setConfig(SkBitmap::kARGB_8888_Config,
+                       bitmap2x.width(),
+                       bitmap2x.height());
+        mask.allocPixels();
+        mask.eraseColor(SK_ColorRED);
+        result.reset(new SkBitmap());
+        *result.get() = SkBitmapOperations::CreateBlendedBitmap(bitmap2x, mask,
+                                                                0.2);
+      } else if (!result.get() ||
+                 result->width() == size_in_dip_.width()) {
+        // The 2x resource pack may have the 1x image if its grd file
+        // points to 1x image. Fallback to 1x by returning empty image
+        // in this case. This 1x image will be scaled when drawn.
+        return gfx::ImageSkiaRep();
+      }
+      // If the size of 2x image isn't exactly 2x of 1x version,
+      // create ImageSkia as usual. This will end up with
+      // corrupted visual representation as the size of image doesn't
+      // match the expected size.
+    }
+    return gfx::ImageSkiaRep(*result.get(), scale_factor);
+  }
+
+ private:
+  int resource_id_;
+  gfx::Size size_in_dip_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourceBundleImageSource);
+};
 
 // static
 std::string ResourceBundle::InitSharedInstanceWithLocale(
     const std::string& pref_locale, Delegate* delegate) {
   DCHECK(g_shared_instance_ == NULL) << "ResourceBundle initialized twice";
   g_shared_instance_ = new ResourceBundle(delegate);
 
   g_shared_instance_->LoadCommonResources();
   std::string result = g_shared_instance_->LoadLocaleResources(pref_locale);
   return result;
@@ skipping 189 matching lines @@
   const SkBitmap* bitmap = GetImageNamed(resource_id).ToSkBitmap();
   return const_cast<SkBitmap*>(bitmap);
 }
 
 gfx::ImageSkia* ResourceBundle::GetImageSkiaNamed(int resource_id) {
   const gfx::ImageSkia* image = GetImageNamed(resource_id).ToImageSkia();
   return const_cast<gfx::ImageSkia*>(image);
 }
 
 gfx::Image& ResourceBundle::GetImageNamed(int resource_id) {
   // Check to see if the image is already in the cache.

[sky, 2012/08/08 14:41:24]

I believe this code can be invoked on any thread, which implies the code you're
adding and related code needs to be thread safe. Is that right? If so, it has
pretty far reaching ramifications for ImageSkia and ImageSkiaSource.

[oshima, 2012/08/08 15:12:16]

This method is still thread safe. However, returned Image isn't thread safe, and
it's been thread unsafe before this CL because Image.GetRepresentation isn't
thread safe.
Does Image need to be thread safe? If so that's a requirement we need to address
separately.

Do you know where we're using this in non UI thread?

[bshe, 2012/08/08 17:26:12]

Not sure if related, for wallpapers, I believe we also use this function in a
WorkerPool thread. 

On 2012/08/08 15:12:16, oshima wrote:

   {
     base::AutoLock lock_scope(*images_and_fonts_lock_);
     if (images_.count(resource_id))
       return images_[resource_id];
   }
 
   gfx::Image image;
   if (delegate_)
     image = delegate_->GetImageNamed(resource_id);
 
   if (image.IsEmpty()) {
     DCHECK(!delegate_ && !data_packs_.empty()) <<
         "Missing call to SetResourcesDataDLL?";
-    gfx::ImageSkia image_skia;
-    for (size_t i = 0; i < data_packs_.size(); ++i) {
-      scoped_ptr<SkBitmap> bitmap(LoadBitmap(*data_packs_[i], resource_id));
-      if (bitmap.get()) {
-        ui::ScaleFactor scale_factor;
-        if (gfx::Screen::IsDIPEnabled()) {
-          scale_factor = GetActualScaleFactor(image_skia, *bitmap,
-              data_packs_[i]->GetScaleFactor());
-        } else {
-          scale_factor = ui::SCALE_FACTOR_100P;
-        }
-        image_skia.AddRepresentation(gfx::ImageSkiaRep(*bitmap, scale_factor));
-      }
-    }
 
-    if (image_skia.empty()) {
+    scoped_ptr<SkBitmap> bitmap(LoadBitmap(resource_id, SCALE_FACTOR_100P));
+    if (!bitmap.get()) {
       LOG(WARNING) << "Unable to load image with id " << resource_id;
       NOTREACHED();  // Want to assert in debug mode.
-      // The load failed to retrieve the image; show a debugging red square.
       return GetEmptyImage();
     }
 
-    Create2xResourceIfMissing(image_skia, resource_id);
-
+    gfx::Size size_in_dip(bitmap->width(), bitmap->height());
+    gfx::ImageSkia image_skia(
+        new ResourceBundleImageSource(resource_id, size_in_dip),
+        size_in_dip);
+    image_skia.AddRepresentation(gfx::ImageSkiaRep(*bitmap.get(),
+                                                   SCALE_FACTOR_100P));
     image = gfx::Image(image_skia);
   }
 
   // The load was successful, so cache the image.
   base::AutoLock lock_scope(*images_and_fonts_lock_);
 
   // Another thread raced the load and has already cached the image.
   if (images_.count(resource_id))
     return images_[resource_id];
 
@@ skipping 202 matching lines @@
   // 99% of our assets are PNGs, however fallback to JPEG.
   SkBitmap* allocated_bitmap =
       gfx::JPEGCodec::Decode(memory->front(), memory->size());
   if (allocated_bitmap)
     return allocated_bitmap;
 
   NOTREACHED() << "Unable to decode theme image resource " << resource_id;
   return NULL;
 }
 
+SkBitmap* ResourceBundle::LoadBitmap(int resource_id,
+                                     ScaleFactor scale_factor) {
+  for (size_t i = 0; i < data_packs_.size(); i++) {
+    if (data_packs_[i]->GetScaleFactor() == scale_factor) {
+      SkBitmap* bitmap = LoadBitmap(*data_packs_[i], resource_id);
+      if (bitmap)
+        return bitmap;
+    }
+  }
+  return NULL;
+}
+
 gfx::Image& ResourceBundle::GetEmptyImage() {
   base::AutoLock lock(*images_and_fonts_lock_);
 
   if (empty_image_.IsEmpty()) {
     // The placeholder bitmap is bright red so people notice the problem.
     SkBitmap bitmap;
     bitmap.setConfig(SkBitmap::kARGB_8888_Config, 32, 32);
     bitmap.allocPixels();
     bitmap.eraseARGB(255, 255, 0, 0);
     empty_image_ = gfx::Image(bitmap);
   }
   return empty_image_;
 }
 
 }  // namespace ui