Use base::PostTaskAndReplyWithResults() in more places.

chrome/browser/extensions/image_loader.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_IMAGE_LOADER_H_
 #define CHROME_BROWSER_EXTENSIONS_IMAGE_LOADER_H_
 
 #include <set>
 
 #include "base/callback_forward.h"
@@ skipping 10 matching lines @@
 }
 
 namespace gfx {
 class Image;
 }
 
 namespace extensions {
 
 class Extension;
 
+typedef base::Callback<void(const gfx::Image&)> ImageLoaderCallback;
+
 // This class is responsible for asynchronously loading extension images and
 // calling a callback when an image is loaded.
 // The views need to load their icons asynchronously might be deleted before
 // the images have loaded. If you pass your callback using a weak_ptr, this
 // will make sure the callback won't be called after the view is deleted.
 class ImageLoader : public BrowserContextKeyedService {
  public:
   // Information about a singe image representation to load from an extension
   // resource.
   struct ImageRepresentation {
@@ skipping 43 matching lines @@
 
   // 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,
                       const ExtensionResource& resource,
                       const gfx::Size& max_size,
-                      const base::Callback<void(const gfx::Image&)>& callback);
+                      const ImageLoaderCallback& callback);
 
   // Same as LoadImage() 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,
                        const std::vector<ImageRepresentation>& info_list,
-                       const base::Callback<void(const gfx::Image&)>& callback);
+                       const ImageLoaderCallback& callback);
 
  private:
+  void ReplyBack(const ImageLoaderCallback& callback,
+                 const std::vector<LoadResult>& load_result);
+
   base::WeakPtrFactory<ImageLoader> weak_ptr_factory_;
 
-  static void LoadImagesOnBlockingPool(
-      const std::vector<ImageRepresentation>& info_list,
-      const std::vector<SkBitmap>& bitmaps,
-      std::vector<LoadResult>* load_result);
-
-  void ReplyBack(
-      const std::vector<LoadResult>* load_result,
-      const base::Callback<void(const gfx::Image&)>& callback);
+  DISALLOW_COPY_AND_ASSIGN(ImageLoader);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_IMAGE_LOADER_H_