Sync bookmark app icon urls and sizes, and download icons for new apps.

chrome/browser/extensions/bookmark_app_helper_unittest.cc

 // Copyright 2014 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/bookmark_app_helper.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_service_test_base.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/web_contents_tester.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/skia_util.h"
 
+namespace extensions {
+
 namespace {
 
 const char kAppUrl[] = "http://www.chromium.org";
 const char kAlternativeAppUrl[] = "http://www.notchromium.org";
 const char kAppTitle[] = "Test title";
 const char kAppShortName[] = "Test short name";
 const char kAlternativeAppTitle[] = "Different test title";
 const char kAppDescription[] = "Test description";
 const char kAppIcon1[] = "fav1.png";
 const char kAppIcon2[] = "fav2.png";
 const char kAppIcon3[] = "fav3.png";
+const char kAppIconURL1[] = "http://foo.com/1.png";
+const char kAppIconURL2[] = "http://foo.com/2.png";
+const char kAppIconURL3[] = "http://foo.com/3.png";
+const char kAppIconURL4[] = "http://foo.com/4.png";
 
 const int kIconSizeTiny = extension_misc::EXTENSION_ICON_BITTY;
 const int kIconSizeSmall = extension_misc::EXTENSION_ICON_SMALL;
 const int kIconSizeMedium = extension_misc::EXTENSION_ICON_MEDIUM;
 const int kIconSizeLarge = extension_misc::EXTENSION_ICON_LARGE;
+const int kIconSizeUnsupported = 123;
 
 class BookmarkAppHelperTest : public testing::Test {
  public:
   BookmarkAppHelperTest() {}
   ~BookmarkAppHelperTest() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkAppHelperTest);
 };
 
@@ skipping 27 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BookmarkAppHelperExtensionServiceTest);
 };
 
 SkBitmap CreateSquareBitmapWithColor(int size, SkColor color) {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(size, size);
   bitmap.eraseColor(color);
   return bitmap;
 }
 
+BookmarkAppHelper::BitmapAndSource CreateSquareBitmapAndSourceWithColor(
+    int size,
+    SkColor color) {
+  return BookmarkAppHelper::BitmapAndSource(
+      GURL(), CreateSquareBitmapWithColor(size, color));
+}
+
+void ValidateBitmapSizeAndColor(SkBitmap bitmap, int size, SkColor color) {
+  // Obtain pixel lock to access pixels.
+  SkAutoLockPixels lock(bitmap);
+  EXPECT_EQ(color, bitmap.getColor(0, 0));
+  EXPECT_EQ(size, bitmap.width());
+  EXPECT_EQ(size, bitmap.height());
+}
+
 WebApplicationInfo::IconInfo CreateIconInfoWithBitmap(int size, SkColor color) {
   WebApplicationInfo::IconInfo icon_info;
   icon_info.width = size;
   icon_info.height = size;
   icon_info.data = CreateSquareBitmapWithColor(size, color);
   return icon_info;
 }
 
+void ValidateAllIconsWithURLsArePresent(const WebApplicationInfo& info_to_check,
+                                        const WebApplicationInfo& other_info) {
+  for (const auto& icon : info_to_check.icons) {
+    if (!icon.url.is_empty()) {
+      bool found = false;
+      for (const auto& other_icon : info_to_check.icons) {
+        if (other_icon.url == icon.url && other_icon.width == icon.width) {
+          found = true;
+          break;
+        }
+      }
+      EXPECT_TRUE(found);
+    }
+  }
+}
+
 void ValidateWebApplicationInfo(base::Closure callback,
-                                const WebApplicationInfo& expected,
-                                const WebApplicationInfo& actual) {
-  EXPECT_EQ(expected.title, actual.title);
-  EXPECT_EQ(expected.description, actual.description);
-  EXPECT_EQ(expected.app_url, actual.app_url);
-  EXPECT_EQ(expected.icons.size(), actual.icons.size());
-  for (size_t i = 0; i < expected.icons.size(); ++i) {
-    EXPECT_EQ(expected.icons[i].width, actual.icons[i].width);
-    EXPECT_EQ(expected.icons[i].height, actual.icons[i].height);
-    EXPECT_EQ(expected.icons[i].url, actual.icons[i].url);
-    EXPECT_TRUE(
-        gfx::BitmapsAreEqual(expected.icons[i].data, actual.icons[i].data));
-  }
+                                const WebApplicationInfo& original,
+                                const WebApplicationInfo& newly_made) {
+  EXPECT_EQ(original.title, newly_made.title);
+  EXPECT_EQ(original.description, newly_made.description);
+  EXPECT_EQ(original.app_url, newly_made.app_url);
+  // There should be 6 icons, as there are three sizes which need to be
+  // generated, and each will generate a 1x and 2x icon.
+  EXPECT_EQ(6u, newly_made.icons.size());
   callback.Run();
 }
 
 }  // namespace
 
-namespace extensions {
-
 class TestBookmarkAppHelper : public BookmarkAppHelper {
  public:
   TestBookmarkAppHelper(ExtensionService* service,
                         WebApplicationInfo web_app_info,
                         content::WebContents* contents)
       : BookmarkAppHelper(service->profile(), web_app_info, contents) {}
 
   ~TestBookmarkAppHelper() override {}
 
   void CreationComplete(const extensions::Extension* extension,
@@ skipping 94 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(helper.extension());
   const Extension* extension =
       service_->GetInstalledExtension(helper.extension()->id());
   EXPECT_TRUE(extension);
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
   EXPECT_TRUE(extension->from_bookmark());
   EXPECT_EQ(kAppTitle, extension->name());
   EXPECT_EQ(kAppDescription, extension->description());
   EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
-  // The tiny icon should have been removed and only the generated ones used.
-  EXPECT_TRUE(
+  EXPECT_FALSE(
       IconsInfo::GetIconResource(extension, kIconSizeTiny,
                                  ExtensionIconSet::MATCH_EXACTLY).empty());
   EXPECT_FALSE(
       IconsInfo::GetIconResource(
           extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY).empty());
   EXPECT_FALSE(
       IconsInfo::GetIconResource(extension,
                                  kIconSizeSmall * 2,
                                  ExtensionIconSet::MATCH_EXACTLY).empty());
   EXPECT_FALSE(
@@ skipping 37 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   {
     EXPECT_EQ(1u, registry()->enabled_extensions().size());
     const Extension* extension =
         registry()->enabled_extensions().begin()->get();
     EXPECT_TRUE(extension->from_bookmark());
     EXPECT_EQ(kAlternativeAppTitle, extension->name());
     EXPECT_EQ(kAppDescription, extension->description());
     EXPECT_EQ(GURL(kAppUrl), AppLaunchInfo::GetLaunchWebURL(extension));
-    EXPECT_TRUE(extensions::IconsInfo::GetIconResource(
-                    extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY)
-                    .empty());
+    EXPECT_FALSE(extensions::IconsInfo::GetIconResource(
+                     extension, kIconSizeSmall, ExtensionIconSet::MATCH_EXACTLY)
+                     .empty());
     EXPECT_FALSE(extensions::IconsInfo::GetIconResource(
                      extension, kIconSizeLarge, ExtensionIconSet::MATCH_EXACTLY)
                      .empty());
   }
 }
 
 TEST_F(BookmarkAppHelperExtensionServiceTest, GetWebApplicationInfo) {
   WebApplicationInfo web_app_info;
   web_app_info.app_url = GURL(kAppUrl);
   web_app_info.title = base::UTF8ToUTF16(kAppTitle);
   web_app_info.description = base::UTF8ToUTF16(kAppDescription);
 
-  web_app_info.icons.push_back(
-      CreateIconInfoWithBitmap(kIconSizeSmall, SK_ColorRED));
-  web_app_info.icons.push_back(
-      CreateIconInfoWithBitmap(kIconSizeLarge, SK_ColorRED));
-
   extensions::CreateOrUpdateBookmarkApp(service_, &web_app_info);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1u, registry()->enabled_extensions().size());
   base::RunLoop run_loop;
   extensions::GetWebApplicationInfoFromApp(
       profile_.get(), registry()->enabled_extensions().begin()->get(),
       base::Bind(&ValidateWebApplicationInfo, run_loop.QuitClosure(),
                  web_app_info));
   run_loop.Run();
 }
 
+TEST_F(BookmarkAppHelperExtensionServiceTest, LinkedAppIconsAreNotChanged) {
+  WebApplicationInfo web_app_info;
+
+  // Add two icons with a URL and bitmap, two icons with just a bitmap, an
+  // icon with just URL and an icon in an unsupported size with just a URL.
+  WebApplicationInfo::IconInfo icon_info =
+      CreateIconInfoWithBitmap(kIconSizeSmall, SK_ColorRED);
+  icon_info.url = GURL(kAppIconURL1);
+  web_app_info.icons.push_back(icon_info);
+
+  icon_info = CreateIconInfoWithBitmap(kIconSizeMedium, SK_ColorRED);
+  icon_info.url = GURL(kAppIconURL2);
+  web_app_info.icons.push_back(icon_info);
+
+  icon_info.data = SkBitmap();
+  icon_info.url = GURL(kAppIconURL3);
+  web_app_info.icons.push_back(icon_info);
+
+  icon_info.url = GURL(kAppIconURL4);
+  web_app_info.icons.push_back(icon_info);
+
+  icon_info = CreateIconInfoWithBitmap(kIconSizeLarge, SK_ColorRED);
+  web_app_info.icons.push_back(icon_info);
+
+  icon_info = CreateIconInfoWithBitmap(kIconSizeUnsupported, SK_ColorRED);
+  web_app_info.icons.push_back(icon_info);
+
+  // Now run the resizing and generation into a new web app info.
+  WebApplicationInfo new_web_app_info;
+  std::map<int, BookmarkAppHelper::BitmapAndSource> size_map =
+      BookmarkAppHelper::ResizeIconsAndGenerateMissing(
+          std::vector<BookmarkAppHelper::BitmapAndSource>(), &new_web_app_info);
+
+  // Now check that the linked app icons (i.e. those with URLs) are matching in
+  // both lists.
+  ValidateAllIconsWithURLsArePresent(web_app_info, new_web_app_info);
+  ValidateAllIconsWithURLsArePresent(new_web_app_info, web_app_info);

[calamity, 2015/04/28 06:56:35]

You could just use a counter in ValidateAllIconsWithURLsArePresent() to count
the number of matching icons and check that found == info_to_check.icons.size()
and info_to_check.icons.size() == other_info.icons.size()

[benwells, 2015/04/28 08:10:56]

As discussed there could be icons without URLs.

+}
+
 TEST_F(BookmarkAppHelperTest, UpdateWebAppInfoFromManifest) {
   WebApplicationInfo web_app_info;
   web_app_info.title = base::UTF8ToUTF16(kAlternativeAppTitle);
   web_app_info.app_url = GURL(kAlternativeAppUrl);
   WebApplicationInfo::IconInfo info;
   info.url = GURL(kAppIcon1);
   web_app_info.icons.push_back(info);
 
   content::Manifest manifest;
   manifest.start_url = GURL(kAppUrl);
@@ skipping 20 matching lines @@
   manifest.icons.push_back(icon);
 
   BookmarkAppHelper::UpdateWebAppInfoFromManifest(manifest, &web_app_info);
   EXPECT_EQ(base::UTF8ToUTF16(kAppTitle), web_app_info.title);
 
   EXPECT_EQ(2u, web_app_info.icons.size());
   EXPECT_EQ(GURL(kAppIcon2), web_app_info.icons[0].url);
   EXPECT_EQ(GURL(kAppIcon3), web_app_info.icons[1].url);
 }
 
+TEST_F(BookmarkAppHelperTest, ConstrainBitmapsToSizes) {
+  std::set<int> desired_sizes;
+  desired_sizes.insert(16);
+  desired_sizes.insert(32);
+  desired_sizes.insert(128);
+  desired_sizes.insert(256);
+
+  {
+    std::vector<BookmarkAppHelper::BitmapAndSource> bitmaps;
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(16, SK_ColorRED));
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(32, SK_ColorGREEN));
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(48, SK_ColorBLUE));
+    bitmaps.push_back(
+        CreateSquareBitmapAndSourceWithColor(144, SK_ColorYELLOW));
+
+    std::map<int, BookmarkAppHelper::BitmapAndSource> results(
+        BookmarkAppHelper::ConstrainBitmapsToSizes(bitmaps, desired_sizes));
+
+    EXPECT_EQ(3u, results.size());
+    ValidateBitmapSizeAndColor(results[16].bitmap, 16, SK_ColorRED);
+    ValidateBitmapSizeAndColor(results[32].bitmap, 32, SK_ColorGREEN);
+    ValidateBitmapSizeAndColor(results[128].bitmap, 128, SK_ColorYELLOW);
+  }
+  {
+    std::vector<BookmarkAppHelper::BitmapAndSource> bitmaps;
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(512, SK_ColorRED));
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(18, SK_ColorGREEN));
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(33, SK_ColorBLUE));
+    bitmaps.push_back(CreateSquareBitmapAndSourceWithColor(17, SK_ColorYELLOW));
+
+    std::map<int, BookmarkAppHelper::BitmapAndSource> results(
+        BookmarkAppHelper::ConstrainBitmapsToSizes(bitmaps, desired_sizes));
+
+    EXPECT_EQ(3u, results.size());
+    ValidateBitmapSizeAndColor(results[16].bitmap, 16, SK_ColorYELLOW);
+    ValidateBitmapSizeAndColor(results[32].bitmap, 32, SK_ColorBLUE);
+    ValidateBitmapSizeAndColor(results[256].bitmap, 256, SK_ColorRED);
+  }
+}
+
 TEST_F(BookmarkAppHelperTest, IsValidBookmarkAppUrl) {
   EXPECT_TRUE(IsValidBookmarkAppUrl(GURL("https://www.chromium.org")));
   EXPECT_TRUE(IsValidBookmarkAppUrl(GURL("http://www.chromium.org/path")));
   EXPECT_FALSE(IsValidBookmarkAppUrl(GURL("ftp://www.chromium.org")));
   EXPECT_FALSE(IsValidBookmarkAppUrl(GURL("chrome://flags")));
 }
 
 }  // namespace extensions