extensions/browser/extension_icon_image_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/extension_icon_image.h"
   6
   7 #include "base/json/json_file_value_serializer.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/path_service.h"
  10 #include "chrome/test/base/testing_profile.h"
  11 #include "content/public/test/test_browser_thread.h"
  12 #include "extensions/browser/image_loader.h"
  13 #include "extensions/common/extension.h"
  14 #include "extensions/common/extension_paths.h"
  15 #include "extensions/common/manifest.h"
  16 #include "extensions/common/manifest_handlers/icons_handler.h"
  17 #include "skia/ext/image_operations.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "ui/base/resource/resource_bundle.h"
  20 #include "ui/gfx/image/image_skia_source.h"
  21 #include "ui/gfx/skia_util.h"
  22
  23 using content::BrowserThread;
  24 using extensions::Extension;
  25 using extensions::IconImage;
  26 using extensions::Manifest;
  27
  28 namespace {
  29
  30 SkBitmap CreateBlankBitmapForScale(int size_dip, ui::ScaleFactor scale_factor) {
  31   SkBitmap bitmap;
  32   const float scale = ui::GetScaleForScaleFactor(scale_factor);
  33   bitmap.allocN32Pixels(static_cast<int>(size_dip * scale),
  34                         static_cast<int>(size_dip * scale));
  35   bitmap.eraseColor(SkColorSetARGB(0, 0, 0, 0));
  36   return bitmap;
  37 }
  38
  39 SkBitmap EnsureBitmapSize(const SkBitmap& original, int size) {
  40   if (original.width() == size && original.height() == size)
  41     return original;
  42
  43   SkBitmap resized = skia::ImageOperations::Resize(
  44       original, skia::ImageOperations::RESIZE_LANCZOS3, size, size);
  45   return resized;
  46 }
  47
  48 // Used to test behavior including images defined by an image skia source.
  49 // |GetImageForScale| simply returns image representation from the image given
  50 // in the ctor.
  51 class MockImageSkiaSource : public gfx::ImageSkiaSource {
  52  public:
  53   explicit MockImageSkiaSource(const gfx::ImageSkia& image)
  54       : image_(image) {
  55   }
  56   virtual ~MockImageSkiaSource() {}
  57
  58   virtual gfx::ImageSkiaRep GetImageForScale(float scale) OVERRIDE {
  59     return image_.GetRepresentation(scale);
  60   }
  61
  62  private:
  63   gfx::ImageSkia image_;
  64 };
  65
  66 // Helper class for synchronously loading extension image resource.
  67 class TestImageLoader {
  68  public:
  69   explicit TestImageLoader(const Extension* extension)
  70       : extension_(extension),
  71         waiting_(false),
  72         image_loaded_(false) {
  73   }
  74   virtual ~TestImageLoader() {}
  75
  76   void OnImageLoaded(const gfx::Image& image) {
  77     image_ = image;
  78     image_loaded_ = true;
  79     if (waiting_)
  80       base::MessageLoop::current()->Quit();
  81   }
  82
  83   SkBitmap LoadBitmap(const std::string& path,
  84                       int size) {
  85     image_loaded_ = false;
  86
  87     image_loader_.LoadImageAsync(
  88         extension_, extension_->GetResource(path), gfx::Size(size, size),
  89         base::Bind(&TestImageLoader::OnImageLoaded,
  90                    base::Unretained(this)));
  91
  92     // If |image_| still hasn't been loaded (i.e. it is being loaded
  93     // asynchronously), wait for it.
  94     if (!image_loaded_) {
  95       waiting_ = true;
  96       base::MessageLoop::current()->Run();
  97       waiting_ = false;
  98     }
  99
 100     EXPECT_TRUE(image_loaded_);
 101
 102     return image_.IsEmpty() ? SkBitmap() : *image_.ToSkBitmap();
 103   }
 104
 105  private:
 106   const Extension* extension_;
 107   bool waiting_;
 108   bool image_loaded_;
 109   gfx::Image image_;
 110   extensions::ImageLoader image_loader_;
 111
 112   DISALLOW_COPY_AND_ASSIGN(TestImageLoader);
 113 };
 114
 115 class ExtensionIconImageTest : public testing::Test,
 116                                public IconImage::Observer {
 117  public:
 118   ExtensionIconImageTest()
 119       : image_loaded_count_(0),
 120         quit_in_image_loaded_(false),
 121         ui_thread_(BrowserThread::UI, &ui_loop_),
 122         file_thread_(BrowserThread::FILE),
 123         io_thread_(BrowserThread::IO) {
 124   }
 125
 126   virtual ~ExtensionIconImageTest() {}
 127
 128   void WaitForImageLoad() {
 129     quit_in_image_loaded_ = true;
 130     base::MessageLoop::current()->Run();
 131     quit_in_image_loaded_ = false;
 132   }
 133
 134   int ImageLoadedCount() {
 135     int result = image_loaded_count_;
 136     image_loaded_count_ = 0;
 137     return result;
 138   }
 139
 140   scoped_refptr<Extension> CreateExtension(const char* name,
 141                                            Manifest::Location location) {
 142     // Create and load an extension.
 143     base::FilePath test_file;
 144     if (!PathService::Get(extensions::DIR_TEST_DATA, &test_file)) {
 145       EXPECT_FALSE(true);
 146       return NULL;
 147     }
 148     test_file = test_file.AppendASCII(name);
 149     int error_code = 0;
 150     std::string error;
 151     JSONFileValueSerializer serializer(test_file.AppendASCII("manifest.json"));
 152     scoped_ptr<base::DictionaryValue> valid_value(
 153         static_cast<base::DictionaryValue*>(serializer.Deserialize(&error_code,
 154                                                                    &error)));
 155     EXPECT_EQ(0, error_code) << error;
 156     if (error_code != 0)
 157       return NULL;
 158
 159     EXPECT_TRUE(valid_value.get());
 160     if (!valid_value)
 161       return NULL;
 162
 163     return Extension::Create(test_file, location, *valid_value,
 164                              Extension::NO_FLAGS, &error);
 165   }
 166
 167   // testing::Test overrides:
 168   virtual void SetUp() OVERRIDE {
 169     file_thread_.Start();
 170     io_thread_.Start();
 171   }
 172
 173   // IconImage::Delegate overrides:
 174   virtual void OnExtensionIconImageChanged(IconImage* image) OVERRIDE {
 175     image_loaded_count_++;
 176     if (quit_in_image_loaded_)
 177       base::MessageLoop::current()->Quit();
 178   }
 179
 180   gfx::ImageSkia GetDefaultIcon() {
 181     return gfx::ImageSkia(gfx::ImageSkiaRep(gfx::Size(16, 16), 1.0f));
 182   }
 183
 184   // Loads an image to be used in test from the extension.
 185   // The image will be loaded from the relative path |path|.
 186   SkBitmap GetTestBitmap(const Extension* extension,
 187                          const std::string& path,
 188                          int size) {
 189     TestImageLoader image_loader(extension);
 190     return image_loader.LoadBitmap(path, size);
 191   }
 192
 193  private:
 194   int image_loaded_count_;
 195   bool quit_in_image_loaded_;
 196   base::MessageLoop ui_loop_;
 197   content::TestBrowserThread ui_thread_;
 198   content::TestBrowserThread file_thread_;
 199   content::TestBrowserThread io_thread_;
 200
 201   DISALLOW_COPY_AND_ASSIGN(ExtensionIconImageTest);
 202 };
 203
 204 }  // namespace
 205
 206 TEST_F(ExtensionIconImageTest, Basic) {
 207   std::vector<ui::ScaleFactor> supported_factors;
 208   supported_factors.push_back(ui::SCALE_FACTOR_100P);
 209   supported_factors.push_back(ui::SCALE_FACTOR_200P);
 210   ui::test::ScopedSetSupportedScaleFactors scoped_supported(supported_factors);
 211   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 212   scoped_refptr<Extension> extension(CreateExtension(
 213       "extension_icon_image", Manifest::INVALID_LOCATION));
 214   ASSERT_TRUE(extension.get() != NULL);
 215
 216   gfx::ImageSkia default_icon = GetDefaultIcon();
 217
 218   // Load images we expect to find as representations in icon_image, so we
 219   // can later use them to validate icon_image.
 220   SkBitmap bitmap_16 = GetTestBitmap(extension.get(), "16.png", 16);
 221   ASSERT_FALSE(bitmap_16.empty());
 222
 223   // There is no image of size 32 defined in the extension manifest, so we
 224   // should expect manifest image of size 48 resized to size 32.
 225   SkBitmap bitmap_48_resized_to_32 =
 226       GetTestBitmap(extension.get(), "48.png", 32);
 227   ASSERT_FALSE(bitmap_48_resized_to_32.empty());
 228
 229   IconImage image(profile.get(),
 230                   extension.get(),
 231                   extensions::IconsInfo::GetIcons(extension.get()),
 232                   16,
 233                   default_icon,
 234                   this);
 235
 236   // No representations in |image_| yet.
 237   gfx::ImageSkia::ImageSkiaReps image_reps = image.image_skia().image_reps();
 238   ASSERT_EQ(0u, image_reps.size());
 239
 240   // Gets representation for a scale factor.
 241   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(1.0f);
 242
 243   // Before the image representation is loaded, image should contain blank
 244   // image representation.
 245   EXPECT_TRUE(gfx::BitmapsAreEqual(
 246       representation.sk_bitmap(),
 247       CreateBlankBitmapForScale(16, ui::SCALE_FACTOR_100P)));
 248
 249   WaitForImageLoad();
 250   EXPECT_EQ(1, ImageLoadedCount());
 251   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 252
 253   representation = image.image_skia().GetRepresentation(1.0f);
 254
 255   // We should get the right representation now.
 256   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_16));
 257   EXPECT_EQ(16, representation.pixel_width());
 258
 259   // Gets representation for an additional scale factor.
 260   representation = image.image_skia().GetRepresentation(2.0f);
 261
 262   EXPECT_TRUE(gfx::BitmapsAreEqual(
 263       representation.sk_bitmap(),
 264       CreateBlankBitmapForScale(16, ui::SCALE_FACTOR_200P)));
 265
 266   WaitForImageLoad();
 267   EXPECT_EQ(1, ImageLoadedCount());
 268   ASSERT_EQ(2u, image.image_skia().image_reps().size());
 269
 270   representation = image.image_skia().GetRepresentation(2.0f);
 271
 272   // Image should have been resized.
 273   EXPECT_EQ(32, representation.pixel_width());
 274   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
 275                                    bitmap_48_resized_to_32));
 276 }
 277
 278 // There is no resource with either exact or bigger size, but there is a smaller
 279 // resource.
 280 TEST_F(ExtensionIconImageTest, FallbackToSmallerWhenNoBigger) {
 281   std::vector<ui::ScaleFactor> supported_factors;
 282   supported_factors.push_back(ui::SCALE_FACTOR_100P);
 283   supported_factors.push_back(ui::SCALE_FACTOR_200P);
 284   ui::test::ScopedSetSupportedScaleFactors scoped_supported(supported_factors);
 285   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 286   scoped_refptr<Extension> extension(CreateExtension(
 287       "extension_icon_image", Manifest::INVALID_LOCATION));
 288   ASSERT_TRUE(extension.get() != NULL);
 289
 290   gfx::ImageSkia default_icon = GetDefaultIcon();
 291
 292   // Load images we expect to find as representations in icon_image, so we
 293   // can later use them to validate icon_image.
 294   SkBitmap bitmap_48 = GetTestBitmap(extension.get(), "48.png", 48);
 295   ASSERT_FALSE(bitmap_48.empty());
 296
 297   IconImage image(profile.get(),
 298                   extension.get(),
 299                   extensions::IconsInfo::GetIcons(extension.get()),
 300                   32,
 301                   default_icon,
 302                   this);
 303
 304   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(2.0f);
 305
 306   WaitForImageLoad();
 307   EXPECT_EQ(1, ImageLoadedCount());
 308   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 309
 310   representation = image.image_skia().GetRepresentation(2.0f);
 311
 312   // We should have loaded the biggest smaller resource resized to the actual
 313   // size.
 314   EXPECT_EQ(2.0f, representation.scale());
 315   EXPECT_EQ(64, representation.pixel_width());
 316   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
 317                                    EnsureBitmapSize(bitmap_48, 64)));
 318 }
 319
 320 // There is no resource with exact size, but there is a smaller and a bigger
 321 // one. The bigger resource should be loaded.
 322 TEST_F(ExtensionIconImageTest, FallbackToBigger) {
 323   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 324   scoped_refptr<Extension> extension(CreateExtension(
 325       "extension_icon_image", Manifest::INVALID_LOCATION));
 326   ASSERT_TRUE(extension.get() != NULL);
 327
 328   gfx::ImageSkia default_icon = GetDefaultIcon();
 329
 330   // Load images we expect to find as representations in icon_image, so we
 331   // can later use them to validate icon_image.
 332   SkBitmap bitmap_24 = GetTestBitmap(extension.get(), "24.png", 24);
 333   ASSERT_FALSE(bitmap_24.empty());
 334
 335   IconImage image(profile.get(),
 336                   extension.get(),
 337                   extensions::IconsInfo::GetIcons(extension.get()),
 338                   17,
 339                   default_icon,
 340                   this);
 341
 342   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(1.0f);
 343
 344   WaitForImageLoad();
 345   EXPECT_EQ(1, ImageLoadedCount());
 346   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 347
 348   representation = image.image_skia().GetRepresentation(1.0f);
 349
 350   // We should have loaded the smallest bigger (resized) resource.
 351   EXPECT_EQ(1.0f, representation.scale());
 352   EXPECT_EQ(17, representation.pixel_width());
 353   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(),
 354                                    EnsureBitmapSize(bitmap_24, 17)));
 355 }
 356
 357 // If resource set is empty, |GetRepresentation| should synchronously return
 358 // default icon, without notifying observer of image change.
 359 TEST_F(ExtensionIconImageTest, NoResources) {
 360   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 361   scoped_refptr<Extension> extension(CreateExtension(
 362       "extension_icon_image", Manifest::INVALID_LOCATION));
 363   ASSERT_TRUE(extension.get() != NULL);
 364
 365   ExtensionIconSet empty_icon_set;
 366   gfx::ImageSkia default_icon = GetDefaultIcon();
 367
 368   const int kRequestedSize = 24;
 369   IconImage image(profile.get(),
 370                   extension.get(),
 371                   empty_icon_set,
 372                   kRequestedSize,
 373                   default_icon,
 374                   this);
 375
 376   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(1.0f);
 377   EXPECT_TRUE(gfx::BitmapsAreEqual(
 378       representation.sk_bitmap(),
 379       EnsureBitmapSize(
 380           default_icon.GetRepresentation(1.0f).sk_bitmap(),
 381           kRequestedSize)));
 382
 383   EXPECT_EQ(0, ImageLoadedCount());
 384   // We should have a default icon representation.
 385   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 386
 387   representation = image.image_skia().GetRepresentation(1.0f);
 388   EXPECT_TRUE(gfx::BitmapsAreEqual(
 389       representation.sk_bitmap(),
 390       EnsureBitmapSize(
 391           default_icon.GetRepresentation(1.0f).sk_bitmap(),
 392           kRequestedSize)));
 393 }
 394
 395 // If resource set is invalid, image load should be done asynchronously and
 396 // the observer should be notified when it's done. |GetRepresentation| should
 397 // return the default icon representation once image load is done.
 398 TEST_F(ExtensionIconImageTest, InvalidResource) {
 399   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 400   scoped_refptr<Extension> extension(CreateExtension(
 401       "extension_icon_image", Manifest::INVALID_LOCATION));
 402   ASSERT_TRUE(extension.get() != NULL);
 403
 404   const int kInvalidIconSize = 24;
 405   ExtensionIconSet invalid_icon_set;
 406   invalid_icon_set.Add(kInvalidIconSize, "invalid.png");
 407
 408   gfx::ImageSkia default_icon = GetDefaultIcon();
 409
 410   IconImage image(profile.get(),
 411                   extension.get(),
 412                   invalid_icon_set,
 413                   kInvalidIconSize,
 414                   default_icon,
 415                   this);
 416
 417   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(1.0f);
 418   EXPECT_TRUE(gfx::BitmapsAreEqual(
 419       representation.sk_bitmap(),
 420       CreateBlankBitmapForScale(kInvalidIconSize, ui::SCALE_FACTOR_100P)));
 421
 422   WaitForImageLoad();
 423   EXPECT_EQ(1, ImageLoadedCount());
 424   // We should have default icon representation now.
 425   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 426
 427   representation = image.image_skia().GetRepresentation(1.0f);
 428   EXPECT_TRUE(gfx::BitmapsAreEqual(
 429       representation.sk_bitmap(),
 430       EnsureBitmapSize(
 431           default_icon.GetRepresentation(1.0f).sk_bitmap(),
 432           kInvalidIconSize)));
 433 }
 434
 435 // Test that IconImage works with lazily (but synchronously) created default
 436 // icon when IconImage returns synchronously.
 437 TEST_F(ExtensionIconImageTest, LazyDefaultIcon) {
 438   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 439   scoped_refptr<Extension> extension(CreateExtension(
 440       "extension_icon_image", Manifest::INVALID_LOCATION));
 441   ASSERT_TRUE(extension.get() != NULL);
 442
 443   gfx::ImageSkia default_icon = GetDefaultIcon();
 444   gfx::ImageSkia lazy_default_icon(new MockImageSkiaSource(default_icon),
 445                                     default_icon.size());
 446
 447   ExtensionIconSet empty_icon_set;
 448
 449   const int kRequestedSize = 128;
 450   IconImage image(profile.get(),
 451                   extension.get(),
 452                   empty_icon_set,
 453                   kRequestedSize,
 454                   lazy_default_icon,
 455                   this);
 456
 457   ASSERT_FALSE(lazy_default_icon.HasRepresentation(1.0f));
 458
 459   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(1.0f);
 460
 461   // The resouce set is empty, so we should get the result right away.
 462   EXPECT_TRUE(lazy_default_icon.HasRepresentation(1.0f));
 463   EXPECT_TRUE(gfx::BitmapsAreEqual(
 464       representation.sk_bitmap(),
 465       EnsureBitmapSize(
 466           default_icon.GetRepresentation(1.0f).sk_bitmap(),
 467           kRequestedSize)));
 468
 469   // We should have a default icon representation.
 470   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 471 }
 472
 473 // Test that IconImage works with lazily (but synchronously) created default
 474 // icon when IconImage returns asynchronously.
 475 TEST_F(ExtensionIconImageTest, LazyDefaultIcon_AsyncIconImage) {
 476   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 477   scoped_refptr<Extension> extension(CreateExtension(
 478       "extension_icon_image", Manifest::INVALID_LOCATION));
 479   ASSERT_TRUE(extension.get() != NULL);
 480
 481   gfx::ImageSkia default_icon = GetDefaultIcon();
 482   gfx::ImageSkia lazy_default_icon(new MockImageSkiaSource(default_icon),
 483                                     default_icon.size());
 484
 485   const int kInvalidIconSize = 24;
 486   ExtensionIconSet invalid_icon_set;
 487   invalid_icon_set.Add(kInvalidIconSize, "invalid.png");
 488
 489   IconImage image(profile.get(),
 490                   extension.get(),
 491                   invalid_icon_set,
 492                   kInvalidIconSize,
 493                   lazy_default_icon,
 494                   this);
 495
 496   ASSERT_FALSE(lazy_default_icon.HasRepresentation(1.0f));
 497
 498   gfx::ImageSkiaRep representation = image.image_skia().GetRepresentation(1.0f);
 499
 500   WaitForImageLoad();
 501   EXPECT_EQ(1, ImageLoadedCount());
 502   // We should have default icon representation now.
 503   ASSERT_EQ(1u, image.image_skia().image_reps().size());
 504
 505   EXPECT_TRUE(lazy_default_icon.HasRepresentation(1.0f));
 506
 507   representation = image.image_skia().GetRepresentation(1.0f);
 508   EXPECT_TRUE(gfx::BitmapsAreEqual(
 509       representation.sk_bitmap(),
 510       EnsureBitmapSize(
 511           default_icon.GetRepresentation(1.0f).sk_bitmap(),
 512           kInvalidIconSize)));
 513 }
 514
 515 // Tests behavior of image created by IconImage after IconImage host goes
 516 // away. The image should still return loaded representations. If requested
 517 // representation was not loaded while IconImage host was around, transparent
 518 // representations should be returned.
 519 TEST_F(ExtensionIconImageTest, IconImageDestruction) {
 520   scoped_ptr<content::BrowserContext> profile(new TestingProfile());
 521   scoped_refptr<Extension> extension(CreateExtension(
 522       "extension_icon_image", Manifest::INVALID_LOCATION));
 523   ASSERT_TRUE(extension.get() != NULL);
 524
 525   gfx::ImageSkia default_icon = GetDefaultIcon();
 526
 527   // Load images we expect to find as representations in icon_image, so we
 528   // can later use them to validate icon_image.
 529   SkBitmap bitmap_16 = GetTestBitmap(extension.get(), "16.png", 16);
 530   ASSERT_FALSE(bitmap_16.empty());
 531
 532   scoped_ptr<IconImage> image(
 533       new IconImage(profile.get(),
 534                     extension.get(),
 535                     extensions::IconsInfo::GetIcons(extension.get()),
 536                     16,
 537                     default_icon,
 538                     this));
 539
 540   // Load an image representation.
 541   gfx::ImageSkiaRep representation =
 542       image->image_skia().GetRepresentation(1.0f);
 543
 544   WaitForImageLoad();
 545   EXPECT_EQ(1, ImageLoadedCount());
 546   ASSERT_EQ(1u, image->image_skia().image_reps().size());
 547
 548   // Stash loaded image skia, and destroy |image|.
 549   gfx::ImageSkia image_skia = image->image_skia();
 550   image.reset();
 551   extension = NULL;
 552
 553   // Image skia should still be able to get previously loaded representation.
 554   representation = image_skia.GetRepresentation(1.0f);
 555
 556   EXPECT_EQ(1.0f, representation.scale());
 557   EXPECT_EQ(16, representation.pixel_width());
 558   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_16));
 559
 560   // When requesting another representation, we should not crash and return some
 561   // image of the size. It could be blank or a rescale from the existing 1.0f
 562   // icon.
 563   representation = image_skia.GetRepresentation(2.0f);
 564
 565   EXPECT_EQ(16, representation.GetWidth());
 566   EXPECT_EQ(16, representation.GetHeight());
 567   EXPECT_EQ(2.0f, representation.scale());
 568 }