Adding CrHome-specific implementation for home page tile.

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>
@@ skipping 195 matching lines @@
 };
 
 class MockMostVisitedSitesObserver : public MostVisitedSites::Observer {
  public:
   MOCK_METHOD1(OnMostVisitedURLsAvailable, void(const NTPTilesVector& tiles));
   MOCK_METHOD1(OnIconMadeAvailable, void(const GURL& site_url));
 };
 
 class FakeHomePageClient : public MostVisitedSites::HomePageClient {
  public:
-  FakeHomePageClient() : home_page_enabled_(false), ntp_is_homepage_(false) {}
+  FakeHomePageClient()
+      : home_page_enabled_(false),
+        ntp_is_homepage_(false),
+        home_page_url_(kHomePageUrl) {}
   ~FakeHomePageClient() override {}
 
   bool IsHomePageEnabled() const override { return home_page_enabled_; }
 
   bool IsNewTabPageUsedAsHomePage() const override { return ntp_is_homepage_; }
 
-  GURL GetHomepageUrl() const override { return GURL(kHomePageUrl); }
+  GURL GetHomepageUrl() const override { return home_page_url_; }
 
   void SetHomePageEnabled(bool home_page_enabled) {
     home_page_enabled_ = home_page_enabled;
   }
 
   void SetNtpIsHomePage(bool ntp_is_homepage) {
     ntp_is_homepage_ = ntp_is_homepage;
   }
 
+  void SetHomePageUrl(GURL home_page_url) { home_page_url_ = home_page_url; }
+
  private:
   bool home_page_enabled_;
   bool ntp_is_homepage_;
+  GURL home_page_url_;
 };
 
 class MockIconCacher : public IconCacher {
  public:
   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));
@@ skipping 114 matching lines @@
 
       // 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, StartFetchPopularSites(_, _, _))
           .Times(AtLeast(0));
     }
 
-    auto home_page_client = base::MakeUnique<FakeHomePageClient>();
-    home_page_client_ = home_page_client.get();
-
     most_visited_sites_ = base::MakeUnique<MostVisitedSites>(
         &pref_service_, mock_top_sites_, &mock_suggestions_service_,
         popular_sites_factory_.New(), std::move(icon_cacher),
-        /*supervisor=*/nullptr, std::move(home_page_client));
+        /*supervisor=*/nullptr);
   }
 
   bool IsPopularSitesEnabledViaVariations() const { return GetParam(); }
 
   bool VerifyAndClearExpectations() {
     base::RunLoop().RunUntilIdle();
     const bool success =
         Mock::VerifyAndClearExpectations(mock_top_sites_.get()) &&
         Mock::VerifyAndClearExpectations(&mock_suggestions_service_) &&
         Mock::VerifyAndClearExpectations(&mock_observer_);
     // For convenience, restore the expectations for IsBlacklisted().
     if (IsPopularSitesEnabledViaVariations()) {
       EXPECT_CALL(*mock_top_sites_, IsBlacklisted(_))
           .WillRepeatedly(Return(false));
     }
     return success;
   }
 
+  FakeHomePageClient* RegisterNewHomePageClient() {
+    auto home_page_client = base::MakeUnique<FakeHomePageClient>();
+    FakeHomePageClient* raw_client_ptr = home_page_client.get();
+    most_visited_sites_->SetHomePageClient(std::move(home_page_client));
+    return raw_client_ptr;
+  }
+
   void DisableRemoteSuggestions() {
     EXPECT_CALL(mock_suggestions_service_, AddCallback(_))
         .Times(AnyNumber())
         .WillRepeatedly(Invoke(&suggestions_service_callbacks_,
                                &SuggestionsService::ResponseCallbackList::Add));
     EXPECT_CALL(mock_suggestions_service_, GetSuggestionsDataFromCache())
         .Times(AnyNumber())
         .WillRepeatedly(Return(SuggestionsProfile()));  // Empty cache.
     EXPECT_CALL(mock_suggestions_service_, FetchSuggestionsData())
         .Times(AnyNumber())
         .WillRepeatedly(Return(true));
   }
 
   base::CallbackList<SuggestionsService::ResponseCallback::RunType>
       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_;
-  FakeHomePageClient* home_page_client_;
   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, ShouldIncludeTileForHomePage) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_, OnMostVisitedURLsAvailable(FirstTileIs(
                                   "", kHomePageUrl, TileSource::HOMEPAGE)));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageWithoutClient) {
+  base::test::ScopedFeatureList features;
+  features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
+  DisableRemoteSuggestions();
+  EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
+      .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
+  EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
+  EXPECT_CALL(mock_observer_,
+              OnMostVisitedURLsAvailable(Not(Contains(
+                  MatchesTile("", kHomePageUrl, TileSource::HOMEPAGE)))));
+  most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
+                                                  /*num_sites=*/3);
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageIfFeatureDisabled) {
   base::test::ScopedFeatureList features;
   features.InitAndDisableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_,
               OnMostVisitedURLsAvailable(Not(Contains(
                   MatchesTile("", kHomePageUrl, TileSource::HOMEPAGE)))));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageIfNoTileRequested) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_, OnMostVisitedURLsAvailable(IsEmpty()));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/0);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldReturnOnlyHomePageIfOneTileRequested) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(
           (MostVisitedURLList{MakeMostVisitedURL("Site 1", "http://site1/")})));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_,
               OnMostVisitedURLsAvailable(ElementsAre(
                   MatchesTile("", kHomePageUrl, TileSource::HOMEPAGE))));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/1);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldDeduplicateHomePageWithTopSites) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(
           (MostVisitedURLList{MakeMostVisitedURL("Site 1", "http://site1/"),
                               MakeMostVisitedURL("", kHomePageUrl)})));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_,
               OnMostVisitedURLsAvailable(
                   AllOf(FirstTileIs("", kHomePageUrl, TileSource::HOMEPAGE),
                         Not(Contains(MatchesTile("", kHomePageUrl,
                                                  TileSource::TOP_SITES))))));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageIfItIsNewTabPage) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
-  home_page_client_->SetNtpIsHomePage(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
+  home_page_client->SetNtpIsHomePage(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_,
               OnMostVisitedURLsAvailable(Not(Contains(
                   MatchesTile("", kHomePageUrl, TileSource::HOMEPAGE)))));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageIfThereIsNone) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(false);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(false);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
   EXPECT_CALL(mock_observer_,
               OnMostVisitedURLsAvailable(Not(Contains(
                   MatchesTile("", kHomePageUrl, TileSource::HOMEPAGE)))));
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   base::RunLoop().RunUntilIdle();
 }
 
+TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageIfEmptyUrl) {
+  const std::string kEmptyHomePageUrl;
+  base::test::ScopedFeatureList features;
+  features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
+  home_page_client->SetHomePageUrl(GURL(kEmptyHomePageUrl));
+  DisableRemoteSuggestions();
+  EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
+      .WillRepeatedly(InvokeCallbackArgument<0>(MostVisitedURLList{}));
+  EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
+  EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(kEmptyHomePageUrl)))
+      .Times(AnyNumber())
+      .WillRepeatedly(Return(false));
+  EXPECT_CALL(mock_observer_,
+              OnMostVisitedURLsAvailable(Not(
+                  FirstTileIs("", kEmptyHomePageUrl, TileSource::HOMEPAGE))));
+  most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
+                                                  /*num_sites=*/3);
+  base::RunLoop().RunUntilIdle();
+}
+
 TEST_P(MostVisitedSitesTest, ShouldNotIncludeHomePageIfBlacklisted) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillRepeatedly(InvokeCallbackArgument<0>(
           (MostVisitedURLList{MakeMostVisitedURL("", kHomePageUrl)})));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AnyNumber())
       .WillRepeatedly(Return(false));
 
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_observer_,
               OnMostVisitedURLsAvailable(Not(Contains(
                   MatchesTile("", kHomePageUrl, TileSource::HOMEPAGE)))));
 
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesTest, ShouldPinHomePageAgainIfBlacklistingUndone) {
   base::test::ScopedFeatureList features;
   features.InitAndEnableFeature(ntp_tiles::kPinHomePageAsTileFeature);
-  home_page_client_->SetHomePageEnabled(true);
+  FakeHomePageClient* home_page_client = RegisterNewHomePageClient();
+  home_page_client->SetHomePageEnabled(true);
 
   DisableRemoteSuggestions();
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillOnce(InvokeCallbackArgument<0>(
           (MostVisitedURLList{MakeMostVisitedURL("", kHomePageUrl)})));
   EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
   EXPECT_CALL(*mock_top_sites_, IsBlacklisted(Eq(GURL(kHomePageUrl))))
       .Times(AtLeast(1))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_observer_,
@@ skipping 564 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