[NTP Tiles] Fetch missing MostLikely tiles from a Google server

components/ntp_tiles/most_visited_sites_unittest.cc

 // Copyright 2015 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/ntp_tiles/most_visited_sites.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <ostream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback_list.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
+#include "base/test/scoped_feature_list.h"
 #include "base/test/sequenced_worker_pool_owner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/history/core/browser/top_sites.h"
 #include "components/history/core/browser/top_sites_observer.h"
+#include "components/ntp_tiles/constants.h"
 #include "components/ntp_tiles/icon_cacher.h"
 #include "components/ntp_tiles/json_unsafe_parser.h"
 #include "components/ntp_tiles/popular_sites_impl.h"
 #include "components/ntp_tiles/pref_names.h"
 #include "components/ntp_tiles/switches.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 150 matching lines @@
 };
 
 class MockMostVisitedSitesObserver : public MostVisitedSites::Observer {
  public:
   MOCK_METHOD1(OnMostVisitedURLsAvailable, void(const NTPTilesVector& tiles));
   MOCK_METHOD1(OnIconMadeAvailable, void(const GURL& site_url));
 };
 
 class MockIconCacher : public IconCacher {
  public:
-  MOCK_METHOD3(StartFetch,
+  MOCK_METHOD3(StartFetchPopularSites,
                void(PopularSites::Site site,
                     const base::Closure& icon_available,
                     const base::Closure& preliminary_icon_available));
+  MOCK_METHOD2(StartFetchMostLikely,
+               void(const GURL& page_url, const base::Closure& icon_available));
 };
 
 class PopularSitesFactoryForTest {
  public:
   PopularSitesFactoryForTest(
       bool enabled,
       sync_preferences::TestingPrefServiceSyncable* pref_service)
       : prefs_(pref_service),
         url_fetcher_factory_(/*default_factory=*/nullptr),
         url_request_context_(new net::TestURLRequestContextGetter(
@@ skipping 69 matching lines @@
     MostVisitedSites::RegisterProfilePrefs(pref_service_.registry());
 
     if (IsPopularSitesEnabledViaVariations()) {
       base::CommandLine::ForCurrentProcess()->AppendSwitch(
           switches::kEnableNTPPopularSites);
     } else {
       base::CommandLine::ForCurrentProcess()->AppendSwitch(
           switches::kDisableNTPPopularSites);
     }
 
+    // Disable in most tests, this is overriden in a specific test.
+    feature_list_.InitAndDisableFeature(
+        kNtpMostLikelyFaviconsFromServerFeature);
+
     // We use StrictMock to make sure the object is not used unless Popular
     // Sites is enabled.
     auto icon_cacher = base::MakeUnique<StrictMock<MockIconCacher>>();
+    icon_cacher_ = icon_cacher.get();
 
     if (IsPopularSitesEnabledViaVariations()) {
       // Populate Popular Sites' internal cache by mimicking a past usage of
       // PopularSitesImpl.
       auto tmp_popular_sites = popular_sites_factory_.New();
       base::RunLoop loop;
       bool save_success = false;
       tmp_popular_sites->MaybeStartFetch(
           /*force_download=*/true,
           base::Bind(
               [](bool* save_success, base::RunLoop* loop, bool success) {
                 *save_success = success;
                 loop->Quit();
               },
               &save_success, &loop));
       loop.Run();
       EXPECT_TRUE(save_success);
 
       // With PopularSites enabled, blacklist is exercised.
       EXPECT_CALL(*mock_top_sites_, IsBlacklisted(_))
           .WillRepeatedly(Return(false));
       // Mock icon cacher never replies, and we also don't verify whether the
       // code uses it correctly.
-      EXPECT_CALL(*icon_cacher, StartFetch(_, _, _)).Times(AtLeast(0));
+      EXPECT_CALL(*icon_cacher, StartFetchPopularSites(_, _, _))
+          .Times(AtLeast(0));
     }
 
     most_visited_sites_ = base::MakeUnique<MostVisitedSites>(
         &pref_service_, mock_top_sites_, &mock_suggestions_service_,
         popular_sites_factory_.New(), std::move(icon_cacher),
         /*supervisor=*/nullptr);
   }
 
   bool IsPopularSitesEnabledViaVariations() const { return GetParam(); }
 
@@ skipping 15 matching lines @@
       suggestions_service_callbacks_;
   TopSitesCallbackList top_sites_callbacks_;
 
   base::MessageLoop message_loop_;
   sync_preferences::TestingPrefServiceSyncable pref_service_;
   PopularSitesFactoryForTest popular_sites_factory_;
   scoped_refptr<StrictMock<MockTopSites>> mock_top_sites_;
   StrictMock<MockSuggestionsService> mock_suggestions_service_;
   StrictMock<MockMostVisitedSitesObserver> mock_observer_;
   std::unique_ptr<MostVisitedSites> most_visited_sites_;
+  base::test::ScopedFeatureList feature_list_;
+  MockIconCacher* icon_cacher_;
 };
 
 TEST_P(MostVisitedSitesTest, ShouldStartNoCallInConstructor) {
   // No call to mocks expected by the mere fact of instantiating
   // MostVisitedSites.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldHandleTopSitesCacheHit) {
   // If cached, TopSites returns the tiles synchronously, running the callback
@@ skipping 171 matching lines @@
           MatchesTile("Site 6", "http://site6/", TileSource::TOP_SITES),
           MatchesTile("Site 7", "http://site7/", TileSource::TOP_SITES))));
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 4", "http://site4/"),
        MakeMostVisitedURL("Site 5", "http://site5/"),
        MakeMostVisitedURL("Site 6", "http://site6/"),
        MakeMostVisitedURL("Site 7", "http://site7/")});
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_P(MostVisitedSitesWithCacheHitTest, ShouldFetchFaviconsIfEnabled) {
+  base::test::ScopedFeatureList feature_list;
+  feature_list.InitAndEnableFeature(kNtpMostLikelyFaviconsFromServerFeature);
+
+  EXPECT_CALL(mock_observer_, OnMostVisitedURLsAvailable(_));
+  EXPECT_CALL(*icon_cacher_, StartFetchMostLikely(GURL("http://site4/"), _));
+
+  suggestions_service_callbacks_.Notify(
+      MakeProfile({MakeSuggestion("Site 4", "http://site4/")}));
+  base::RunLoop().RunUntilIdle();
+}
+
 INSTANTIATE_TEST_CASE_P(MostVisitedSitesWithCacheHitTest,
                         MostVisitedSitesWithCacheHitTest,
                         ::testing::Bool());
 
 class MostVisitedSitesWithEmptyCacheTest : public MostVisitedSitesTest {
  public:
   // Constructor sets the common expectations for the case where suggestions
   // service doesn't have cached results when the observer is registered.
   MostVisitedSitesWithEmptyCacheTest() {
     InSequence seq;
@@ skipping 322 matching lines @@
                       TileSource::TOP_SITES),
           MatchesTile("Site 4", "https://www.site4.com/",
                       TileSource::TOP_SITES),
           MatchesTile("Site 1", "https://www.site1.com/", TileSource::POPULAR),
           MatchesTile("Site 2", "https://www.site2.com/",
                       TileSource::POPULAR)));
 }
 
 }  // namespace
 }  // namespace ntp_tiles