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