Load extension icons for more scale factors.

extensions/browser/image_loader.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_IMAGE_LOADER_H_
 #define EXTENSIONS_BROWSER_IMAGE_LOADER_H_
 
 #include <set>
 
 #include "base/callback_forward.h"
@@ skipping 31 matching lines @@
   // Information about a singe image representation to load from an extension
   // resource.
   struct ImageRepresentation {
     // Enum values to indicate whether to resize loaded bitmap when it is larger
     // than |desired_size| or always resize it.
     enum ResizeCondition { RESIZE_WHEN_LARGER, ALWAYS_RESIZE, NEVER_RESIZE };
 
     ImageRepresentation(const ExtensionResource& resource,
                         ResizeCondition resize_condition,
                         const gfx::Size& desired_size,
-                        ui::ScaleFactor scale_factor);
+                        float scale_factor);
     ~ImageRepresentation();
 
     // Extension resource to load.
     ExtensionResource resource;
 
     ResizeCondition resize_condition;
 
     // When |resize_method| is ALWAYS_RESIZE or when the loaded image is larger
     // than |desired_size| it will be resized to these dimensions.
     gfx::Size desired_size;
 
     // |scale_factor| is used to construct the loaded gfx::ImageSkia.
-    ui::ScaleFactor scale_factor;
+    float scale_factor;
   };
 
   struct LoadResult;
 
   // Returns the instance for the given |context| or NULL if none. This is
   // a convenience wrapper around ImageLoaderFactory::GetForBrowserContext.
   static ImageLoader* Get(content::BrowserContext* context);
 
   ImageLoader();
   ~ImageLoader() override;
 
   // Specify image resource to load. If the loaded image is larger than
   // |max_size| it will be resized to those dimensions. IMPORTANT NOTE: this
   // function may call back your callback synchronously (ie before it returns)
   // if the image was found in the cache.
   // Note this method loads a raw bitmap from the resource. All sizes given are
   // assumed to be in pixels.
   // TODO(estade): remove this in favor of LoadImageAtEveryScaleFactorAsync,
   // and rename the latter to LoadImageAsync.
   void LoadImageAsync(const Extension* extension,
                       const ExtensionResource& resource,
                       const gfx::Size& max_size,
                       const ImageLoaderImageCallback& callback);
 
-  // Loads and returns a gfx::Image that has representations at all supported
-  // scale factors.
+  // Loads a gfx::Image that has representations at all scale factors we are
+  // likely to care about. That includes every scale for which we pack resources
+  // in ResourceBundle plus the scale for all currently attached displays. The
+  // image is returned via |callback|.
   void LoadImageAtEveryScaleFactorAsync(
       const Extension* extension,
       const gfx::Size& dip_size,
       const ImageLoaderImageCallback& callback);
 
   // Same as LoadImageAsync() above except it loads multiple images from the
   // same extension. This is used to load multiple resolutions of the same image
   // type.
   void LoadImagesAsync(const Extension* extension,
                        const std::vector<ImageRepresentation>& info_list,
@@ skipping 18 matching lines @@
                                 const std::vector<LoadResult>& load_result);
 
   base::WeakPtrFactory<ImageLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageLoader);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_IMAGE_LOADER_H_