Add flag which shows missing 2x resources

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/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
 
+// 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.HasBitmapForScale(2.0f)) {
+    float bitmap_scale;
+    SkBitmap bitmap = image.GetBitmapForScale(2.0f, &bitmap_scale);
+
+    if (bitmap_scale == 1.0f)
+      LOG(INFO) << "Missing 2x resource with id " << idr;
+    else
+      LOG(INFO) << "Incorrectly sized 2x resource with id " << idr;
+
+    SkBitmap bitmap2x = skia::ImageOperations::Resize(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.AddBitmapForScale(result, 2.0f);
+  }
+}
+
 }  // namespace
 
 ResourceBundle* ResourceBundle::g_shared_instance_ = NULL;
 
 // 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);
 
@@ skipping 196 matching lines @@
       }
     }
 
     if (image_skia.empty()) {
       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);
+
     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 221 matching lines @@
     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