Generalize ExtensionIconSet to store icon paths for custom size sets

chrome/browser/extensions/image_loading_tracker_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 "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/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "grit/component_extension_resources.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/size.h"
@@ skipping 77 matching lines @@
   content::TestBrowserThread io_thread_;
 };
 
 // Tests asking ImageLoadingTracker to cache pushes the result to the Extension.
 TEST_F(ImageLoadingTrackerTest, Cache) {
   scoped_refptr<Extension> extension(CreateExtension(
       "image_loading_tracker", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   ExtensionResource image_resource =
-      extension->GetIconResource(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+      extension->GetIconResource(extension_misc::EXTENSION_ICON_SMALLISH,
                                  ExtensionIconSet::MATCH_EXACTLY);
-  gfx::Size max_size(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
-                     ExtensionIconSet::EXTENSION_ICON_SMALLISH);
+  gfx::Size max_size(extension_misc::EXTENSION_ICON_SMALLISH,
+                     extension_misc::EXTENSION_ICON_SMALLISH);
   ImageLoadingTracker loader(this);
   loader.LoadImage(extension.get(),
                    image_resource,
                    max_size,
                    ImageLoadingTracker::CACHE);
 
   // The image isn't cached, so we should not have received notification.
   EXPECT_EQ(0, image_loaded_count());
 
   WaitForImageLoad();
 
   // We should have gotten the image.
   EXPECT_EQ(1, image_loaded_count());
 
   // Check that the image was loaded.
-  EXPECT_EQ(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+  EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             image_.ToSkBitmap()->width());
 
   // The image should be cached in the Extension.
   EXPECT_TRUE(extension->HasCachedImage(image_resource, max_size));
 
   // Make sure the image is in the extension.
-  EXPECT_EQ(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+  EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             extension->GetCachedImage(image_resource, max_size).width());
 
   // Ask the tracker for the image again, this should call us back immediately.
   loader.LoadImage(extension.get(),
                    image_resource,
                    max_size,
                    ImageLoadingTracker::CACHE);
   // We should have gotten the image.
   EXPECT_EQ(1, image_loaded_count());
 
   // Check that the image was loaded.
-  EXPECT_EQ(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+  EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             image_.ToSkBitmap()->width());
 }
 
 // Tests deleting an extension while waiting for the image to load doesn't cause
 // problems.
 TEST_F(ImageLoadingTrackerTest, DeleteExtensionWhileWaitingForCache) {
   scoped_refptr<Extension> extension(CreateExtension(
       "image_loading_tracker", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   ExtensionResource image_resource =
-      extension->GetIconResource(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+      extension->GetIconResource(extension_misc::EXTENSION_ICON_SMALLISH,
                                  ExtensionIconSet::MATCH_EXACTLY);
   ImageLoadingTracker loader(this);
   loader.LoadImage(extension.get(),
                    image_resource,
-                   gfx::Size(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
-                             ExtensionIconSet::EXTENSION_ICON_SMALLISH),
+                   gfx::Size(extension_misc::EXTENSION_ICON_SMALLISH,
+                             extension_misc::EXTENSION_ICON_SMALLISH),
                    ImageLoadingTracker::CACHE);
 
   // The image isn't cached, so we should not have received notification.
   EXPECT_EQ(0, image_loaded_count());
 
   // Send out notification the extension was uninstalled.
   extensions::UnloadedExtensionInfo details(extension.get(),
       extension_misc::UNLOAD_REASON_UNINSTALL);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_EXTENSION_UNLOADED,
       content::NotificationService::AllSources(),
       content::Details<extensions::UnloadedExtensionInfo>(&details));
 
   // Chuck the extension, that way if anyone tries to access it we should crash
   // or get valgrind errors.
   extension = NULL;
 
   WaitForImageLoad();
 
   // Even though we deleted the extension, we should still get the image.
   // We should still have gotten the image.
   EXPECT_EQ(1, image_loaded_count());
 
   // Check that the image was loaded.
-  EXPECT_EQ(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+  EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             image_.ToSkBitmap()->width());
 }
 
 // Tests loading multiple dimensions of the same image.
 TEST_F(ImageLoadingTrackerTest, MultipleImages) {
   scoped_refptr<Extension> extension(CreateExtension(
       "image_loading_tracker", Extension::INVALID));
   ASSERT_TRUE(extension.get() != NULL);
 
   std::vector<ImageLoadingTracker::ImageInfo> info_list;
-  int sizes[] = {ExtensionIconSet::EXTENSION_ICON_SMALLISH,
-                 ExtensionIconSet::EXTENSION_ICON_BITTY};
+  int sizes[] = {extension_misc::EXTENSION_ICON_SMALLISH,
+                 extension_misc::EXTENSION_ICON_BITTY};
   for (size_t i = 0; i < arraysize(sizes); ++i) {
     ExtensionResource resource =
         extension->GetIconResource(sizes[i], ExtensionIconSet::MATCH_EXACTLY);
     info_list.push_back(ImageLoadingTracker::ImageInfo(
         resource, gfx::Size(sizes[i], sizes[i])));
   }
 
   ImageLoadingTracker loader(this);
   loader.LoadImages(extension.get(), info_list, ImageLoadingTracker::CACHE);
 
   // The image isn't cached, so we should not have received notification.
   EXPECT_EQ(0, image_loaded_count());
 
   WaitForImageLoad();
 
   // We should have gotten the image.
   EXPECT_EQ(1, image_loaded_count());
 
   // Check that all images were loaded.
   std::vector<gfx::ImageSkiaRep> image_reps =
       image_.ToImageSkia()->image_reps();
   ASSERT_EQ(2u, image_reps.size());
   const gfx::ImageSkiaRep* img_rep1 = &image_reps[0];
   const gfx::ImageSkiaRep* img_rep2 = &image_reps[1];
   if (img_rep1->pixel_width() > img_rep2->pixel_width()) {
     std::swap(img_rep1, img_rep2);
   }
-  EXPECT_EQ(ExtensionIconSet::EXTENSION_ICON_BITTY,
+  EXPECT_EQ(extension_misc::EXTENSION_ICON_BITTY,
             img_rep1->pixel_width());
-  EXPECT_EQ(ExtensionIconSet::EXTENSION_ICON_SMALLISH,
+  EXPECT_EQ(extension_misc::EXTENSION_ICON_SMALLISH,
             img_rep2->pixel_width());
 }
 
 // Tests IsComponentExtensionResource function.
 TEST_F(ImageLoadingTrackerTest, IsComponentExtensionResource) {
   scoped_refptr<Extension> extension(CreateExtension(
       "file_manager", Extension::COMPONENT));
   ASSERT_TRUE(extension.get() != NULL);
 
   ExtensionResource resource =
-      extension->GetIconResource(ExtensionIconSet::EXTENSION_ICON_BITTY,
+      extension->GetIconResource(extension_misc::EXTENSION_ICON_BITTY,
                                  ExtensionIconSet::MATCH_EXACTLY);
 
 #if defined(FILE_MANAGER_EXTENSION)
   ImageLoadingTracker loader(this);
   int resource_id;
   ASSERT_EQ(true,
             loader.IsComponentExtensionResource(extension.get(),
                                                 resource,
                                                 resource_id));
   ASSERT_EQ(IDR_FILE_MANAGER_ICON_16, resource_id);
 #endif
 }