Load extension icons for more scale factors.

extensions/browser/image_loader.cc

 // Copyright 2014 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 "extensions/browser/image_loader.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/component_extension_resource_manager.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/image_loader_factory.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "skia/ext/image_operations.h"
 #include "ui/base/layout.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/display/display.h"
+#include "ui/display/screen.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_family.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 namespace {
 
@@ skipping 92 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoader::ImageRepresentation
 
 ImageLoader::ImageRepresentation::ImageRepresentation(
     const ExtensionResource& resource,
     ResizeCondition resize_condition,
     const gfx::Size& desired_size,
-    ui::ScaleFactor scale_factor)
+    float scale_factor)
     : resource(resource),
       resize_condition(resize_condition),
       desired_size(desired_size),
-      scale_factor(scale_factor) {
-}
+      scale_factor(scale_factor) {}
 
 ImageLoader::ImageRepresentation::~ImageRepresentation() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoader::LoadResult
 
 struct ImageLoader::LoadResult  {
   LoadResult(const SkBitmap& bitmap,
              const gfx::Size& original_size,
@@ skipping 69 matching lines @@
 ImageLoader* ImageLoader::Get(content::BrowserContext* context) {
   return ImageLoaderFactory::GetForBrowserContext(context);
 }
 
 void ImageLoader::LoadImageAsync(const Extension* extension,
                                  const ExtensionResource& resource,
                                  const gfx::Size& max_size,
                                  const ImageLoaderImageCallback& callback) {
   std::vector<ImageRepresentation> info_list;
   info_list.push_back(ImageRepresentation(
-      resource,
-      ImageRepresentation::RESIZE_WHEN_LARGER,
-      max_size,
-      ui::SCALE_FACTOR_100P));
+      resource, ImageRepresentation::RESIZE_WHEN_LARGER, max_size, 1.f));
   LoadImagesAsync(extension, info_list, callback);
 }
 
 void ImageLoader::LoadImageAtEveryScaleFactorAsync(
     const Extension* extension,
     const gfx::Size& dip_size,
     const ImageLoaderImageCallback& callback) {
   std::vector<ImageRepresentation> info_list;
-  for (auto scale : ui::GetSupportedScaleFactors()) {
-    const float scale_factor = ui::GetScaleForScaleFactor(scale);
-    const gfx::Size px_size = gfx::ScaleToFlooredSize(dip_size, scale_factor);
+
+  std::set<float> scales;
+  for (auto scale : ui::GetSupportedScaleFactors())
+    scales.insert(ui::GetScaleForScaleFactor(scale));
+
+  // There may not be a screen in unit tests.
+  auto screen = display::Screen::GetScreen();
+  if (screen) {
+    for (const auto& display : screen->GetAllDisplays())
+      scales.insert(display.device_scale_factor());
+  }
+
+  for (auto scale : scales) {
+    const gfx::Size px_size = gfx::ScaleToFlooredSize(dip_size, scale);
     ExtensionResource image = IconsInfo::GetIconResource(
         extension, px_size.width(), ExtensionIconSet::MATCH_BIGGER);
     info_list.push_back(ImageRepresentation(
         image, ImageRepresentation::ALWAYS_RESIZE, px_size, scale));
   }
   LoadImagesAsync(extension, info_list, callback);
 }
 
 void ImageLoader::LoadImagesAsync(
     const Extension* extension,
@@ skipping 32 matching lines @@
                             const std::vector<LoadResult>& load_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   gfx::ImageSkia image_skia;
 
   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
        it != load_result.end(); ++it) {
     const SkBitmap& bitmap = it->bitmap;
     const ImageRepresentation& image_rep = it->image_representation;
 
-    image_skia.AddRepresentation(gfx::ImageSkiaRep(
-        bitmap,
-        ui::GetScaleForScaleFactor(image_rep.scale_factor)));
+    image_skia.AddRepresentation(
+        gfx::ImageSkiaRep(bitmap, image_rep.scale_factor));
   }
 
   gfx::Image image;
   if (!image_skia.isNull()) {
     image_skia.MakeThreadSafe();
     image = gfx::Image(image_skia);
   }
 
   callback.Run(image);
 }
 
 void ImageLoader::ReplyBackWithImageFamily(
     const ImageLoaderImageFamilyCallback& callback,
     const std::vector<LoadResult>& load_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::map<std::pair<int, int>, gfx::ImageSkia> image_skia_map;
   gfx::ImageFamily image_family;
 
   for (std::vector<LoadResult>::const_iterator it = load_result.begin();
        it != load_result.end();
        ++it) {
     const SkBitmap& bitmap = it->bitmap;
     const ImageRepresentation& image_rep = it->image_representation;
     const std::pair<int, int> key = std::make_pair(
         image_rep.desired_size.width(), image_rep.desired_size.height());
     // Create a new ImageSkia for this width/height, or add a representation to
     // an existing ImageSkia with the same width/height.
     image_skia_map[key].AddRepresentation(
-        gfx::ImageSkiaRep(bitmap,
-                          ui::GetScaleForScaleFactor(image_rep.scale_factor)));
+        gfx::ImageSkiaRep(bitmap, image_rep.scale_factor));
   }
 
   for (std::map<std::pair<int, int>, gfx::ImageSkia>::iterator it =
            image_skia_map.begin();
        it != image_skia_map.end();
        ++it) {
     it->second.MakeThreadSafe();
     image_family.Add(it->second);
   }
 
   callback.Run(image_family);
 }
 
 }  // namespace extensions