Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

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_loader.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
+#include "chrome/common/extensions/manifest.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"
 
 using content::BrowserThread;
 using extensions::Extension;
 using extensions::IconImage;
+using extensions::Manifest;
 
 namespace {
 
 SkBitmap CreateBlankBitmapForScale(int size_dip, ui::ScaleFactor scale_factor) {
   SkBitmap bitmap;
   const float scale = ui::GetScaleFactorScale(scale_factor);
   bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                    static_cast<int>(size_dip * scale),
                    static_cast<int>(size_dip * scale));
   bitmap.allocPixels();
@@ skipping 97 matching lines @@
     quit_in_image_loaded_ = false;
   }
 
   int ImageLoadedCount() {
     int result = image_loaded_count_;
     image_loaded_count_ = 0;
     return result;
   }
 
   scoped_refptr<Extension> CreateExtension(const char* name,
-                                           Extension::Location location) {
+                                           Manifest::Location location) {
     // Create and load an extension.
     FilePath test_file;
     if (!PathService::Get(chrome::DIR_TEST_DATA, &test_file)) {
       EXPECT_FALSE(true);
       return NULL;
     }
     test_file = test_file.AppendASCII("extensions").AppendASCII(name);
     int error_code = 0;
     std::string error;
     JSONFileValueSerializer serializer(test_file.AppendASCII("app.json"));
@@ skipping 47 matching lines @@
   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));
+      "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, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
@@ skipping 45 matching lines @@
   // Image should have been resized.
   EXPECT_EQ(32, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
                                    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) {
   scoped_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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, "48.png", 48);
   ASSERT_FALSE(bitmap_48.empty());
 
@@ skipping 14 matching lines @@
   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_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(ui::SCALE_FACTOR_100P, representation.scale_factor());
   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_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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(extension, empty_icon_set, kRequestedSize, default_icon,
                   this);
 
   gfx::ImageSkiaRep representation =
@@ skipping 14 matching lines @@
       EnsureBitmapSize(
           default_icon.GetRepresentation(ui::SCALE_FACTOR_100P).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_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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();
 
   IconImage image(extension, invalid_icon_set, kInvalidIconSize, default_icon,
                   this);
@@ skipping 14 matching lines @@
       representation.sk_bitmap(),
       EnsureBitmapSize(
           default_icon.GetRepresentation(ui::SCALE_FACTOR_100P).sk_bitmap(),
           kInvalidIconSize)));
 }
 
 // Test that IconImage works with lazily (but synchronously) created default
 // icon when IconImage returns synchronously.
 TEST_F(ExtensionIconImageTest, LazyDefaultIcon) {
   scoped_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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;
 
   const int kRequestedSize = 128;
   IconImage image(extension, empty_icon_set, kRequestedSize, lazy_default_icon,
@@ skipping 13 matching lines @@
           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_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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;
   invalid_icon_set.Add(kInvalidIconSize, "invalid.png");
 
@@ skipping 15 matching lines @@
   representation = image.image_skia().GetRepresentation(ui::SCALE_FACTOR_100P);
   EXPECT_TRUE(gfx::BitmapsAreEqual(
       representation.sk_bitmap(),
       EnsureBitmapSize(
           default_icon.GetRepresentation(ui::SCALE_FACTOR_100P).sk_bitmap(),
           kInvalidIconSize)));
 }
 
 TEST_F(ExtensionIconImageTest, LoadPrecachedImage) {
   scoped_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "extension_icon_image", Manifest::INVALID_LOCATION));
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Store the image in the cache.
   SkBitmap bitmap_16 =
       GetTestBitmap(extension, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
   extension->SetCachedImage(extension->GetResource("16.png"), bitmap_16,
                             gfx::Size(16, 16));
@@ skipping 14 matching lines @@
   EXPECT_EQ(0, ImageLoadedCount());
   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 }
 
 // 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_refptr<Extension> extension(CreateExtension(
-      "extension_icon_image", Extension::INVALID));
+      "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, "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
@@ skipping 20 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)));
 }