Always select best favicon bitmap

components/favicon/core/favicon_handler_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 "components/favicon/core/favicon_handler.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 768 matching lines @@
 // - On a page with <link rel="icon"> tags with no "sizes" information.
 // Selects the largest exact match. Note that a 32x32 PNG image is not a "true
 // exact match" on an OS which supports an 1x and 2x. A "true exact match" is
 // a .ico file with 16x16 and 32x32 bitmaps.
 TEST_F(FaviconHandlerMultipleFaviconsTest, ChooseLargestExactMatch) {
   EXPECT_EQ(32,
             DownloadTillDoneIgnoringHistory(IntVector{16, 24, 32, 48, 256}));
 }
 
 // Test that if there are several single resolution favicons to choose
-// from, the exact match is preferred even if it results in upsampling.
-TEST_F(FaviconHandlerMultipleFaviconsTest, ChooseExactMatchDespiteUpsampling) {
-  EXPECT_EQ(16, DownloadTillDoneIgnoringHistory(IntVector{16, 24, 48, 256}));
+// from, the exact match is not preferred if it results in upsampling.
+TEST_F(FaviconHandlerMultipleFaviconsTest, ChooseBestDespiteSmallerExactMatch) {
+  EXPECT_EQ(48, DownloadTillDoneIgnoringHistory(IntVector{16, 24, 48, 256}));
 }
 
 // Test that favicons which need to be upsampled a little or downsampled
 // a little are preferred over huge favicons.
 TEST_F(FaviconHandlerMultipleFaviconsTest,
        ChooseMinorDownsamplingOverHugeIcon) {
   EXPECT_EQ(48, DownloadTillDoneIgnoringHistory(IntVector{256, 48}));
 }
 
 TEST_F(FaviconHandlerMultipleFaviconsTest, ChooseMinorUpsamplingOverHugeIcon) {
@@ skipping 78 matching lines @@
 TEST_F(FaviconHandlerTest, FaviconInvalidURL) {
   const GURL kInvalidFormatURL("invalid");
   ASSERT_TRUE(kInvalidFormatURL.is_empty());
 
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, _, _, _)).Times(0);
 
   RunHandlerWithSimpleFaviconCandidates({kInvalidFormatURL});
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
 }
 
-TEST_F(FaviconHandlerTest, TestSortFavicon) {
-  const std::vector<favicon::FaviconURL> kSourceIconURLs{
-      FaviconURL(GURL("http://www.google.com/a"), FAVICON,
-                 {gfx::Size(1, 1), gfx::Size(17, 17)}),
-      FaviconURL(GURL("http://www.google.com/b"), FAVICON,
-                 {gfx::Size(1024, 1024), gfx::Size(512, 512)}),
-      FaviconURL(GURL("http://www.google.com/c"), FAVICON,
-                 {gfx::Size(16, 16), gfx::Size(14, 14)}),
-      FaviconURL(GURL("http://www.google.com/d"), FAVICON, kEmptySizes),
-      FaviconURL(GURL("http://www.google.com/e"), FAVICON, kEmptySizes)};
-
-  std::unique_ptr<FaviconHandler> handler = RunHandlerWithCandidates(
-      FaviconDriverObserver::NON_TOUCH_LARGEST, kSourceIconURLs);
-
-  struct ExpectedResult {
-    // The favicon's index in kSourceIconURLs.
-    size_t favicon_index;
-    // Width of largest bitmap.
-    int width;
-  } results[] = {
-      // First is icon2, though its size larger than maximal.
-      {1, 1024},
-      // Second is icon1
-      // The 17x17 is largest.
-      {0, 17},
-      // Third is icon3.
-      // The 16x16 is largest.
-      {2, 16},
-      // The rest of bitmaps come in order, there is no "sizes" attribute.
-      {3, -1},
-      {4, -1},
-  };
-  const std::vector<FaviconURL>& icons = handler->image_urls();
-  ASSERT_EQ(5u, icons.size());
-  for (size_t i = 0; i < icons.size(); ++i) {
-    EXPECT_EQ(kSourceIconURLs[results[i].favicon_index].icon_url,
-              icons[i].icon_url);
-    if (results[i].width != -1)
-      EXPECT_EQ(results[i].width, icons[i].icon_sizes[0].width());
-  }
-}
-
 TEST_F(FaviconHandlerTest, TestDownloadLargestFavicon) {
   // Names represent the bitmap sizes per icon.
   const GURL kIconURL1024_512("http://www.google.com/a");
   const GURL kIconURL15_14("http://www.google.com/b");
   const GURL kIconURL16_512("http://www.google.com/c");
   const GURL kIconURLWithoutSize1("http://www.google.com/d");
   const GURL kIconURLWithoutSize2("http://www.google.com/e");
 
   RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_LARGEST,
@@ skipping 30 matching lines @@
 
   RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_LARGEST,
       {FaviconURL(kIconURL1, FAVICON, {gfx::Size(15, 15)}),
        FaviconURL(kIconURL2, FAVICON, {gfx::Size(14, 14), gfx::Size(16, 16)})});
 
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL2));
 }
 
 TEST_F(FaviconHandlerTest, TestFaviconWasScaledAfterDownload) {
-  const int kMaximalSize = FaviconHandler::GetMaximalIconSize(FAVICON);
+#if defined(OS_IOS)
+  const int kMaximalSize = 144;
+#else
+  const int kMaximalSize = 192;
+#endif
 
   const GURL kIconURL1("http://www.google.com/b");
   const GURL kIconURL2("http://www.google.com/c");
 
   const int kOriginalSize1 = kMaximalSize + 1;
   const int kOriginalSize2 = kMaximalSize + 2;
 
   delegate_.fake_downloader().AddWithOriginalSizes(
       kIconURL1, IntVector{kMaximalSize}, IntVector{kOriginalSize1});
   delegate_.fake_downloader().AddWithOriginalSizes(
       kIconURL2, IntVector{kMaximalSize}, IntVector{kOriginalSize2});
 
-  // Verify the largest bitmap was selected although it was scaled down to
-  // maximal size and smaller than |kIconURL1| now.
+  // Verify the best bitmap was selected although it was scaled down to maximal
+  // size and smaller than |kIconURL2| now.
   EXPECT_CALL(delegate_,
-              OnFaviconUpdated(_, _, kIconURL2, _,
+              OnFaviconUpdated(_, _, kIconURL1, _,
                                ImageSizeIs(kMaximalSize, kMaximalSize)));
 
   RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_LARGEST,
       {FaviconURL(kIconURL1, FAVICON,
                   SizeVector{gfx::Size(kOriginalSize1, kOriginalSize1)}),
        FaviconURL(kIconURL2, FAVICON,
                   SizeVector{gfx::Size(kOriginalSize2, kOriginalSize2)})});
 
-  EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL2));
+  EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL1));
 }
 
 // Test that if several icons are downloaded because the icons are smaller than
 // expected that OnFaviconUpdated() is called with the largest downloaded
 // bitmap.
 TEST_F(FaviconHandlerTest, TestKeepDownloadedLargestFavicon) {
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(_, _, kIconURL12x12, _, ImageSizeIs(12, 12)));
 
   RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_LARGEST,
       {FaviconURL(kIconURL10x10, FAVICON, SizeVector{gfx::Size(16, 16)}),
        FaviconURL(kIconURL12x12, FAVICON, SizeVector{gfx::Size(15, 15)}),
        FaviconURL(kIconURL16x16, FAVICON, kEmptySizes)});
 }
 
 }  // namespace
 }  // namespace favicon