Trivial renames in preparation for Web Manifest support

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 194 matching lines @@
   std::map<GURL, Response> responses_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeImageDownloader);
 };
 
 class MockDelegate : public FaviconHandler::Delegate {
  public:
   MockDelegate() {
     // Delegate image downloading to FakeImageDownloader.
     ON_CALL(*this, DownloadImage(_, _, _))
-        .WillByDefault(
-            Invoke(&fake_downloader_, &FakeImageDownloader::DownloadImage));
+        .WillByDefault(Invoke(&fake_image_downloader_,
+                              &FakeImageDownloader::DownloadImage));
   }
 
   MOCK_METHOD3(DownloadImage,
                int(const GURL& url,
                    int max_image_size,
                    ImageDownloadCallback callback));
   MOCK_METHOD0(IsOffTheRecord, bool());
   MOCK_METHOD1(IsBookmarked, bool(const GURL& url));
   MOCK_METHOD5(OnFaviconUpdated,
                void(const GURL& page_url,
                     FaviconDriverObserver::NotificationIconType type,
                     const GURL& icon_url,
                     bool icon_url_changed,
                     const gfx::Image& image));
 
-  FakeImageDownloader& fake_downloader() { return fake_downloader_; }
+  FakeImageDownloader& fake_image_downloader() {
+    return fake_image_downloader_;
+  }
 
   // Convenience getter for test readability. Returns pending and completed
   // download URLs.
-  const URLVector& downloads() const { return fake_downloader_.downloads(); }
+  const URLVector& downloads() const {
+    return fake_image_downloader_.downloads();
+  }
 
  private:
-  FakeImageDownloader fake_downloader_;
+  FakeImageDownloader fake_image_downloader_;
 };
 
 // FakeFaviconService mimics a FaviconService backend that allows setting up
 // test data stored via Store(). If Store() has not been called for a
 // particular URL, the callback is called with empty database results.
 class FakeFaviconService {
  public:
   FakeFaviconService()
       : manual_callback_task_runner_(new base::TestSimpleTaskRunner()) {}
 
@@ skipping 126 matching lines @@
   const GURL kPageURL = GURL("http://www.google.com");
   const GURL kIconURL10x10 = GURL("http://www.google.com/favicon10x10");
   const GURL kIconURL12x12 = GURL("http://www.google.com/favicon12x12");
   const GURL kIconURL16x16 = GURL("http://www.google.com/favicon16x16");
   const GURL kIconURL64x64 = GURL("http://www.google.com/favicon64x64");
 
   FaviconHandlerTest()
       : scoped_task_environment_(
             base::test::ScopedTaskEnvironment::MainThreadType::UI) {
     // Register various known icon URLs.
-    delegate_.fake_downloader().Add(kIconURL10x10, IntVector{10});
-    delegate_.fake_downloader().Add(kIconURL12x12, IntVector{12});
-    delegate_.fake_downloader().Add(kIconURL16x16, IntVector{16});
-    delegate_.fake_downloader().Add(kIconURL64x64, IntVector{64});
+    delegate_.fake_image_downloader().Add(kIconURL10x10, IntVector{10});
+    delegate_.fake_image_downloader().Add(kIconURL12x12, IntVector{12});
+    delegate_.fake_image_downloader().Add(kIconURL16x16, IntVector{16});
+    delegate_.fake_image_downloader().Add(kIconURL64x64, IntVector{64});
 
     // The score computed by SelectFaviconFrames() is dependent on the supported
     // scale factors of the platform. It is used for determining the goodness of
     // a downloaded bitmap in FaviconHandler::OnDidDownloadFavicon().
     // Force the values of the scale factors so that the tests produce the same
     // results on all platforms.
     scoped_set_supported_scale_factors_.reset(
         new ui::test::ScopedSetSupportedScaleFactors({ui::SCALE_FACTOR_100P}));
   }
 
   bool VerifyAndClearExpectations() {
     base::RunLoop().RunUntilIdle();
     favicon_service_.fake()->ClearDbRequests();
-    delegate_.fake_downloader().ClearDownloads();
+    delegate_.fake_image_downloader().ClearDownloads();
     return testing::Mock::VerifyAndClearExpectations(&favicon_service_) &&
            testing::Mock::VerifyAndClearExpectations(&delegate_);
   }
 
   // Creates a new handler and feeds in the page URL and the candidates.
   // Returns the handler in case tests want to exercise further steps.
   std::unique_ptr<FaviconHandler> RunHandlerWithCandidates(
       FaviconDriverObserver::NotificationIconType handler_type,
       const std::vector<favicon::FaviconURL>& candidates) {
     auto handler = base::MakeUnique<FaviconHandler>(&favicon_service_,
                                                     &delegate_, handler_type);
     handler->FetchFavicon(kPageURL);
     // The first RunUntilIdle() causes the FaviconService lookups be faster than
-    // OnUpdateFaviconURL(), which is the most likely scenario.
+    // OnUpdateCandidates(), which is the most likely scenario.
     base::RunLoop().RunUntilIdle();
-    handler->OnUpdateFaviconURL(kPageURL, candidates);
+    handler->OnUpdateCandidates(kPageURL, candidates);
     base::RunLoop().RunUntilIdle();
     return handler;
   }
 
   // Same as above, but for the simplest case where all types are FAVICON and
   // no sizes are provided, using a FaviconHandler of type NON_TOUCH_16_DIP.
   std::unique_ptr<FaviconHandler> RunHandlerWithSimpleFaviconCandidates(
       const std::vector<GURL>& urls) {
     std::vector<favicon::FaviconURL> candidates;
     for (const GURL& url : urls) {
@@ skipping 38 matching lines @@
               UpdateFaviconMappingsAndFetch(kPageURL, kIconURL16x16, FAVICON,
                                             /*desired_size_in_dip=*/16, _, _));
 
   RunHandlerWithSimpleFaviconCandidates({kIconURL16x16});
 }
 
 // Test that the FaviconHandler process finishes when:
 // - There is data in the database for neither the page URL nor the icon URL.
 // AND
 // - FaviconService::GetFaviconForPageURL() callback returns before
-//   FaviconHandler::OnUpdateFaviconURL() is called.
+//   FaviconHandler::OnUpdateCandidates() is called.
 TEST_F(FaviconHandlerTest, DownloadUnknownFaviconIfCandidatesSlower) {
   // Defer the database lookup completion to control the exact timing.
   favicon_service_.fake()->SetRunCallbackManuallyForUrl(kPageURL);
 
   EXPECT_CALL(favicon_service_, SetFavicons(_, _, _, _)).Times(0);
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, _, _, _)).Times(0);
 
   FaviconHandler handler(&favicon_service_, &delegate_,
                          FaviconDriverObserver::NON_TOUCH_16_DIP);
   handler.FetchFavicon(kPageURL);
   base::RunLoop().RunUntilIdle();
   // Database lookup for |kPageURL| is ongoing.
   ASSERT_TRUE(favicon_service_.fake()->HasPendingManualCallback());
-  // Causes FaviconService lookups be faster than OnUpdateFaviconURL().
+  // Causes FaviconService lookups be faster than OnUpdateCandidates().
   ASSERT_TRUE(favicon_service_.fake()->RunCallbackManually());
   ASSERT_TRUE(VerifyAndClearExpectations());
 
   EXPECT_CALL(favicon_service_, SetFavicons(kPageURL, kIconURL16x16, FAVICON,
                                             ImageSizeIs(16, 16)));
   EXPECT_CALL(delegate_, OnFaviconUpdated(
                              kPageURL, FaviconDriverObserver::NON_TOUCH_16_DIP,
                              kIconURL16x16, /*icon_url_changed=*/true, _));
   // Feed in favicons now that the database lookup is completed.
-  handler.OnUpdateFaviconURL(kPageURL,
+  handler.OnUpdateCandidates(kPageURL,
                              {FaviconURL(kIconURL16x16, FAVICON, kEmptySizes)});
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(favicon_service_.fake()->db_requests(),
               ElementsAre(kIconURL16x16));
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL16x16));
 }
 
 // Test that the FaviconHandler process finishes when:
 // - There is data in the database for neither the page URL nor the icon URL.
 // AND
 // - FaviconService::GetFaviconForPageURL() callback returns after
-//   FaviconHandler::OnUpdateFaviconURL() is called.
+//   FaviconHandler::OnUpdateCandidates() is called.
 TEST_F(FaviconHandlerTest, DownloadUnknownFaviconIfCandidatesFaster) {
   // Defer the database lookup completion to control the exact timing.
   favicon_service_.fake()->SetRunCallbackManuallyForUrl(kPageURL);
 
   EXPECT_CALL(favicon_service_, SetFavicons(_, _, _, _)).Times(0);
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, _, _, _)).Times(0);
 
   FaviconHandler handler(&favicon_service_, &delegate_,
                          FaviconDriverObserver::NON_TOUCH_16_DIP);
   handler.FetchFavicon(kPageURL);
   base::RunLoop().RunUntilIdle();
   // Feed in favicons before completing the database lookup.
-  handler.OnUpdateFaviconURL(kPageURL,
+  handler.OnUpdateCandidates(kPageURL,
                              {FaviconURL(kIconURL16x16, FAVICON, kEmptySizes)});
 
   ASSERT_TRUE(VerifyAndClearExpectations());
   // Database lookup for |kPageURL| is ongoing.
   ASSERT_TRUE(favicon_service_.fake()->HasPendingManualCallback());
 
   EXPECT_CALL(favicon_service_, SetFavicons(kPageURL, kIconURL16x16, FAVICON,
                                             ImageSizeIs(16, 16)));
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, kIconURL16x16, _, _));
 
@@ skipping 44 matching lines @@
 TEST_F(FaviconHandlerTest, RedownloadExpiredPageUrlFavicon) {
   const GURL kIconURL("http://www.google.com/favicon");
   const SkColor kOldColor = SK_ColorBLUE;
   const SkColor kNewColor = SK_ColorGREEN;
 
   favicon_service_.fake()->Store(
       kPageURL, kIconURL,
       CreateRawBitmapResult(kIconURL, FAVICON, /*expired=*/true,
                             gfx::kFaviconSize, kOldColor));
 
-  delegate_.fake_downloader().Add(kIconURL, IntVector{gfx::kFaviconSize},
-                                  IntVector{gfx::kFaviconSize}, kNewColor);
+  delegate_.fake_image_downloader().Add(kIconURL, IntVector{gfx::kFaviconSize},
+                                        IntVector{gfx::kFaviconSize},
+                                        kNewColor);
 
   EXPECT_CALL(favicon_service_,
               SetFavicons(_, kIconURL, _, ImageColorIs(kNewColor)));
 
   InSequence seq;
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(_, _, kIconURL, _, ImageColorIs(kOldColor)));
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(_, _, kIconURL, _, ImageColorIs(kNewColor)));
 
@@ skipping 26 matching lines @@
   RunHandlerWithSimpleFaviconCandidates({kNewIconURL});
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kNewIconURL));
 }
 
 // If there is data for the page URL in history which is invalid, test that:
 // - The invalid data is not sent to the UI.
 // - The icon is redownloaded.
 TEST_F(FaviconHandlerTest, FaviconInHistoryInvalid) {
   const GURL kIconURL("http://www.google.com/favicon");
 
-  delegate_.fake_downloader().Add(kIconURL, IntVector{gfx::kFaviconSize},
-                                  IntVector{gfx::kFaviconSize}, SK_ColorBLUE);
+  delegate_.fake_image_downloader().Add(kIconURL, IntVector{gfx::kFaviconSize},
+                                        IntVector{gfx::kFaviconSize},
+                                        SK_ColorBLUE);
 
   // Set non empty but invalid data.
   std::vector<FaviconRawBitmapResult> bitmap_result =
       CreateRawBitmapResult(kIconURL);
   // Empty bitmap data is invalid.
   bitmap_result[0].bitmap_data = new base::RefCountedBytes();
 
   favicon_service_.fake()->Store(kPageURL, kIconURL, bitmap_result);
 
   EXPECT_CALL(delegate_,
@@ skipping 25 matching lines @@
 
   RunHandlerWithSimpleFaviconCandidates({kNewIconURL});
   EXPECT_THAT(favicon_service_.fake()->db_requests(),
               ElementsAre(kPageURL, kNewIconURL));
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
 }
 
 TEST_F(FaviconHandlerTest, Download2ndFaviconURLCandidate) {
   const GURL kIconURLReturning500("http://www.google.com/500.png");
 
-  delegate_.fake_downloader().AddError(kIconURLReturning500, 500);
+  delegate_.fake_image_downloader().AddError(kIconURLReturning500, 500);
 
   favicon_service_.fake()->Store(
       kPageURL, kIconURL64x64,
       CreateRawBitmapResult(kIconURL64x64, TOUCH_ICON,
                             /*expired=*/true));
 
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(kPageURL, FaviconDriverObserver::TOUCH_LARGEST,
                                kIconURL64x64, /*icon_url_changed=*/true, _));
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(kPageURL, FaviconDriverObserver::TOUCH_LARGEST,
                                kIconURL64x64, /*icon_url_changed=*/false, _));
 
   RunHandlerWithCandidates(
       FaviconDriverObserver::TOUCH_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
 // candidate URLs is ignored. This test tests the scenario where a download is
-// in flight when FaviconHandler::OnUpdateFaviconURL() is called.
+// in flight when FaviconHandler::OnUpdateCandidates() is called.
 // TODO(mastiz): Make this test deal with FaviconURLs of type
 // favicon_base::FAVICON and add new ones like OnlyDownloadMatchingIconType and
 // CallSetFaviconsWithCorrectIconType.
 TEST_F(FaviconHandlerTest, UpdateDuringDownloading) {
   const GURL kIconURL1("http://www.google.com/favicon");
   const GURL kIconURL2 = kIconURL16x16;
   const GURL kIconURL3 = kIconURL64x64;
 
   // Defer the download completion such that RunUntilIdle() doesn't complete
   // the download.
-  delegate_.fake_downloader().SetRunCallbackManuallyForUrl(kIconURL1);
+  delegate_.fake_image_downloader().SetRunCallbackManuallyForUrl(kIconURL1);
 
-  delegate_.fake_downloader().Add(kIconURL1, IntVector{16});
-  delegate_.fake_downloader().Add(kIconURL3, IntVector{64});
+  delegate_.fake_image_downloader().Add(kIconURL1, IntVector{16});
+  delegate_.fake_image_downloader().Add(kIconURL3, IntVector{64});
 
   std::unique_ptr<FaviconHandler> handler =
       RunHandlerWithSimpleFaviconCandidates({kIconURL1, kIconURL2});
 
   ASSERT_TRUE(VerifyAndClearExpectations());
-  ASSERT_TRUE(delegate_.fake_downloader().HasPendingManualCallback());
+  ASSERT_TRUE(delegate_.fake_image_downloader().HasPendingManualCallback());
 
   // Favicon update should invalidate the ongoing download.
   EXPECT_CALL(favicon_service_, SetFavicons(_, kIconURL3, _, _));
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, kIconURL3, _, _));
 
-  handler->OnUpdateFaviconURL(kPageURL,
+  handler->OnUpdateCandidates(kPageURL,
                               {FaviconURL(kIconURL3, FAVICON, kEmptySizes)});
 
   // Finalizes download, which should be thrown away as the favicon URLs were
   // updated.
-  EXPECT_TRUE(delegate_.fake_downloader().RunCallbackManually());
+  EXPECT_TRUE(delegate_.fake_image_downloader().RunCallbackManually());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(favicon_service_.fake()->db_requests(), ElementsAre(kIconURL3));
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL3));
 }
 
 // Test that sending an icon URL update different to the previous icon URL
 // update during a database lookup ignores the first icon URL and processes the
 // second.
 TEST_F(FaviconHandlerTest, UpdateDuringDatabaseLookup) {
   const GURL kIconURL1 = kIconURL16x16;
   const GURL kIconURL2 = kIconURL64x64;
 
   // Defer the lookup completion such that RunUntilIdle() doesn't complete the
   // lookup.
   favicon_service_.fake()->SetRunCallbackManuallyForUrl(kIconURL1);
 
-  delegate_.fake_downloader().Add(kIconURL1, IntVector{16});
-  delegate_.fake_downloader().Add(kIconURL2, IntVector{64});
+  delegate_.fake_image_downloader().Add(kIconURL1, IntVector{16});
+  delegate_.fake_image_downloader().Add(kIconURL2, IntVector{64});
 
   std::unique_ptr<FaviconHandler> handler =
       RunHandlerWithSimpleFaviconCandidates(URLVector{kIconURL1});
 
   ASSERT_TRUE(VerifyAndClearExpectations());
   ASSERT_TRUE(favicon_service_.fake()->HasPendingManualCallback());
 
   // SetFavicons() and OnFaviconUpdated() should be called for the new icon URL
   // and not |kIconURL1|.
   EXPECT_CALL(favicon_service_, SetFavicons(_, kIconURL2, _, _));
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, kIconURL2, _, _));
 
-  handler->OnUpdateFaviconURL(kPageURL,
+  handler->OnUpdateCandidates(kPageURL,
                               {FaviconURL(kIconURL2, FAVICON, kEmptySizes)});
 
   // Finalizes the DB lookup, which should be thrown away as the favicon URLs
   // were updated.
   EXPECT_TRUE(favicon_service_.fake()->RunCallbackManually());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_THAT(favicon_service_.fake()->db_requests(), ElementsAre(kIconURL2));
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL2));
 }
 
 // Test that sending an icon URL update identical to the previous icon URL
 // update during image download is a no-op.
 TEST_F(FaviconHandlerTest, UpdateSameIconURLsWhileDownloadingShouldBeNoop) {
   const GURL kSlowLoadingIconURL("http://www.google.com/slow_favicon");
 
   const std::vector<FaviconURL> favicon_urls = {
       FaviconURL(kIconURL64x64, FAVICON, kEmptySizes),
       FaviconURL(kSlowLoadingIconURL, FAVICON, kEmptySizes),
   };
 
   // Defer the download completion such that RunUntilIdle() doesn't complete
   // the download.
-  delegate_.fake_downloader().SetRunCallbackManuallyForUrl(kSlowLoadingIconURL);
-  delegate_.fake_downloader().Add(kSlowLoadingIconURL, IntVector{16});
+  delegate_.fake_image_downloader().SetRunCallbackManuallyForUrl(
+      kSlowLoadingIconURL);
+  delegate_.fake_image_downloader().Add(kSlowLoadingIconURL, IntVector{16});
 
   std::unique_ptr<FaviconHandler> handler = RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_16_DIP, favicon_urls);
 
   ASSERT_THAT(favicon_service_.fake()->db_requests(),
               ElementsAre(kPageURL, kIconURL64x64, kSlowLoadingIconURL));
   ASSERT_TRUE(VerifyAndClearExpectations());
-  ASSERT_TRUE(delegate_.fake_downloader().HasPendingManualCallback());
+  ASSERT_TRUE(delegate_.fake_image_downloader().HasPendingManualCallback());
 
-  // Calling OnUpdateFaviconURL() with the same icon URLs should have no effect,
+  // Calling OnUpdateCandidates() with the same icon URLs should have no effect,
   // despite the ongoing download.
-  handler->OnUpdateFaviconURL(kPageURL, favicon_urls);
+  handler->OnUpdateCandidates(kPageURL, favicon_urls);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(favicon_service_.fake()->db_requests(), IsEmpty());
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
 
   // Complete the download.
   EXPECT_CALL(favicon_service_, SetFavicons(_, _, _, _));
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, _, _, _));
-  EXPECT_TRUE(delegate_.fake_downloader().RunCallbackManually());
+  EXPECT_TRUE(delegate_.fake_image_downloader().RunCallbackManually());
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
 }
 
 // Test that sending an icon URL update identical to the previous icon URL
 // update during a database lookup is a no-op.
 TEST_F(FaviconHandlerTest, UpdateSameIconURLsWhileDatabaseLookupShouldBeNoop) {
   const std::vector<FaviconURL> favicon_urls = {
       FaviconURL(kIconURL64x64, FAVICON, kEmptySizes),
   };
 
   favicon_service_.fake()->SetRunCallbackManuallyForUrl(kIconURL64x64);
 
   std::unique_ptr<FaviconHandler> handler = RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_16_DIP, favicon_urls);
 
   // Ongoing database lookup.
   ASSERT_THAT(favicon_service_.fake()->db_requests(),
               ElementsAre(kPageURL, kIconURL64x64));
   ASSERT_THAT(delegate_.downloads(), IsEmpty());
   ASSERT_TRUE(VerifyAndClearExpectations());
   ASSERT_TRUE(favicon_service_.fake()->HasPendingManualCallback());
 
-  // Calling OnUpdateFaviconURL() with the same icon URLs should have no effect,
+  // Calling OnUpdateCandidates() with the same icon URLs should have no effect,
   // despite the ongoing DB lookup.
-  handler->OnUpdateFaviconURL(kPageURL, favicon_urls);
+  handler->OnUpdateCandidates(kPageURL, favicon_urls);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(favicon_service_.fake()->db_requests(), IsEmpty());
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
 
   // Complete the lookup.
   EXPECT_CALL(favicon_service_, SetFavicons(_, _, _, _));
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, _, _, _));
   EXPECT_TRUE(favicon_service_.fake()->RunCallbackManually());
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(delegate_.downloads(), ElementsAre(kIconURL64x64));
 }
 
 // Test that calling OnUpdateFaviconUrl() with the same icon URLs as before is a
 // no-op. This is important because OnUpdateFaviconUrl() is called when the page
 // finishes loading. This can occur several times for pages with iframes.
 TEST_F(FaviconHandlerTest, UpdateSameIconURLsAfterFinishedShouldBeNoop) {
   const std::vector<FaviconURL> favicon_urls = {
       FaviconURL(kIconURL10x10, FAVICON, kEmptySizes),
       FaviconURL(kIconURL16x16, FAVICON, kEmptySizes),
   };
 
   std::unique_ptr<FaviconHandler> handler = RunHandlerWithCandidates(
       FaviconDriverObserver::NON_TOUCH_16_DIP, favicon_urls);
 
   ASSERT_TRUE(VerifyAndClearExpectations());
 
-  // Calling OnUpdateFaviconURL() with identical data should be a no-op.
+  // Calling OnUpdateCandidates() with identical data should be a no-op.
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, _, _, _)).Times(0);
   EXPECT_CALL(favicon_service_, SetFavicons(_, _, _, _)).Times(0);
 
-  handler->OnUpdateFaviconURL(kPageURL, favicon_urls);
+  handler->OnUpdateCandidates(kPageURL, favicon_urls);
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(favicon_service_.fake()->db_requests(), IsEmpty());
   EXPECT_THAT(delegate_.downloads(), IsEmpty());
 }
 
 // Fixes crbug.com/544560
 // Tests that Delegate::OnFaviconUpdated() is called if:
 // - The best icon on the initial page is not the last icon.
 // - All of the initial page's icons are downloaded.
 // AND
 // - JavaScript modifies the page's <link rel="icon"> tags to contain only the
 //   last icon.
 TEST_F(FaviconHandlerTest,
        OnFaviconAvailableNotificationSentAfterIconURLChange) {
   const GURL kIconURL1(
       "http://wwww.page_which_animates_favicon.com/frame1.png");
   const GURL kIconURL2(
       "http://wwww.page_which_animates_favicon.com/frame2.png");
 
   // |kIconURL1| is the better match.
-  delegate_.fake_downloader().Add(kIconURL1, IntVector{15});
-  delegate_.fake_downloader().Add(kIconURL2, IntVector{10});
+  delegate_.fake_image_downloader().Add(kIconURL1, IntVector{15});
+  delegate_.fake_image_downloader().Add(kIconURL2, IntVector{10});
 
   // Two FaviconDriver::OnFaviconUpdated() notifications should be sent for
   // |kIconURL1|, one before and one after the download.
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, kIconURL1, _, _));
 
   std::unique_ptr<FaviconHandler> handler =
       RunHandlerWithSimpleFaviconCandidates({kIconURL1, kIconURL2});
 
   // Both |kIconURL1| and |kIconURL2| should have been requested from the
   // database and downloaded. |kIconURL2| should have been fetched from the
   // database and downloaded last.
   ASSERT_THAT(delegate_.downloads(), ElementsAre(kIconURL1, kIconURL2));
   ASSERT_THAT(favicon_service_.fake()->db_requests(),
               ElementsAre(kPageURL, kIconURL1, kIconURL2));
   ASSERT_TRUE(VerifyAndClearExpectations());
 
   // Simulate the page changing it's icon URL to just |kIconURL2| via
   // Javascript.
   EXPECT_CALL(delegate_, OnFaviconUpdated(_, _, kIconURL2, _, _));
-  handler->OnUpdateFaviconURL(kPageURL,
+  handler->OnUpdateCandidates(kPageURL,
                               {FaviconURL(kIconURL2, FAVICON, kEmptySizes)});
   base::RunLoop().RunUntilIdle();
 }
 
 // Test the favicon which is selected when the web page provides several
 // favicons and none of the favicons are cached in history.
 // The goal of this test is to be more of an integration test than
 // SelectFaviconFramesTest.*.
 class FaviconHandlerMultipleFaviconsTest : public FaviconHandlerTest {
  protected:
@@ skipping 17 matching lines @@
   // Returns the chosen size among |candidate_icon_sizes| or -1 if none was
   // chosen.
   int DownloadTillDoneIgnoringHistory(const IntVector& candidate_icon_sizes) {
     std::vector<FaviconURL> candidate_icons;
     int chosen_icon_size = -1;
 
     for (int icon_size : candidate_icon_sizes) {
       const GURL icon_url(base::StringPrintf(
           "https://www.google.com/generated/%dx%d", icon_size, icon_size));
       // Set up 200 responses for all images, and the corresponding size.
-      delegate_.fake_downloader().Add(icon_url, IntVector{icon_size});
+      delegate_.fake_image_downloader().Add(icon_url, IntVector{icon_size});
       // Create test candidates of type FAVICON and a fake URL.
       candidate_icons.emplace_back(icon_url, FAVICON, kEmptySizes);
 
       ON_CALL(delegate_, OnFaviconUpdated(_, _, icon_url, _, _))
           .WillByDefault(Assign(&chosen_icon_size, icon_size));
     }
 
     RunHandlerWithCandidates(FaviconDriverObserver::NON_TOUCH_16_DIP,
                              candidate_icons);
     return chosen_icon_size;
@@ skipping 35 matching lines @@
 
   RunHandlerWithSimpleFaviconCandidates({k404IconURL});
   EXPECT_THAT(delegate_.downloads(), ElementsAre(k404IconURL));
 }
 
 // Test that WasUnableToDownloadFavicon() is not called if a download returns
 // HTTP status 503.
 TEST_F(FaviconHandlerTest, NotReport503) {
   const GURL k503IconURL("http://www.google.com/503.png");
 
-  delegate_.fake_downloader().AddError(k503IconURL, 503);
+  delegate_.fake_image_downloader().AddError(k503IconURL, 503);
 
   EXPECT_CALL(favicon_service_, UnableToDownloadFavicon(_)).Times(0);
 
   RunHandlerWithSimpleFaviconCandidates({k503IconURL});
   EXPECT_THAT(delegate_.downloads(), ElementsAre(k503IconURL));
 }
 
 // Test that the best favicon is selected when:
 // - The page provides several favicons.
 // - Downloading one of the page's icon URLs previously returned a 404.
@@ skipping 112 matching lines @@
   // 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});
+  delegate_.fake_image_downloader().Add(kIconURL1, IntVector{15});
+  delegate_.fake_image_downloader().Add(kIconURL2, IntVector{14, 16});
 
   // Verify NotifyFaviconAvailable().
   EXPECT_CALL(delegate_,
               OnFaviconUpdated(_, FaviconDriverObserver::NON_TOUCH_LARGEST,
                                kIconURL2, _, _));
 
   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(
       FaviconDriverObserver::NON_TOUCH_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().Add(kIconURL1, IntVector{kMaximalSize},
-                                  IntVector{kOriginalSize1}, SK_ColorBLUE);
-  delegate_.fake_downloader().Add(kIconURL2, IntVector{kMaximalSize},
-                                  IntVector{kOriginalSize2}, SK_ColorBLUE);
+  delegate_.fake_image_downloader().Add(kIconURL1, IntVector{kMaximalSize},
+                                        IntVector{kOriginalSize1},
+                                        SK_ColorBLUE);
+  delegate_.fake_image_downloader().Add(kIconURL2, IntVector{kMaximalSize},
+                                        IntVector{kOriginalSize2},
+                                        SK_ColorBLUE);
 
   // 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,
       {FaviconURL(kIconURL1, FAVICON,
@@ skipping 138 matching lines @@
 
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Favicons.DownloadAttempts.Favicons"),
       ElementsAre(base::Bucket(/*sample=*/1, /*expected_count=*/1)));
 }
 
 TEST_F(FaviconHandlerTest, TestRecordFailingDownloadAttempt) {
   base::HistogramTester histogram_tester;
   const GURL k404IconURL("http://www.google.com/404.png");
 
-  delegate_.fake_downloader().AddError(k404IconURL, 404);
+  delegate_.fake_image_downloader().AddError(k404IconURL, 404);
 
   EXPECT_CALL(favicon_service_, UnableToDownloadFavicon(k404IconURL));
 
   RunHandlerWithSimpleFaviconCandidates({k404IconURL});
 
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
       ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::FAILED),
                                /*expected_count=*/1)));
 }
 
 TEST_F(FaviconHandlerTest, TestRecordSkippedDownloadForKnownFailingUrl) {
   base::HistogramTester histogram_tester;
   const GURL k404IconURL("http://www.google.com/404.png");
 
   ON_CALL(favicon_service_, WasUnableToDownloadFavicon(k404IconURL))
       .WillByDefault(Return(true));
 
   RunHandlerWithSimpleFaviconCandidates({k404IconURL});
 
   EXPECT_THAT(
       histogram_tester.GetAllSamples("Favicons.DownloadOutcome"),
       ElementsAre(base::Bucket(static_cast<int>(DownloadOutcome::SKIPPED),
                                /*expected_count=*/1)));
 }
 
 }  // namespace
 }  // namespace favicon