Make some updates to extension iconography.

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 62 matching lines @@
 
   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.
-  void LoadImageAsync(const extensions::Extension* extension,
+  // 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.
+  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 extensions::Extension* extension,
+  void LoadImagesAsync(const Extension* extension,
                        const std::vector<ImageRepresentation>& info_list,
                        const ImageLoaderImageCallback& callback);
 
   // Same as LoadImagesAsync() above except it loads into an image family. This
   // is used to load multiple images of different logical sizes as opposed to
   // LoadImagesAsync() which loads different scale factors of the same logical
   // image size.
   //
   // If multiple images of the same logical size are loaded, they will be
   // combined into a single ImageSkia in the ImageFamily.
-  void LoadImageFamilyAsync(const extensions::Extension* extension,
+  void LoadImageFamilyAsync(const Extension* extension,
                             const std::vector<ImageRepresentation>& info_list,
                             const ImageLoaderImageFamilyCallback& callback);
 
  private:
   void ReplyBack(const ImageLoaderImageCallback& callback,
                  const std::vector<LoadResult>& load_result);
 
   void ReplyBackWithImageFamily(const ImageLoaderImageFamilyCallback& callback,
                                 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_