Make some updates to extension iconography.

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/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image_family.h"
 #include "ui/gfx/image/image_skia.h"
 
 using content::BrowserThread;
-using extensions::Extension;
-using extensions::ExtensionsBrowserClient;
-using extensions::ImageLoader;
-using extensions::Manifest;
+
+namespace extensions {
 
 namespace {
 
 bool ShouldResizeImageRepresentation(
     ImageLoader::ImageRepresentation::ResizeCondition resize_method,
     const gfx::Size& decoded_size,
     const gfx::Size& desired_size) {
   switch (resize_method) {
     case ImageLoader::ImageRepresentation::ALWAYS_RESIZE:
       return decoded_size != desired_size;
@@ skipping 78 matching lines @@
               extension->path(), it->resource.relative_path(), &resource_id)) {
         LoadResourceOnUIThread(resource_id, &bitmaps[i]);
       }
     }
   }
   return bitmaps;
 }
 
 }  // namespace
 
-namespace extensions {
-
 ////////////////////////////////////////////////////////////////////////////////
 // ImageLoader::ImageRepresentation
 
 ImageLoader::ImageRepresentation::ImageRepresentation(
     const ExtensionResource& resource,
     ResizeCondition resize_condition,
     const gfx::Size& desired_size,
     ui::ScaleFactor scale_factor)
     : resource(resource),
       resize_condition(resize_condition),
@@ skipping 89 matching lines @@
                                  const ImageLoaderImageCallback& callback) {
   std::vector<ImageRepresentation> info_list;
   info_list.push_back(ImageRepresentation(
       resource,
       ImageRepresentation::RESIZE_WHEN_LARGER,
       max_size,
       ui::SCALE_FACTOR_100P));
   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);
+    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,
     const std::vector<ImageRepresentation>& info_list,
     const ImageLoaderImageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(LoadImagesOnBlockingPool,
                  info_list,
                  LoadResourceBitmaps(extension, info_list)),
       base::Bind(
           &ImageLoader::ReplyBack, weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void ImageLoader::LoadImageFamilyAsync(
-    const extensions::Extension* extension,
+    const Extension* extension,
     const std::vector<ImageRepresentation>& info_list,
     const ImageLoaderImageFamilyCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   base::PostTaskAndReplyWithResult(
       BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(LoadImagesOnBlockingPool,
                  info_list,
                  LoadResourceBitmaps(extension, info_list)),
@@ skipping 54 matching lines @@
        it != image_skia_map.end();
        ++it) {
     it->second.MakeThreadSafe();
     image_family.Add(it->second);
   }
 
   callback.Run(image_family);
 }
 
 }  // namespace extensions