Moves extension_icon_image and image_loader to extensions/browser

extensions/browser/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 "extensions/browser/extension_icon_image.h"
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
-#include "chrome/browser/extensions/image_loader.h"
 #include "chrome/common/chrome_paths.h"
-#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
+#include "extensions/browser/image_loader.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_handlers/icons_handler.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"
 
 using content::BrowserThread;
 using extensions::Extension;
 using extensions::IconImage;
 using extensions::Manifest;
@@ skipping 146 matching lines @@
   }
 
   // IconImage::Delegate overrides:
   virtual void OnExtensionIconImageChanged(IconImage* image) OVERRIDE {
     image_loaded_count_++;
     if (quit_in_image_loaded_)
       base::MessageLoop::current()->Quit();
   }
 
   gfx::ImageSkia GetDefaultIcon() {
-    return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IDR_EXTENSIONS_FAVICON);
+    return gfx::ImageSkia(gfx::ImageSkiaRep(gfx::Size(16, 16), 1.0f));
   }
 
   // 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) {
     TestImageLoader image_loader(extension);
     return image_loader.LoadBitmap(path, size);
   }
 
  private:
   int image_loaded_count_;
   bool quit_in_image_loaded_;
   base::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) {
   std::vector<ui::ScaleFactor> supported_factors;
   supported_factors.push_back(ui::SCALE_FACTOR_100P);
   supported_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::ScopedSetSupportedScaleFactors scoped_supported(supported_factors);
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   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.get(), "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
@@ skipping 53 matching lines @@
                                    bitmap_48_resized_to_32));
 }
 
 // There is no resource with either exact or bigger size, but there is a smaller
 // resource.
 TEST_F(ExtensionIconImageTest, FallbackToSmallerWhenNoBigger) {
   std::vector<ui::ScaleFactor> supported_factors;
   supported_factors.push_back(ui::SCALE_FACTOR_100P);
   supported_factors.push_back(ui::SCALE_FACTOR_200P);
   ui::test::ScopedSetSupportedScaleFactors scoped_supported(supported_factors);
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   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.get(), "48.png", 48);
   ASSERT_FALSE(bitmap_48.empty());
@@ skipping 18 matching lines @@
   EXPECT_EQ(2.0f, representation.scale());
   EXPECT_EQ(64, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
                                    EnsureBitmapSize(bitmap_48, 64)));
 }
 
 // There is no resource with exact size, but there is a smaller and a bigger
 // one. Requested size is smaller than 32 though, so the smaller resource should
 // be loaded.
 TEST_F(ExtensionIconImageTest, FallbackToSmaller) {
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   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.get(), "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
@@ skipping 16 matching lines @@
   // We should have loaded smaller (resized) resource.
   EXPECT_EQ(1.0f, representation.scale());
   EXPECT_EQ(17, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
                                    EnsureBitmapSize(bitmap_16, 17)));
 }
 
 // If resource set is empty, |GetRepresentation| should synchronously return
 // default icon, without notifying observer of image change.
 TEST_F(ExtensionIconImageTest, NoResources) {
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   ASSERT_TRUE(extension.get() != NULL);
 
   ExtensionIconSet empty_icon_set;
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   const int kRequestedSize = 24;
   IconImage image(profile.get(),
                   extension.get(),
@@ skipping 18 matching lines @@
       representation.sk_bitmap(),
       EnsureBitmapSize(
           default_icon.GetRepresentation(1.0f).sk_bitmap(),
           kRequestedSize)));
 }
 
 // If resource set is invalid, image load should be done asynchronously and
 // the observer should be notified when it's done. |GetRepresentation| should
 // return the default icon representation once image load is done.
 TEST_F(ExtensionIconImageTest, InvalidResource) {
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   ASSERT_TRUE(extension.get() != NULL);
 
   const int kInvalidIconSize = 24;
   ExtensionIconSet invalid_icon_set;
   invalid_icon_set.Add(kInvalidIconSize, "invalid.png");
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
@@ skipping 18 matching lines @@
   EXPECT_TRUE(gfx::BitmapsAreEqual(
       representation.sk_bitmap(),
       EnsureBitmapSize(
           default_icon.GetRepresentation(1.0f).sk_bitmap(),
           kInvalidIconSize)));
 }
 
 // Test that IconImage works with lazily (but synchronously) created default
 // icon when IconImage returns synchronously.
 TEST_F(ExtensionIconImageTest, LazyDefaultIcon) {
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
   gfx::ImageSkia lazy_default_icon(new MockImageSkiaSource(default_icon),
                                     default_icon.size());
 
   ExtensionIconSet empty_icon_set;
 
@@ skipping 17 matching lines @@
           default_icon.GetRepresentation(1.0f).sk_bitmap(),
           kRequestedSize)));
 
   // We should have a default icon representation.
   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 }
 
 // Test that IconImage works with lazily (but synchronously) created default
 // icon when IconImage returns asynchronously.
 TEST_F(ExtensionIconImageTest, LazyDefaultIcon_AsyncIconImage) {
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
   gfx::ImageSkia lazy_default_icon(new MockImageSkiaSource(default_icon),
                                     default_icon.size());
 
   const int kInvalidIconSize = 24;
   ExtensionIconSet invalid_icon_set;
@@ skipping 23 matching lines @@
       EnsureBitmapSize(
           default_icon.GetRepresentation(1.0f).sk_bitmap(),
           kInvalidIconSize)));
 }
 
 // Tests behavior of image created by IconImage after IconImage host goes
 // away. The image should still return loaded representations. If requested
 // representation was not loaded while IconImage host was around, transparent
 // representations should be returned.
 TEST_F(ExtensionIconImageTest, IconImageDestruction) {
-  scoped_ptr<Profile> profile(new TestingProfile());
+  scoped_ptr<content::BrowserContext> profile(new TestingProfile());
   scoped_refptr<Extension> extension(CreateExtension(
       "extension_icon_image", Manifest::INVALID_LOCATION));
   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.get(), "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
@@ skipping 28 matching lines @@
 
   // When requesting another representation, we should not crash and return some
   // image of the size. It could be blank or a rescale from the existing 1.0f
   // icon.
   representation = image_skia.GetRepresentation(2.0f);
 
   EXPECT_EQ(16, representation.GetWidth());
   EXPECT_EQ(16, representation.GetHeight());
   EXPECT_EQ(2.0f, representation.scale());
 }