ntp_tiles: Cleanup enum names

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 68 matching lines @@
 // gmock makes it simple to create action templates that do for the various
 // possible numbers of arguments.
 ACTION_TEMPLATE(InvokeCallbackArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(p0)) {
   ::std::tr1::get<k>(args).Run(p0);
 }
 
 NTPTile MakeTile(const std::string& title,
                  const std::string& url,
-                 NTPTileSource source) {
+                 TileSource source) {
   NTPTile tile;
   tile.title = base::ASCIIToUTF16(title);
   tile.url = GURL(url);
   tile.source = source;
   return tile;
 }
 
 ChromeSuggestion MakeSuggestion(const std::string& title,
                                 const std::string& url) {
   ChromeSuggestion suggestion;
@@ skipping 267 matching lines @@
   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.
   if (IsPopularSitesEnabledViaVariations()) {
     EXPECT_CALL(
         mock_observer_,
         OnMostVisitedURLsAvailable(ElementsAre(
-            MatchesTile("Site 1", "http://site1/", NTPTileSource::TOP_SITES),
+            MatchesTile("Site 1", "http://site1/", TileSource::TOP_SITES),
             MatchesTile("PopularSite1", "http://popularsite1/",
-                        NTPTileSource::POPULAR),
+                        TileSource::POPULAR),
             MatchesTile("PopularSite2", "http://popularsite2/",
-                        NTPTileSource::POPULAR))));
+                        TileSource::POPULAR))));
   } else {
     EXPECT_CALL(mock_observer_,
                 OnMostVisitedURLsAvailable(ElementsAre(MatchesTile(
-                    "Site 1", "http://site1/", NTPTileSource::TOP_SITES))));
+                    "Site 1", "http://site1/", TileSource::TOP_SITES))));
   }
   EXPECT_CALL(mock_suggestions_service_, FetchSuggestionsData())
       .WillOnce(Return(true));
 
   most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                   /*num_sites=*/3);
   VerifyAndClearExpectations();
   EXPECT_FALSE(suggestions_service_callbacks_.empty());
   CHECK(top_sites_callbacks_.empty());
 
@@ skipping 28 matching lines @@
     EXPECT_CALL(mock_suggestions_service_, GetSuggestionsDataFromCache())
         .WillOnce(Return(MakeProfile({
             MakeSuggestion("Site 1", "http://site1/"),
             MakeSuggestion("Site 2", "http://site2/"),
             MakeSuggestion("Site 3", "http://site3/"),
         })));
     if (IsPopularSitesEnabledViaVariations()) {
       EXPECT_CALL(mock_observer_,
                   OnMostVisitedURLsAvailable(ElementsAre(
                       MatchesTile("Site 1", "http://site1/",
-                                  NTPTileSource::SUGGESTIONS_SERVICE),
+                                  TileSource::SUGGESTIONS_SERVICE),
                       MatchesTile("Site 2", "http://site2/",
-                                  NTPTileSource::SUGGESTIONS_SERVICE),
+                                  TileSource::SUGGESTIONS_SERVICE),
                       MatchesTile("Site 3", "http://site3/",
-                                  NTPTileSource::SUGGESTIONS_SERVICE),
+                                  TileSource::SUGGESTIONS_SERVICE),
                       MatchesTile("PopularSite1", "http://popularsite1/",
-                                  NTPTileSource::POPULAR))));
+                                  TileSource::POPULAR))));
     } else {
       EXPECT_CALL(mock_observer_,
                   OnMostVisitedURLsAvailable(ElementsAre(
                       MatchesTile("Site 1", "http://site1/",
-                                  NTPTileSource::SUGGESTIONS_SERVICE),
+                                  TileSource::SUGGESTIONS_SERVICE),
                       MatchesTile("Site 2", "http://site2/",
-                                  NTPTileSource::SUGGESTIONS_SERVICE),
+                                  TileSource::SUGGESTIONS_SERVICE),
                       MatchesTile("Site 3", "http://site3/",
-                                  NTPTileSource::SUGGESTIONS_SERVICE))));
+                                  TileSource::SUGGESTIONS_SERVICE))));
     }
     EXPECT_CALL(mock_suggestions_service_, FetchSuggestionsData())
         .WillOnce(Return(true));
 
     most_visited_sites_->SetMostVisitedURLsObserver(&mock_observer_,
                                                     /*num_sites=*/4);
     VerifyAndClearExpectations();
 
     EXPECT_FALSE(suggestions_service_callbacks_.empty());
     EXPECT_TRUE(top_sites_callbacks_.empty());
   }
 };
 
 TEST_P(MostVisitedSitesWithCacheHitTest, ShouldFavorSuggestionsServiceCache) {
   // Constructor sets basic expectations for a suggestions service cache hit.
 }
 
 TEST_P(MostVisitedSitesWithCacheHitTest,
        ShouldPropagateUpdateBySuggestionsService) {
   EXPECT_CALL(mock_observer_,
-              OnMostVisitedURLsAvailable(ElementsAre(
-                  MatchesTile("Site 4", "http://site4/",
-                              NTPTileSource::SUGGESTIONS_SERVICE),
-                  MatchesTile("Site 5", "http://site5/",
-                              NTPTileSource::SUGGESTIONS_SERVICE),
-                  MatchesTile("Site 6", "http://site6/",
-                              NTPTileSource::SUGGESTIONS_SERVICE),
-                  MatchesTile("Site 7", "http://site7/",
-                              NTPTileSource::SUGGESTIONS_SERVICE))));
+              OnMostVisitedURLsAvailable(
+                  ElementsAre(MatchesTile("Site 4", "http://site4/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 5", "http://site5/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 6", "http://site6/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 7", "http://site7/",
+                                          TileSource::SUGGESTIONS_SERVICE))));
   suggestions_service_callbacks_.Notify(
       MakeProfile({MakeSuggestion("Site 4", "http://site4/"),
                    MakeSuggestion("Site 5", "http://site5/"),
                    MakeSuggestion("Site 6", "http://site6/"),
                    MakeSuggestion("Site 7", "http://site7/")}));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithCacheHitTest, ShouldTruncateList) {
   EXPECT_CALL(mock_observer_, OnMostVisitedURLsAvailable(SizeIs(4)));
   suggestions_service_callbacks_.Notify(
       MakeProfile({MakeSuggestion("Site 4", "http://site4/"),
                    MakeSuggestion("Site 5", "http://site5/"),
                    MakeSuggestion("Site 6", "http://site6/"),
                    MakeSuggestion("Site 7", "http://site7/"),
                    MakeSuggestion("Site 8", "http://site8/")}));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithCacheHitTest,
        ShouldCompleteWithPopularSitesIffEnabled) {
   if (IsPopularSitesEnabledViaVariations()) {
     EXPECT_CALL(mock_observer_,
                 OnMostVisitedURLsAvailable(ElementsAre(
                     MatchesTile("Site 4", "http://site4/",
-                                NTPTileSource::SUGGESTIONS_SERVICE),
+                                TileSource::SUGGESTIONS_SERVICE),
                     MatchesTile("PopularSite1", "http://popularsite1/",
-                                NTPTileSource::POPULAR),
+                                TileSource::POPULAR),
                     MatchesTile("PopularSite2", "http://popularsite2/",
-                                NTPTileSource::POPULAR))));
+                                TileSource::POPULAR))));
   } else {
     EXPECT_CALL(
         mock_observer_,
         OnMostVisitedURLsAvailable(ElementsAre(MatchesTile(
-            "Site 4", "http://site4/", NTPTileSource::SUGGESTIONS_SERVICE))));
+            "Site 4", "http://site4/", TileSource::SUGGESTIONS_SERVICE))));
   }
   suggestions_service_callbacks_.Notify(
       MakeProfile({MakeSuggestion("Site 4", "http://site4/")}));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithCacheHitTest,
        ShouldSwitchToTopSitesIfEmptyUpdateBySuggestionsService) {
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillOnce(Invoke(&top_sites_callbacks_, &TopSitesCallbackList::Add));
   suggestions_service_callbacks_.Notify(SuggestionsProfile());
   VerifyAndClearExpectations();
 
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 4", "http://site4/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 5", "http://site5/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 6", "http://site6/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 7", "http://site7/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 4", "http://site4/", TileSource::TOP_SITES),
+          MatchesTile("Site 5", "http://site5/", TileSource::TOP_SITES),
+          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();
 }
 
 INSTANTIATE_TEST_CASE_P(MostVisitedSitesWithCacheHitTest,
                         MostVisitedSitesWithCacheHitTest,
@@ skipping 29 matching lines @@
        ShouldQueryTopSitesAndSuggestionsService) {
   // Constructor sets basic expectations for a suggestions service cache miss.
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldCompleteWithPopularSitesIffEnabled) {
   if (IsPopularSitesEnabledViaVariations()) {
     EXPECT_CALL(mock_observer_,
                 OnMostVisitedURLsAvailable(ElementsAre(
                     MatchesTile("Site 4", "http://site4/",
-                                NTPTileSource::SUGGESTIONS_SERVICE),
+                                TileSource::SUGGESTIONS_SERVICE),
                     MatchesTile("PopularSite1", "http://popularsite1/",
-                                NTPTileSource::POPULAR),
+                                TileSource::POPULAR),
                     MatchesTile("PopularSite2", "http://popularsite2/",
-                                NTPTileSource::POPULAR))));
+                                TileSource::POPULAR))));
   } else {
     EXPECT_CALL(
         mock_observer_,
         OnMostVisitedURLsAvailable(ElementsAre(MatchesTile(
-            "Site 4", "http://site4/", NTPTileSource::SUGGESTIONS_SERVICE))));
+            "Site 4", "http://site4/", TileSource::SUGGESTIONS_SERVICE))));
   }
   suggestions_service_callbacks_.Notify(
       MakeProfile({MakeSuggestion("Site 4", "http://site4/")}));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldIgnoreTopSitesIfSuggestionsServiceFaster) {
   // Reply from suggestions service triggers and update to our observer.
   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))));
+              OnMostVisitedURLsAvailable(
+                  ElementsAre(MatchesTile("Site 1", "http://site1/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 2", "http://site2/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 3", "http://site3/",
+                                          TileSource::SUGGESTIONS_SERVICE))));
   suggestions_service_callbacks_.Notify(
       MakeProfile({MakeSuggestion("Site 1", "http://site1/"),
                    MakeSuggestion("Site 2", "http://site2/"),
                    MakeSuggestion("Site 3", "http://site3/")}));
   VerifyAndClearExpectations();
 
   // Reply from top sites is ignored (i.e. not reported to observer).
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 4", "http://site4/")});
   VerifyAndClearExpectations();
 
   // Update by TopSites is also ignored.
   mock_top_sites_->NotifyTopSitesChanged(
       history::TopSitesObserver::ChangeReason::MOST_VISITED);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldExposeTopSitesIfSuggestionsServiceFasterButEmpty) {
   // Empty reply from suggestions service causes no update to our observer.
   suggestions_service_callbacks_.Notify(SuggestionsProfile());
   VerifyAndClearExpectations();
 
   // Reply from top sites is propagated to observer.
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 1", "http://site1/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 2", "http://site2/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 3", "http://site3/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 1", "http://site1/", TileSource::TOP_SITES),
+          MatchesTile("Site 2", "http://site2/", TileSource::TOP_SITES),
+          MatchesTile("Site 3", "http://site3/", TileSource::TOP_SITES))));
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 1", "http://site1/"),
        MakeMostVisitedURL("Site 2", "http://site2/"),
        MakeMostVisitedURL("Site 3", "http://site3/")});
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldFavorSuggestionsServiceAlthoughSlower) {
   // Reply from top sites is propagated to observer.
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 1", "http://site1/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 2", "http://site2/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 3", "http://site3/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 1", "http://site1/", TileSource::TOP_SITES),
+          MatchesTile("Site 2", "http://site2/", TileSource::TOP_SITES),
+          MatchesTile("Site 3", "http://site3/", TileSource::TOP_SITES))));
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 1", "http://site1/"),
        MakeMostVisitedURL("Site 2", "http://site2/"),
        MakeMostVisitedURL("Site 3", "http://site3/")});
   VerifyAndClearExpectations();
 
   // Reply from suggestions service overrides top sites.
   InSequence seq;
   EXPECT_CALL(mock_observer_,
-              OnMostVisitedURLsAvailable(ElementsAre(
-                  MatchesTile("Site 4", "http://site4/",
-                              NTPTileSource::SUGGESTIONS_SERVICE),
-                  MatchesTile("Site 5", "http://site5/",
-                              NTPTileSource::SUGGESTIONS_SERVICE),
-                  MatchesTile("Site 6", "http://site6/",
-                              NTPTileSource::SUGGESTIONS_SERVICE))));
+              OnMostVisitedURLsAvailable(
+                  ElementsAre(MatchesTile("Site 4", "http://site4/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 5", "http://site5/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 6", "http://site6/",
+                                          TileSource::SUGGESTIONS_SERVICE))));
   suggestions_service_callbacks_.Notify(
       MakeProfile({MakeSuggestion("Site 4", "http://site4/"),
                    MakeSuggestion("Site 5", "http://site5/"),
                    MakeSuggestion("Site 6", "http://site6/")}));
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldIgnoreSuggestionsServiceIfSlowerAndEmpty) {
   // Reply from top sites is propagated to observer.
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 1", "http://site1/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 2", "http://site2/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 3", "http://site3/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 1", "http://site1/", TileSource::TOP_SITES),
+          MatchesTile("Site 2", "http://site2/", TileSource::TOP_SITES),
+          MatchesTile("Site 3", "http://site3/", TileSource::TOP_SITES))));
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 1", "http://site1/"),
        MakeMostVisitedURL("Site 2", "http://site2/"),
        MakeMostVisitedURL("Site 3", "http://site3/")});
   VerifyAndClearExpectations();
 
   // Reply from suggestions service is empty and thus ignored.
   suggestions_service_callbacks_.Notify(SuggestionsProfile());
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest, ShouldPropagateUpdateByTopSites) {
   // Reply from top sites is propagated to observer.
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 1", "http://site1/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 2", "http://site2/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 3", "http://site3/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 1", "http://site1/", TileSource::TOP_SITES),
+          MatchesTile("Site 2", "http://site2/", TileSource::TOP_SITES),
+          MatchesTile("Site 3", "http://site3/", TileSource::TOP_SITES))));
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 1", "http://site1/"),
        MakeMostVisitedURL("Site 2", "http://site2/"),
        MakeMostVisitedURL("Site 3", "http://site3/")});
   VerifyAndClearExpectations();
 
   // Reply from suggestions service is empty and thus ignored.
   suggestions_service_callbacks_.Notify(SuggestionsProfile());
   VerifyAndClearExpectations();
   EXPECT_TRUE(top_sites_callbacks_.empty());
 
   // Update from top sites is propagated to observer.
   EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
       .WillOnce(InvokeCallbackArgument<0>(
           MostVisitedURLList{MakeMostVisitedURL("Site 4", "http://site4/"),
                              MakeMostVisitedURL("Site 5", "http://site5/"),
                              MakeMostVisitedURL("Site 6", "http://site6/")}));
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 4", "http://site4/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 5", "http://site5/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 6", "http://site6/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 4", "http://site4/", TileSource::TOP_SITES),
+          MatchesTile("Site 5", "http://site5/", TileSource::TOP_SITES),
+          MatchesTile("Site 6", "http://site6/", TileSource::TOP_SITES))));
   mock_top_sites_->NotifyTopSitesChanged(
       history::TopSitesObserver::ChangeReason::MOST_VISITED);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldSendEmptyListIfBothTopSitesAndSuggestionsServiceEmpty) {
   if (IsPopularSitesEnabledViaVariations()) {
     EXPECT_CALL(mock_observer_,
                 OnMostVisitedURLsAvailable(ElementsAre(
                     MatchesTile("PopularSite1", "http://popularsite1/",
-                                NTPTileSource::POPULAR),
+                                TileSource::POPULAR),
                     MatchesTile("PopularSite2", "http://popularsite2/",
-                                NTPTileSource::POPULAR))));
+                                TileSource::POPULAR))));
   } else {
     // The Android NTP doesn't finish initialization until it gets tiles, so a
     // 0-tile notification is always needed.
     EXPECT_CALL(mock_observer_, OnMostVisitedURLsAvailable(IsEmpty()));
   }
   suggestions_service_callbacks_.Notify(SuggestionsProfile());
   top_sites_callbacks_.ClearAndNotify(MostVisitedURLList{});
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldNotifyOnceIfTopSitesUnchanged) {
   EXPECT_CALL(
       mock_observer_,
       OnMostVisitedURLsAvailable(ElementsAre(
-          MatchesTile("Site 1", "http://site1/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 2", "http://site2/", NTPTileSource::TOP_SITES),
-          MatchesTile("Site 3", "http://site3/", NTPTileSource::TOP_SITES))));
+          MatchesTile("Site 1", "http://site1/", TileSource::TOP_SITES),
+          MatchesTile("Site 2", "http://site2/", TileSource::TOP_SITES),
+          MatchesTile("Site 3", "http://site3/", TileSource::TOP_SITES))));
 
   suggestions_service_callbacks_.Notify(SuggestionsProfile());
 
   top_sites_callbacks_.ClearAndNotify(
       {MakeMostVisitedURL("Site 1", "http://site1/"),
        MakeMostVisitedURL("Site 2", "http://site2/"),
        MakeMostVisitedURL("Site 3", "http://site3/")});
   base::RunLoop().RunUntilIdle();
 
   for (int i = 0; i < 4; ++i) {
     EXPECT_CALL(*mock_top_sites_, GetMostVisitedURLs(_, false))
         .WillOnce(Invoke(&top_sites_callbacks_, &TopSitesCallbackList::Add));
     mock_top_sites_->NotifyTopSitesChanged(
         history::TopSitesObserver::ChangeReason::MOST_VISITED);
     EXPECT_FALSE(top_sites_callbacks_.empty());
     top_sites_callbacks_.ClearAndNotify(
         {MakeMostVisitedURL("Site 1", "http://site1/"),
          MakeMostVisitedURL("Site 2", "http://site2/"),
          MakeMostVisitedURL("Site 3", "http://site3/")});
     base::RunLoop().RunUntilIdle();
   }
 }
 
 TEST_P(MostVisitedSitesWithEmptyCacheTest,
        ShouldNotifyOnceIfSuggestionsUnchanged) {
   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))));
+              OnMostVisitedURLsAvailable(
+                  ElementsAre(MatchesTile("Site 1", "http://site1/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 2", "http://site2/",
+                                          TileSource::SUGGESTIONS_SERVICE),
+                              MatchesTile("Site 3", "http://site3/",
+                                          TileSource::SUGGESTIONS_SERVICE))));
 
   for (int i = 0; i < 5; ++i) {
     suggestions_service_callbacks_.Notify(
         MakeProfile({MakeSuggestion("Site 1", "http://site1/"),
                      MakeSuggestion("Site 2", "http://site2/"),
                      MakeSuggestion("Site 3", "http://site3/")}));
   }
 }
 
 INSTANTIATE_TEST_CASE_P(MostVisitedSitesWithEmptyCacheTest,
                         MostVisitedSitesWithEmptyCacheTest,
                         ::testing::Bool());
 
 // This a test for MostVisitedSites::MergeTiles(...) method, and thus has the
 // same scope as the method itself. This tests merging popular sites with
 // personal tiles.
 // More important things out of the scope of testing presently:
 // - Removing blacklisted tiles.
 // - Correct host extraction from the URL.
 // - Ensuring personal tiles are not duplicated in popular tiles.
 TEST(MostVisitedSitesMergeTest, ShouldMergeTilesWithPersonalOnly) {
   std::vector<NTPTile> personal_tiles{
-      MakeTile("Site 1", "https://www.site1.com/", NTPTileSource::TOP_SITES),
-      MakeTile("Site 2", "https://www.site2.com/", NTPTileSource::TOP_SITES),
-      MakeTile("Site 3", "https://www.site3.com/", NTPTileSource::TOP_SITES),
-      MakeTile("Site 4", "https://www.site4.com/", NTPTileSource::TOP_SITES),
+      MakeTile("Site 1", "https://www.site1.com/", TileSource::TOP_SITES),
+      MakeTile("Site 2", "https://www.site2.com/", TileSource::TOP_SITES),
+      MakeTile("Site 3", "https://www.site3.com/", TileSource::TOP_SITES),
+      MakeTile("Site 4", "https://www.site4.com/", TileSource::TOP_SITES),
   };
   // Without any popular tiles, the result after merge should be the personal
   // tiles.
   EXPECT_THAT(MostVisitedSites::MergeTiles(std::move(personal_tiles),
                                            /*whitelist_tiles=*/NTPTilesVector(),
                                            /*popular_tiles=*/NTPTilesVector()),
               ElementsAre(MatchesTile("Site 1", "https://www.site1.com/",
-                                      NTPTileSource::TOP_SITES),
+                                      TileSource::TOP_SITES),
                           MatchesTile("Site 2", "https://www.site2.com/",
-                                      NTPTileSource::TOP_SITES),
+                                      TileSource::TOP_SITES),
                           MatchesTile("Site 3", "https://www.site3.com/",
-                                      NTPTileSource::TOP_SITES),
+                                      TileSource::TOP_SITES),
                           MatchesTile("Site 4", "https://www.site4.com/",
-                                      NTPTileSource::TOP_SITES)));
+                                      TileSource::TOP_SITES)));
 }
 
 TEST(MostVisitedSitesMergeTest, ShouldMergeTilesWithPopularOnly) {
   std::vector<NTPTile> popular_tiles{
-      MakeTile("Site 1", "https://www.site1.com/", NTPTileSource::POPULAR),
-      MakeTile("Site 2", "https://www.site2.com/", NTPTileSource::POPULAR),
-      MakeTile("Site 3", "https://www.site3.com/", NTPTileSource::POPULAR),
-      MakeTile("Site 4", "https://www.site4.com/", NTPTileSource::POPULAR),
+      MakeTile("Site 1", "https://www.site1.com/", TileSource::POPULAR),
+      MakeTile("Site 2", "https://www.site2.com/", TileSource::POPULAR),
+      MakeTile("Site 3", "https://www.site3.com/", TileSource::POPULAR),
+      MakeTile("Site 4", "https://www.site4.com/", TileSource::POPULAR),
   };
   // Without any personal tiles, the result after merge should be the popular
   // tiles.
   EXPECT_THAT(
       MostVisitedSites::MergeTiles(/*personal_tiles=*/NTPTilesVector(),
                                    /*whitelist_tiles=*/NTPTilesVector(),
                                    /*popular_tiles=*/std::move(popular_tiles)),
-      ElementsAre(MatchesTile("Site 1", "https://www.site1.com/",
-                              NTPTileSource::POPULAR),
-                  MatchesTile("Site 2", "https://www.site2.com/",
-                              NTPTileSource::POPULAR),
-                  MatchesTile("Site 3", "https://www.site3.com/",
-                              NTPTileSource::POPULAR),
-                  MatchesTile("Site 4", "https://www.site4.com/",
-                              NTPTileSource::POPULAR)));
+      ElementsAre(
+          MatchesTile("Site 1", "https://www.site1.com/", TileSource::POPULAR),
+          MatchesTile("Site 2", "https://www.site2.com/", TileSource::POPULAR),
+          MatchesTile("Site 3", "https://www.site3.com/", TileSource::POPULAR),
+          MatchesTile("Site 4", "https://www.site4.com/",
+                      TileSource::POPULAR)));
 }
 
 TEST(MostVisitedSitesMergeTest, ShouldMergeTilesFavoringPersonalOverPopular) {
   std::vector<NTPTile> popular_tiles{
-      MakeTile("Site 1", "https://www.site1.com/", NTPTileSource::POPULAR),
-      MakeTile("Site 2", "https://www.site2.com/", NTPTileSource::POPULAR),
+      MakeTile("Site 1", "https://www.site1.com/", TileSource::POPULAR),
+      MakeTile("Site 2", "https://www.site2.com/", TileSource::POPULAR),
   };
   std::vector<NTPTile> personal_tiles{
-      MakeTile("Site 3", "https://www.site3.com/", NTPTileSource::TOP_SITES),
-      MakeTile("Site 4", "https://www.site4.com/", NTPTileSource::TOP_SITES),
+      MakeTile("Site 3", "https://www.site3.com/", TileSource::TOP_SITES),
+      MakeTile("Site 4", "https://www.site4.com/", TileSource::TOP_SITES),
   };
   EXPECT_THAT(
       MostVisitedSites::MergeTiles(std::move(personal_tiles),
                                    /*whitelist_tiles=*/NTPTilesVector(),
                                    /*popular_tiles=*/std::move(popular_tiles)),
-      ElementsAre(MatchesTile("Site 3", "https://www.site3.com/",
-                              NTPTileSource::TOP_SITES),
-                  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)));
+      ElementsAre(
+          MatchesTile("Site 3", "https://www.site3.com/",
+                      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