ntp_tiles: Migrate to multi-observer model

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 189 matching lines @@
   bool empty() const { return callbacks_.empty(); }
 
  private:
   std::vector<TopSites::GetMostVisitedURLsCallback> callbacks_;
 };
 
 class MostVisitedSitesTest : public ::testing::Test {
  protected:
   MostVisitedSitesTest()
       : mock_top_sites_(new StrictMock<MockTopSites>()),
-        mock_popular_sites_(new StrictMock<MockPopularSites>()),
-        most_visited_sites_(&pref_service_,
-                            mock_top_sites_,
-                            &mock_suggestions_service_,
-                            base::WrapUnique(mock_popular_sites_),
-                            /*icon_cacher=*/nullptr,
-                            /*supervisor=*/nullptr) {
+        mock_popular_sites_(new StrictMock<MockPopularSites>()) {
     MostVisitedSites::RegisterProfilePrefs(pref_service_.registry());
     // TODO(mastiz): Add test coverage including Popular Sites.
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kDisableNTPPopularSites);
     // PopularSites::sites() might be called even if the feature is disabled.
     // An empty vector is returned because there was no actual fetch.
     EXPECT_CALL(*mock_popular_sites_, sites())
         .Times(AtLeast(0))
         .WillRepeatedly(ReturnRef(empty_popular_sites_vector_));
+    EXPECT_CALL(mock_suggestions_service_, AddCallback(_))
+        .WillOnce(Invoke(&suggestions_service_callbacks_,
+                         &SuggestionsService::ResponseCallbackList::Add));
+
+    most_visited_sites_ =
+        base::WrapUnique<MostVisitedSites>(new MostVisitedSites(
+            &pref_service_, mock_top_sites_, &mock_suggestions_service_,
+            base::WrapUnique(mock_popular_sites_),
+            /*icon_cacher=*/nullptr,
+            /*supervisor=*/nullptr));
+    most_visited_sites_->AddObserver(&mock_observer_);
+    VerifyAndClearExpectations();
+
+    EXPECT_FALSE(suggestions_service_callbacks_.empty());
   }
 
   bool VerifyAndClearExpectations() {
     base::RunLoop().RunUntilIdle();
     // Note that we don't verify or clear mock_popular_sites_, since there's
     // no interaction expected except sites() possibly being called, which is
     // verified during teardown.
     return Mock::VerifyAndClearExpectations(mock_top_sites_.get()) &&
            Mock::VerifyAndClearExpectations(&mock_suggestions_service_) &&
            Mock::VerifyAndClearExpectations(&mock_observer_);
   }
 
   base::CallbackList<SuggestionsService::ResponseCallback::RunType>
       suggestions_service_callbacks_;
   TopSitesCallbackList top_sites_callbacks_;
 
   base::MessageLoop message_loop_;
   sync_preferences::TestingPrefServiceSyncable pref_service_;
   scoped_refptr<StrictMock<MockTopSites>> mock_top_sites_;
   StrictMock<MockSuggestionsService> mock_suggestions_service_;
   StrictMock<MockPopularSites>* const mock_popular_sites_;
   StrictMock<MockMostVisitedSitesObserver> mock_observer_;
-  MostVisitedSites most_visited_sites_;
+  std::unique_ptr<MostVisitedSites> most_visited_sites_;
   const PopularSites::SitesVector empty_popular_sites_vector_;
 };
 
-TEST_F(MostVisitedSitesTest, ShouldStartNoCallInConstructor) {
-  // No call to mocks expected by the mere fact of instantiating
-  // MostVisitedSites.
+TEST_F(MostVisitedSitesTest, ShouldRegisterCallbacksInConstructor) {
+  EXPECT_CALL(mock_observer_, OnMostVisitedURLsAvailable(_));
+  suggestions_service_callbacks_.Notify(
+      MakeProfile({MakeSuggestion("Site 1", "http://site1/")}));
   base::RunLoop().RunUntilIdle();
 }
 
 class MostVisitedSitesWithCacheHitTest : public MostVisitedSitesTest {
  public:
   // Constructor sets the common expectations for the case where suggestions
   // service has cached results when the observer is registered.
   MostVisitedSitesWithCacheHitTest() {
     InSequence seq;
     EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
-    EXPECT_CALL(mock_suggestions_service_, AddCallback(_))
-        .WillOnce(Invoke(&suggestions_service_callbacks_,
-                         &SuggestionsService::ResponseCallbackList::Add));
     EXPECT_CALL(mock_suggestions_service_, GetSuggestionsDataFromCache())
         .WillOnce(Return(MakeProfile({
             MakeSuggestion("Site 1", "http://site1/"),
             MakeSuggestion("Site 2", "http://site2/"),
             MakeSuggestion("Site 3", "http://site3/"),
             MakeSuggestion("Site 4", "http://site4/"),
         })));
     EXPECT_CALL(mock_observer_,
                 OnMostVisitedURLsAvailable(ElementsAre(
                     MatchesTile("Site 1", "http://site1/",
                                 NTPTileSource::SUGGESTIONS_SERVICE),
                     MatchesTile("Site 2", "http://site2/",
                                 NTPTileSource::SUGGESTIONS_SERVICE),
                     MatchesTile("Site 3", "http://site3/",
+                                NTPTileSource::SUGGESTIONS_SERVICE),
+                    MatchesTile("Site 4", "http://site4/",
                                 NTPTileSource::SUGGESTIONS_SERVICE))));
     EXPECT_CALL(mock_suggestions_service_, FetchSuggestionsData())
         .WillOnce(Return(true));
-    most_visited_sites_.SetMostVisitedURLsObserver(&mock_observer_,
-                                                   /*num_sites=*/3);
+    most_visited_sites_->Refresh();
     VerifyAndClearExpectations();
 
     EXPECT_FALSE(suggestions_service_callbacks_.empty());
     EXPECT_TRUE(top_sites_callbacks_.empty());
   }
 };
 
 TEST_F(MostVisitedSitesWithCacheHitTest, ShouldFavorSuggestionsServiceCache) {
   // Constructor sets basic expectations for a suggestions service cache hit.
 }
@@ skipping 24 matching lines @@
   base::RunLoop().RunUntilIdle();
 }
 
 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;
     EXPECT_CALL(*mock_top_sites_, SyncWithHistory());
-    EXPECT_CALL(mock_suggestions_service_, AddCallback(_))
-        .WillOnce(Invoke(&suggestions_service_callbacks_,
-                         &SuggestionsService::ResponseCallbackList::Add));
     EXPECT_CALL(mock_suggestions_service_, GetSuggestionsDataFromCache())
         .WillOnce(Return(SuggestionsProfile()));  // Empty cache.
     EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
         .WillOnce(Invoke(&top_sites_callbacks_, &TopSitesCallbackList::Add));
     EXPECT_CALL(mock_suggestions_service_, FetchSuggestionsData())
         .WillOnce(Return(true));
-    most_visited_sites_.SetMostVisitedURLsObserver(&mock_observer_,
-                                                   /*num_sites=*/3);
+    most_visited_sites_->Refresh();
     VerifyAndClearExpectations();
 
-    EXPECT_FALSE(suggestions_service_callbacks_.empty());
     EXPECT_FALSE(top_sites_callbacks_.empty());
   }
 };
 
 TEST_F(MostVisitedSitesWithEmptyCacheTest,
        ShouldQueryTopSitesAndSuggestionsService) {
   // Constructor sets basic expectations for a suggestions service cache miss.
 }
 
 TEST_F(MostVisitedSitesWithEmptyCacheTest,
@@ skipping 165 matching lines @@
                   MatchesTile("Site 4", "https://www.site4.com/",
                               NTPTileSource::TOP_SITES),
                   MatchesTile("Site 1", "https://www.site1.com/",
                               NTPTileSource::POPULAR),
                   MatchesTile("Site 2", "https://www.site2.com/",
                               NTPTileSource::POPULAR)));
 }
 
 }  // namespace
 }  // namespace ntp_tiles