Change browser/page action default icon defined in manifest to support hidpi.

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/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"
 
 using content::BrowserThread;
 using extensions::Extension;
 using extensions::IconImage;
 
 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();
   bitmap.eraseColor(SkColorSetARGB(0, 0, 0, 0));
   return bitmap;
 }
 
+SkBitmap EnsureBitmapSize(const SkBitmap& original, int size) {
+  if (original.width() == size && original.height() == size)
+    return original;
+
+  SkBitmap resized = skia::ImageOperations::Resize(
+      original, skia::ImageOperations::RESIZE_LANCZOS3, size, size);
+  return resized;
+}
+
 // Used to test behaviour including images defined by an image skia source.
 // |GetImageForScale| simply returns image representation from the image given
 // in the ctor.
 class MockImageSkiaSource : public gfx::ImageSkiaSource {
  public:
   explicit MockImageSkiaSource(const gfx::ImageSkia& image)
       : image_(image) {
   }
   virtual ~MockImageSkiaSource() {}
 
@@ skipping 236 matching lines @@
 
   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());
 
   representation = image.image_skia().GetRepresentation(ui::SCALE_FACTOR_200P);
 
-  // We should have loaded the biggest smaller resource. In this case the
-  // loaded resource should not be resized.
+  // We should have loaded the biggest smaller resource resized to the actual
+  // size.
   EXPECT_EQ(ui::SCALE_FACTOR_200P, representation.scale_factor());
-  EXPECT_EQ(48, representation.pixel_width());
-  EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_48));
+  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));
   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);
   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());
 
   representation = image.image_skia().GetRepresentation(ui::SCALE_FACTOR_100P);
 
-  // We should have loaded smaller (not resized) resource.
+  // We should have loaded smaller (resized) resource.
   EXPECT_EQ(ui::SCALE_FACTOR_100P, representation.scale_factor());
-  EXPECT_EQ(16, representation.pixel_width());
-  EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_16));
+  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));
   ASSERT_TRUE(extension.get() != NULL);
 
   ExtensionIconSet empty_icon_set;
@@ skipping 182 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)));
 }