Add a class to replace ImageLoadingTracker with a nicer API.

chrome/browser/extensions/extension_icon_image_unittest.cc

 // 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.
 
 #include "chrome/browser/extensions/extension_icon_image.h"
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
-#include "chrome/browser/extensions/image_loading_tracker.h"
+#include "chrome/browser/extensions/image_loader.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/test/test_browser_thread.h"
 #include "grit/theme_resources.h"
 #include "skia/ext/image_operations.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/skia_util.h"
@@ skipping 37 matching lines @@
   virtual gfx::ImageSkiaRep GetImageForScale(
       ui::ScaleFactor scale_factor) OVERRIDE {
     return image_.GetRepresentation(scale_factor);
   }
 
  private:
   gfx::ImageSkia image_;
 };
 
 // Helper class for synchronously loading extension image resource.
-class TestImageLoader : public ImageLoadingTracker::Observer {
+class TestImageLoader {
  public:
   explicit TestImageLoader(const Extension* extension)
       : extension_(extension),
         waiting_(false),
-        image_loaded_(false),
-        ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)) {
+        image_loaded_(false) {
   }
   virtual ~TestImageLoader() {}
 
-  // ImageLoadingTracker::Observer override.
-  virtual void OnImageLoaded(const gfx::Image& image,
-                             const std::string& extension_id,
-                             int index) OVERRIDE {
+  void OnImageLoaded(const gfx::Image& image) {
     image_ = image;
     image_loaded_ = true;
     if (waiting_)
       MessageLoop::current()->Quit();
   }
 
   SkBitmap LoadBitmap(const std::string& path,
-                      int size,
-                      ImageLoadingTracker::CacheParam cache_param) {
+                      int size) {
     image_loaded_ = false;
 
-    tracker_.LoadImage(extension_,
-                       extension_->GetResource(path),
-                       gfx::Size(size, size),
-                       cache_param);
+    image_loader_.LoadImageAsync(
+        extension_, extension_->GetResource(path), gfx::Size(size, size),
+        base::Bind(&TestImageLoader::OnImageLoaded,
+                   base::Unretained(this)));
 
     // If |image_| still hasn't been loaded (i.e. it is being loaded
     // asynchronously), wait for it.
     if (!image_loaded_) {
       waiting_ = true;
       MessageLoop::current()->Run();
       waiting_ = false;
     }
 
     EXPECT_TRUE(image_loaded_);
 
     return image_.IsEmpty() ? SkBitmap() : *image_.ToSkBitmap();
   }
 
  private:
   const Extension* extension_;
   bool waiting_;
   bool image_loaded_;
   gfx::Image image_;
-  ImageLoadingTracker tracker_;
+  extensions::ImageLoader image_loader_;
 
   DISALLOW_COPY_AND_ASSIGN(TestImageLoader);
 };
 
 class ExtensionIconImageTest : public testing::Test,
                                public IconImage::Observer {
  public:
   ExtensionIconImageTest()
       : image_loaded_count_(0),
         quit_in_image_loaded_(false),
@@ skipping 58 matching lines @@
 
   gfx::ImageSkia GetDefaultIcon() {
     return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         IDR_EXTENSIONS_FAVICON);
   }
 
   // Loads an image to be used in test from the extension.
   // The image will be loaded from the relative path |path|.
   SkBitmap GetTestBitmap(const Extension* extension,
                          const std::string& path,
-                         int size,
-                         ImageLoadingTracker::CacheParam cache_param) {
+                         int size) {
     TestImageLoader image_loader(extension);
-    return image_loader.LoadBitmap(path, size, cache_param);
+    return image_loader.LoadBitmap(path, size);
   }
 
  private:
   int image_loaded_count_;
   bool quit_in_image_loaded_;
   MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionIconImageTest);
 };
 
 }  // namespace
 
 TEST_F(ExtensionIconImageTest, Basic) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_16 =
-      GetTestBitmap(extension, "16.png", 16, ImageLoadingTracker::DONT_CACHE);
+      GetTestBitmap(extension, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
   // There is no image of size 32 defined in the extension manifest, so we
   // should expect manifest image of size 48 resized to size 32.
   SkBitmap bitmap_48_resized_to_32 =
-      GetTestBitmap(extension, "48.png", 32, ImageLoadingTracker::DONT_CACHE);
+      GetTestBitmap(extension, "48.png", 32);
   ASSERT_FALSE(bitmap_48_resized_to_32.empty());
 
   IconImage image(extension, extension->icons(), 16, default_icon, this);
 
   // No representations in |image_| yet.
   gfx::ImageSkia::ImageSkiaReps image_reps = image.image_skia().image_reps();
   ASSERT_EQ(0u, image_reps.size());
 
   // Gets representation for a scale factor.
   gfx::ImageSkiaRep representation =
@@ skipping 39 matching lines @@
 TEST_F(ExtensionIconImageTest, FallbackToSmallerWhenNoBigger) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_48 =
-      GetTestBitmap(extension, "48.png", 48, ImageLoadingTracker::DONT_CACHE);
+      GetTestBitmap(extension, "48.png", 48);
   ASSERT_FALSE(bitmap_48.empty());
 
   IconImage image(extension, extension->icons(), 32, default_icon, this);
 
   gfx::ImageSkiaRep representation =
       image.image_skia().GetRepresentation(ui::SCALE_FACTOR_200P);
 
   WaitForImageLoad();
   EXPECT_EQ(1, ImageLoadedCount());
   ASSERT_EQ(1u, image.image_skia().image_reps().size());
@@ skipping 14 matching lines @@
 TEST_F(ExtensionIconImageTest, FallbackToSmaller) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_16 =
-      GetTestBitmap(extension, "16.png", 16, ImageLoadingTracker::DONT_CACHE);
+      GetTestBitmap(extension, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
   IconImage image(extension, extension->icons(), 17, default_icon, this);
 
   gfx::ImageSkiaRep representation =
       image.image_skia().GetRepresentation(ui::SCALE_FACTOR_100P);
 
   WaitForImageLoad();
   EXPECT_EQ(1, ImageLoadedCount());
   ASSERT_EQ(1u, image.image_skia().image_reps().size());
@@ skipping 131 matching lines @@
       default_icon.GetRepresentation(ui::SCALE_FACTOR_100P).sk_bitmap()));
 }
 
 TEST_F(ExtensionIconImageTest, LoadPrecachedImage) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
-  // Note the cache parameter.
+  // Store the image in the cache.
   SkBitmap bitmap_16 =
-      GetTestBitmap(extension, "16.png", 16, ImageLoadingTracker::CACHE);
+      GetTestBitmap(extension, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
+  extension->SetCachedImage(extension->GetResource("16.png"), bitmap_16,
+                            gfx::Size(16, 16));
 
   IconImage image(extension, extension->icons(), 16, default_icon, this);
 
   // No representations in |image_| yet.
   gfx::ImageSkia::ImageSkiaReps image_reps = image.image_skia().image_reps();
   ASSERT_EQ(0u, image_reps.size());
 
   // Gets representation for a scale factor.
   // Since the icon representation is precached, it should be returned right
   // away. Also, we should not receive any notifications.
@@ skipping 12 matching lines @@
 TEST_F(ExtensionIconImageTest, IconImageDestruction) {
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_16 =
-      GetTestBitmap(extension, "16.png", 16, ImageLoadingTracker::DONT_CACHE);
+      GetTestBitmap(extension, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
   scoped_ptr<IconImage> image(
       new IconImage(extension, extension->icons(), 16, default_icon, this));
 
   // Load an image representation.
   gfx::ImageSkiaRep representation =
       image->image_skia().GetRepresentation(ui::SCALE_FACTOR_100P);
 
   WaitForImageLoad();
@@ skipping 12 matching lines @@
   EXPECT_EQ(16, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_16));
 
   // When requesting another representation, we should get blank image.
   representation = image_skia.GetRepresentation(ui::SCALE_FACTOR_200P);
 
   EXPECT_TRUE(gfx::BitmapsAreEqual(
       representation.sk_bitmap(),
       CreateBlankBitmapForScale(16, ui::SCALE_FACTOR_200P)));
 }