src/chrome/browser/extensions/bookmark_app_helper_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 "chrome/browser/extensions/bookmark_app_helper.h"
   6
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "chrome/browser/extensions/extension_service.h"
   9 #include "chrome/browser/extensions/extension_service_test_base.h"
  10 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
  11 #include "chrome/test/base/testing_profile.h"
  12 #include "content/public/browser/render_process_host.h"
  13 #include "content/public/browser/web_contents.h"
  14 #include "content/public/test/web_contents_tester.h"
  15 #include "extensions/browser/extension_registry.h"
  16 #include "extensions/common/constants.h"
  17 #include "extensions/common/extension_icon_set.h"
  18 #include "extensions/common/manifest_handlers/icons_handler.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20 #include "third_party/skia/include/core/SkBitmap.h"
  21 #include "ui/gfx/skia_util.h"
  22
  23 namespace {
  24
  25 const char kAppUrl[] = "http://www.chromium.org";
  26 const char kAppTitle[] = "Test title";
  27 const char kAlternativeAppTitle[] = "Different test title";
  28 const char kAppDescription[] = "Test description";
  29
  30 const int kIconSizeTiny = extension_misc::EXTENSION_ICON_BITTY;
  31 const int kIconSizeSmall = extension_misc::EXTENSION_ICON_SMALL;
  32 const int kIconSizeMedium = extension_misc::EXTENSION_ICON_MEDIUM;
  33 const int kIconSizeLarge = extension_misc::EXTENSION_ICON_LARGE;
  34
  35 class BookmarkAppHelperTest : public testing::Test {
  36  public:
  37   BookmarkAppHelperTest() {}
  38   virtual ~BookmarkAppHelperTest() {}
  39
  40  private:
  41   DISALLOW_COPY_AND_ASSIGN(BookmarkAppHelperTest);
  42 };
  43
  44 class BookmarkAppHelperExtensionServiceTest
  45     : public extensions::ExtensionServiceTestBase {
  46  public:
  47   BookmarkAppHelperExtensionServiceTest() {}
  48   virtual ~BookmarkAppHelperExtensionServiceTest() {}
  49
  50   virtual void SetUp() OVERRIDE {
  51     extensions::ExtensionServiceTestBase::SetUp();
  52     InitializeEmptyExtensionService();
  53     service_->Init();
  54     EXPECT_EQ(0u, service_->extensions()->size());
  55   }
  56
  57   virtual void TearDown() OVERRIDE {
  58     ExtensionServiceTestBase::TearDown();
  59     for (content::RenderProcessHost::iterator i(
  60              content::RenderProcessHost::AllHostsIterator());
  61          !i.IsAtEnd();
  62          i.Advance()) {
  63       content::RenderProcessHost* host = i.GetCurrentValue();
  64       if (Profile::FromBrowserContext(host->GetBrowserContext()) ==
  65           profile_.get())
  66         host->Cleanup();
  67     }
  68   }
  69
  70  private:
  71   DISALLOW_COPY_AND_ASSIGN(BookmarkAppHelperExtensionServiceTest);
  72 };
  73
  74 SkBitmap CreateSquareBitmapWithColor(int size, SkColor color) {
  75   SkBitmap bitmap;
  76   bitmap.allocN32Pixels(size, size);
  77   bitmap.eraseColor(color);
  78   return bitmap;
  79 }
  80
  81 void ValidateBitmapSizeAndColor(SkBitmap bitmap, int size, SkColor color) {
  82   // Obtain pixel lock to access pixels.
  83   SkAutoLockPixels lock(bitmap);
  84   EXPECT_EQ(color, bitmap.getColor(0, 0));
  85   EXPECT_EQ(size, bitmap.width());
  86   EXPECT_EQ(size, bitmap.height());
  87 }
  88
  89 WebApplicationInfo::IconInfo CreateIconInfoWithBitmap(int size, SkColor color) {
  90   WebApplicationInfo::IconInfo icon_info;
  91   icon_info.width = size;
  92   icon_info.height = size;
  93   icon_info.data = CreateSquareBitmapWithColor(size, color);
  94   return icon_info;
  95 }
  96
  97 void ValidateWebApplicationInfo(base::Closure callback,
  98                                 const WebApplicationInfo& expected,
  99                                 const WebApplicationInfo& actual) {
 100   EXPECT_EQ(expected.title, actual.title);
 101   EXPECT_EQ(expected.description, actual.description);
 102   EXPECT_EQ(expected.app_url, actual.app_url);
 103   EXPECT_EQ(expected.icons.size(), actual.icons.size());
 104   for (size_t i = 0; i < expected.icons.size(); ++i) {
 105     EXPECT_EQ(expected.icons[i].width, actual.icons[i].width);
 106     EXPECT_EQ(expected.icons[i].height, actual.icons[i].height);
 107     EXPECT_EQ(expected.icons[i].url, actual.icons[i].url);
 108     EXPECT_TRUE(
 109         gfx::BitmapsAreEqual(expected.icons[i].data, actual.icons[i].data));
 110   }
 111   callback.Run();
 112 }
 113
 114 }  // namespace
 115
 116 namespace extensions {
 117
 118 class TestBookmarkAppHelper : public BookmarkAppHelper {
 119  public:
 120   TestBookmarkAppHelper(ExtensionService* service,
 121                         WebApplicationInfo web_app_info,
 122                         content::WebContents* contents)
 123       : BookmarkAppHelper(service, web_app_info, contents) {}
 124
 125   virtual ~TestBookmarkAppHelper() {}
 126
 127   void CreationComplete(const extensions::Extension* extension,
 128                         const WebApplicationInfo& web_app_info) {
 129     extension_ = extension;
 130   }
 131
 132   void CompleteIconDownload(
 133       bool success,
 134       const std::map<GURL, std::vector<SkBitmap> >& bitmaps) {
 135     BookmarkAppHelper::OnIconsDownloaded(success, bitmaps);
 136   }
 137
 138   const Extension* extension() { return extension_; }
 139
 140  private:
 141   const Extension* extension_;
 142
 143   DISALLOW_COPY_AND_ASSIGN(TestBookmarkAppHelper);
 144 };
 145
 146 TEST_F(BookmarkAppHelperExtensionServiceTest, CreateBookmarkApp) {
 147   WebApplicationInfo web_app_info;
 148   web_app_info.app_url = GURL(kAppUrl);
 149   web_app_info.title = base::UTF8ToUTF16(kAppTitle);
 150   web_app_info.description = base::UTF8ToUTF16(kAppDescription);
 151
 152   scoped_ptr<content::WebContents> contents(
 153       content::WebContentsTester::CreateTestWebContents(profile_.get(), NULL));
 154   TestBookmarkAppHelper helper(service_, web_app_info, contents.get());
 155   helper.Create(base::Bind(&TestBookmarkAppHelper::CreationComplete,
 156                            base::Unretained(&helper)));
 157
 158   std::map<GURL, std::vector<SkBitmap> > icon_map;
 159   icon_map[GURL(kAppUrl)].push_back(
 160       CreateSquareBitmapWithColor(kIconSizeSmall, SK_ColorRED));
 161   helper.CompleteIconDownload(true, icon_map);
 162
 163   base::RunLoop().RunUntilIdle();
 164   EXPECT_TRUE(helper.extension());
 165   const Extension* extension =
 166       service_->GetInstalledExtension(helper.extension()->id());
 167   EXPECT_TRUE(extension);
 168   EXPECT_EQ(1u, service_->extensions()->size());
 169   EXPECT_TRUE(extension->from_bookmark());
 170   EXPECT_EQ(kAppTitle, extension->name());
 171   EXPECT_EQ(kAppDescription, extension->description());
 172   EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
 173   EXPECT_FALSE(
 174       IconsInfo::GetIconResource(
 175           extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY).empty());
 176 }
 177
 178 TEST_F(BookmarkAppHelperExtensionServiceTest, CreateBookmarkAppNoContents) {
 179   WebApplicationInfo web_app_info;
 180   web_app_info.app_url = GURL(kAppUrl);
 181   web_app_info.title = base::UTF8ToUTF16(kAppTitle);
 182   web_app_info.description = base::UTF8ToUTF16(kAppDescription);
 183   web_app_info.icons.push_back(
 184       CreateIconInfoWithBitmap(kIconSizeTiny, SK_ColorRED));
 185
 186   TestBookmarkAppHelper helper(service_, web_app_info, NULL);
 187   helper.Create(base::Bind(&TestBookmarkAppHelper::CreationComplete,
 188                            base::Unretained(&helper)));
 189
 190   base::RunLoop().RunUntilIdle();
 191   EXPECT_TRUE(helper.extension());
 192   const Extension* extension =
 193       service_->GetInstalledExtension(helper.extension()->id());
 194   EXPECT_TRUE(extension);
 195   EXPECT_EQ(1u, service_->extensions()->size());
 196   EXPECT_TRUE(extension->from_bookmark());
 197   EXPECT_EQ(kAppTitle, extension->name());
 198   EXPECT_EQ(kAppDescription, extension->description());
 199   EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
 200   EXPECT_FALSE(
 201       IconsInfo::GetIconResource(
 202           extension, kIconSizeTiny, ExtensionIconSet::MATCH_EXACTLY).empty());
 203   EXPECT_FALSE(
 204       IconsInfo::GetIconResource(
 205           extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY).empty());
 206   EXPECT_FALSE(
 207       IconsInfo::GetIconResource(extension,
 208                                  kIconSizeSmall * 2,
 209                                  ExtensionIconSet::MATCH_EXACTLY).empty());
 210   EXPECT_FALSE(
 211       IconsInfo::GetIconResource(
 212           extension, kIconSizeMedium, ExtensionIconSet::MATCH_EXACTLY).empty());
 213   EXPECT_FALSE(
 214       IconsInfo::GetIconResource(extension,
 215                                  kIconSizeMedium * 2,
 216                                  ExtensionIconSet::MATCH_EXACTLY).empty());
 217 }
 218
 219 TEST_F(BookmarkAppHelperExtensionServiceTest, CreateAndUpdateBookmarkApp) {
 220   EXPECT_EQ(0u, registry()->enabled_extensions().size());
 221   WebApplicationInfo web_app_info;
 222   web_app_info.app_url = GURL(kAppUrl);
 223   web_app_info.title = base::UTF8ToUTF16(kAppTitle);
 224   web_app_info.description = base::UTF8ToUTF16(kAppDescription);
 225   web_app_info.icons.push_back(
 226       CreateIconInfoWithBitmap(kIconSizeSmall, SK_ColorRED));
 227
 228   extensions::CreateOrUpdateBookmarkApp(service_, web_app_info);
 229   base::RunLoop().RunUntilIdle();
 230
 231   {
 232     EXPECT_EQ(1u, registry()->enabled_extensions().size());
 233     const Extension* extension = service_->extensions()->begin()->get();
 234     EXPECT_TRUE(extension->from_bookmark());
 235     EXPECT_EQ(kAppTitle, extension->name());
 236     EXPECT_EQ(kAppDescription, extension->description());
 237     EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
 238     EXPECT_FALSE(extensions::IconsInfo::GetIconResource(
 239                      extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY)
 240                      .empty());
 241   }
 242
 243   web_app_info.title = base::UTF8ToUTF16(kAlternativeAppTitle);
 244   web_app_info.icons[0] = CreateIconInfoWithBitmap(kIconSizeLarge, SK_ColorRED);
 245
 246   extensions::CreateOrUpdateBookmarkApp(service_, web_app_info);
 247   base::RunLoop().RunUntilIdle();
 248
 249   {
 250     EXPECT_EQ(1u, registry()->enabled_extensions().size());
 251     const Extension* extension = service_->extensions()->begin()->get();
 252     EXPECT_TRUE(extension->from_bookmark());
 253     EXPECT_EQ(kAlternativeAppTitle, extension->name());
 254     EXPECT_EQ(kAppDescription, extension->description());
 255     EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
 256     EXPECT_TRUE(extensions::IconsInfo::GetIconResource(
 257                     extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY)
 258                     .empty());
 259     EXPECT_FALSE(extensions::IconsInfo::GetIconResource(
 260                      extension, kIconSizeLarge, ExtensionIconSet::MATCH_EXACTLY)
 261                      .empty());
 262   }
 263 }
 264
 265 TEST_F(BookmarkAppHelperExtensionServiceTest, GetWebApplicationInfo) {
 266   WebApplicationInfo web_app_info;
 267   web_app_info.app_url = GURL(kAppUrl);
 268   web_app_info.title = base::UTF8ToUTF16(kAppTitle);
 269   web_app_info.description = base::UTF8ToUTF16(kAppDescription);
 270
 271   web_app_info.icons.push_back(
 272       CreateIconInfoWithBitmap(kIconSizeSmall, SK_ColorRED));
 273   web_app_info.icons.push_back(
 274       CreateIconInfoWithBitmap(kIconSizeLarge, SK_ColorRED));
 275
 276   extensions::CreateOrUpdateBookmarkApp(service_, web_app_info);
 277   base::RunLoop().RunUntilIdle();
 278
 279   EXPECT_EQ(1u, registry()->enabled_extensions().size());
 280   base::RunLoop run_loop;
 281   extensions::GetWebApplicationInfoFromApp(
 282       profile_.get(),
 283       service_->extensions()->begin()->get(),
 284       base::Bind(
 285           &ValidateWebApplicationInfo, run_loop.QuitClosure(), web_app_info));
 286   run_loop.Run();
 287 }
 288
 289 TEST_F(BookmarkAppHelperTest, ConstrainBitmapsToSizes) {
 290   std::set<int> desired_sizes;
 291   desired_sizes.insert(16);
 292   desired_sizes.insert(32);
 293   desired_sizes.insert(128);
 294   desired_sizes.insert(256);
 295
 296   {
 297     std::vector<SkBitmap> bitmaps;
 298     bitmaps.push_back(CreateSquareBitmapWithColor(16, SK_ColorRED));
 299     bitmaps.push_back(CreateSquareBitmapWithColor(32, SK_ColorGREEN));
 300     bitmaps.push_back(CreateSquareBitmapWithColor(48, SK_ColorBLUE));
 301     bitmaps.push_back(CreateSquareBitmapWithColor(144, SK_ColorYELLOW));
 302
 303     std::map<int, SkBitmap> results(
 304         BookmarkAppHelper::ConstrainBitmapsToSizes(bitmaps, desired_sizes));
 305
 306     EXPECT_EQ(3u, results.size());
 307     ValidateBitmapSizeAndColor(results[16], 16, SK_ColorRED);
 308     ValidateBitmapSizeAndColor(results[32], 32, SK_ColorGREEN);
 309     ValidateBitmapSizeAndColor(results[128], 128, SK_ColorYELLOW);
 310   }
 311   {
 312     std::vector<SkBitmap> bitmaps;
 313     bitmaps.push_back(CreateSquareBitmapWithColor(512, SK_ColorRED));
 314     bitmaps.push_back(CreateSquareBitmapWithColor(18, SK_ColorGREEN));
 315     bitmaps.push_back(CreateSquareBitmapWithColor(33, SK_ColorBLUE));
 316     bitmaps.push_back(CreateSquareBitmapWithColor(17, SK_ColorYELLOW));
 317
 318     std::map<int, SkBitmap> results(
 319         BookmarkAppHelper::ConstrainBitmapsToSizes(bitmaps, desired_sizes));
 320
 321     EXPECT_EQ(3u, results.size());
 322     ValidateBitmapSizeAndColor(results[16], 16, SK_ColorYELLOW);
 323     ValidateBitmapSizeAndColor(results[32], 32, SK_ColorBLUE);
 324     ValidateBitmapSizeAndColor(results[256], 256, SK_ColorRED);
 325   }
 326 }
 327
 328 TEST_F(BookmarkAppHelperTest, IsValidBookmarkAppUrl) {
 329   EXPECT_TRUE(IsValidBookmarkAppUrl(GURL("https://www.chromium.org")));
 330   EXPECT_TRUE(IsValidBookmarkAppUrl(GURL("http://www.chromium.org/path")));
 331   EXPECT_FALSE(IsValidBookmarkAppUrl(GURL("ftp://www.chromium.org")));
 332   EXPECT_FALSE(IsValidBookmarkAppUrl(GURL("chrome://flags")));
 333 }
 334
 335 }  // namespace extensions