Treat touch icons just like non-touch icons on mobile

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 <map>
 #include <memory>
@@ skipping 552 matching lines @@
   const GURL kIconURLReturning500("http://www.google.com/500.png");
 
   delegate_.fake_downloader().AddError(kIconURLReturning500, 500);
 
   favicon_service_.fake()->Store(
       kPageURL, kIconURL64x64,
       CreateRawBitmapResult(kIconURL64x64, TOUCH_ICON,
                             /*expired=*/true));
 
   EXPECT_CALL(delegate_,
-              OnFaviconUpdated(kPageURL, FaviconDriverObserver::TOUCH_LARGEST,
+              OnFaviconUpdated(kPageURL, FaviconDriverObserver::LARGEST,
                                kIconURL64x64, /*icon_url_changed=*/true, _));
   EXPECT_CALL(delegate_,
-              OnFaviconUpdated(kPageURL, FaviconDriverObserver::TOUCH_LARGEST,
+              OnFaviconUpdated(kPageURL, FaviconDriverObserver::LARGEST,
                                kIconURL64x64, /*icon_url_changed=*/false, _));
 
   RunHandlerWithCandidates(
-      FaviconDriverObserver::TOUCH_LARGEST,
+      FaviconDriverObserver::LARGEST,
       {
           FaviconURL(kIconURLReturning500, TOUCH_PRECOMPOSED_ICON, kEmptySizes),
           FaviconURL(kIconURL64x64, TOUCH_ICON, kEmptySizes),
       });
   // First download fails, second succeeds.
   EXPECT_THAT(delegate_.downloads(),
               ElementsAre(kIconURLReturning500, kIconURL64x64));
 }
 
 // Test that download data for icon URLs other than the current favicon
@@ skipping 307 matching lines @@
 
   const std::vector<favicon::FaviconURL> kSourceIconURLs{
       FaviconURL(kIconURL1_17, FAVICON, {gfx::Size(1, 1), gfx::Size(17, 17)}),
       FaviconURL(kIconURL1024_512, FAVICON,
                  {gfx::Size(1024, 1024), gfx::Size(512, 512)}),
       FaviconURL(kIconURL16_14, FAVICON,
                  {gfx::Size(16, 16), gfx::Size(14, 14)}),
       FaviconURL(kIconURLWithoutSize1, FAVICON, kEmptySizes),
       FaviconURL(kIconURLWithoutSize2, FAVICON, kEmptySizes)};
 
-  std::unique_ptr<FaviconHandler> handler = RunHandlerWithCandidates(
-      FaviconDriverObserver::NON_TOUCH_LARGEST, kSourceIconURLs);
+  std::unique_ptr<FaviconHandler> handler =
+      RunHandlerWithCandidates(FaviconDriverObserver::LARGEST, kSourceIconURLs);
 
   EXPECT_THAT(
       handler->GetIconURLs(),
       ElementsAre(
           // The 512x512 bitmap is the best match for the desired size.
           kIconURL1024_512, kIconURL1_17, kIconURL16_14,
           // The rest of bitmaps come in order, there is no "sizes" attribute.
           kIconURLWithoutSize1, kIconURLWithoutSize2));
 }
 
 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,
+      FaviconDriverObserver::LARGEST,
       {FaviconURL(kIconURL1024_512, FAVICON,
                   {gfx::Size(1024, 1024), gfx::Size(512, 512)}),
        FaviconURL(kIconURL15_14, FAVICON,
                   {gfx::Size(15, 15), gfx::Size(14, 14)}),
        FaviconURL(kIconURL16_512, FAVICON,
                   {gfx::Size(16, 16), gfx::Size(512, 512)}),
        FaviconURL(kIconURLWithoutSize1, FAVICON, kEmptySizes),
        FaviconURL(kIconURLWithoutSize2, FAVICON, kEmptySizes)});
 
   // Icon URLs are not registered and hence 404s will be produced, which
   // allows checking whether the icons were requested according to their size.
   // The favicons should have been requested in decreasing order of their sizes.
   // Favicons without any <link sizes=""> attribute should have been downloaded
   // last.
   EXPECT_THAT(delegate_.downloads(),
               ElementsAre(kIconURL1024_512, kIconURL16_512, kIconURL15_14,
                           kIconURLWithoutSize1, kIconURLWithoutSize2));
 }
 
 TEST_F(FaviconHandlerTest, TestSelectLargestFavicon) {
   const GURL kIconURL1("http://www.google.com/b");
   const GURL kIconURL2("http://www.google.com/c");
 
   delegate_.fake_downloader().Add(kIconURL1, IntVector{15});
   delegate_.fake_downloader().Add(kIconURL2, IntVector{14, 16});
 
   // Verify NotifyFaviconAvailable().
-  EXPECT_CALL(delegate_,
-              OnFaviconUpdated(_, FaviconDriverObserver::NON_TOUCH_LARGEST,
-                               kIconURL2, _, _));
+  EXPECT_CALL(delegate_, OnFaviconUpdated(_, FaviconDriverObserver::LARGEST,
+                                          kIconURL2, _, _));
 
   RunHandlerWithCandidates(
-      FaviconDriverObserver::NON_TOUCH_LARGEST,
+      FaviconDriverObserver::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(
-      FaviconDriverObserver::NON_TOUCH_LARGEST);
+  const int kMaximalSize =
+      FaviconHandler::GetMaximalIconSize(FaviconDriverObserver::LARGEST);
 
   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 best bitmap was selected (although smaller than |kIconURL2|)
   // and that it was scaled down to |kMaximalSize|.
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(_, _, kIconURL1, _,
                                ImageSizeIs(kMaximalSize, kMaximalSize)));
 
   RunHandlerWithCandidates(
-      FaviconDriverObserver::NON_TOUCH_LARGEST,
+      FaviconDriverObserver::LARGEST,
       {FaviconURL(kIconURL1, FAVICON,
                   SizeVector{gfx::Size(kOriginalSize1, kOriginalSize1)}),
        FaviconURL(kIconURL2, FAVICON,
                   SizeVector{gfx::Size(kOriginalSize2, kOriginalSize2)})});
 
   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,
+      FaviconDriverObserver::LARGEST,
       {FaviconURL(kIconURL10x10, FAVICON, SizeVector{gfx::Size(16, 16)}),
        FaviconURL(kIconURL12x12, FAVICON, SizeVector{gfx::Size(15, 15)}),
        FaviconURL(kIconURL16x16, FAVICON, kEmptySizes)});
 }
 
 }  // namespace
 }  // namespace favicon