ntp_tiles: Cleanup enum names

components/ntp_tiles/most_visited_sites.cc

 // Copyright 2013 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 <algorithm>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 45 matching lines @@
     std::unique_ptr<MostVisitedSitesSupervisor> supervisor)
     : prefs_(prefs),
       top_sites_(top_sites),
       suggestions_service_(suggestions),
       popular_sites_(std::move(popular_sites)),
       icon_cacher_(std::move(icon_cacher)),
       supervisor_(std::move(supervisor)),
       observer_(nullptr),
       num_sites_(0),
       top_sites_observer_(this),
-      mv_source_(NTPTileSource::TOP_SITES),
+      mv_source_(TileSource::TOP_SITES),
       top_sites_weak_ptr_factory_(this) {
   DCHECK(prefs_);
   // top_sites_ can be null in tests.
   // TODO(sfiera): have iOS use a dummy TopSites in its tests.
   DCHECK(suggestions_service_);
   if (supervisor_)
     supervisor_->SetObserver(this);
 }
 
 MostVisitedSites::~MostVisitedSites() {
   if (supervisor_)
     supervisor_->SetObserver(nullptr);
 }
 
-bool MostVisitedSites::DoesSourceExist(NTPTileSource source) const {
+bool MostVisitedSites::DoesSourceExist(TileSource source) const {
   switch (source) {
-    case NTPTileSource::TOP_SITES:
+    case TileSource::TOP_SITES:
       return top_sites_ != nullptr;
-    case NTPTileSource::SUGGESTIONS_SERVICE:
+    case TileSource::SUGGESTIONS_SERVICE:
       return suggestions_service_ != nullptr;
-    case NTPTileSource::POPULAR:
+    case TileSource::POPULAR:
       return popular_sites_ != nullptr;
-    case NTPTileSource::WHITELIST:
+    case TileSource::WHITELIST:
       return supervisor_ != nullptr;
   }
   NOTREACHED();
   return false;
 }
 
 void MostVisitedSites::SetMostVisitedURLsObserver(Observer* observer,
                                                   int num_sites) {
   DCHECK(observer);
   observer_ = observer;
@@ skipping 36 matching lines @@
                                                  bool add_url) {
   if (top_sites_) {
     // Always blacklist in the local TopSites.
     if (add_url)
       top_sites_->AddBlacklistedURL(url);
     else
       top_sites_->RemoveBlacklistedURL(url);
   }
 
   // Only blacklist in the server-side suggestions service if it's active.
-  if (mv_source_ == NTPTileSource::SUGGESTIONS_SERVICE) {
+  if (mv_source_ == TileSource::SUGGESTIONS_SERVICE) {
     if (add_url)
       suggestions_service_->BlacklistURL(url);
     else
       suggestions_service_->UndoBlacklistURL(url);
   }
 }
 
 void MostVisitedSites::ClearBlacklistedUrls() {
   if (top_sites_) {
     // Always update the blacklist in the local TopSites.
     top_sites_->ClearBlacklistedURLs();
   }
 
   // Only update the server-side blacklist if it's active.
-  if (mv_source_ == NTPTileSource::SUGGESTIONS_SERVICE) {
+  if (mv_source_ == TileSource::SUGGESTIONS_SERVICE) {
     suggestions_service_->ClearBlacklist();
   }
 }
 
 void MostVisitedSites::OnBlockedSitesChanged() {
   BuildCurrentTiles();
 }
 
 // static
 void MostVisitedSites::RegisterProfilePrefs(
@@ skipping 19 matching lines @@
         return whitelist.large_icon_path;
     }
   }
   return base::FilePath();
 }
 
 void MostVisitedSites::OnMostVisitedURLsAvailable(
     const history::MostVisitedURLList& visited_list) {
   // Ignore the event if tiles provided by the Suggestions Service, which take
   // precedence.
-  if (mv_source_ == NTPTileSource::SUGGESTIONS_SERVICE) {
+  if (mv_source_ == TileSource::SUGGESTIONS_SERVICE) {
     return;
   }
 
   NTPTilesVector tiles;
   size_t num_tiles =
       std::min(visited_list.size(), static_cast<size_t>(num_sites_));
   for (size_t i = 0; i < num_tiles; ++i) {
     const history::MostVisitedURL& visited = visited_list[i];
     if (visited.url.is_empty())
       break;  // This is the signal that there are no more real visited sites.
     if (supervisor_ && supervisor_->IsBlocked(visited.url))
       continue;
 
     NTPTile tile;
     tile.title = visited.title;
     tile.url = visited.url;
-    tile.source = NTPTileSource::TOP_SITES;
+    tile.source = TileSource::TOP_SITES;
     tile.whitelist_icon_path = GetWhitelistLargeIconPath(visited.url);
 
     tiles.push_back(std::move(tile));
   }
 
-  mv_source_ = NTPTileSource::TOP_SITES;
+  mv_source_ = TileSource::TOP_SITES;
   SaveNewTilesAndNotify(std::move(tiles));
 }
 
 void MostVisitedSites::OnSuggestionsProfileChanged(
     const SuggestionsProfile& suggestions_profile) {
   if (suggestions_profile.suggestions_size() == 0 &&
-      mv_source_ != NTPTileSource::SUGGESTIONS_SERVICE) {
+      mv_source_ != TileSource::SUGGESTIONS_SERVICE) {
     return;
   }
 
   BuildCurrentTilesGivenSuggestionsProfile(suggestions_profile);
 }
 
 void MostVisitedSites::BuildCurrentTiles() {
   BuildCurrentTilesGivenSuggestionsProfile(
       suggestions_service_->GetSuggestionsDataFromCache().value_or(
           SuggestionsProfile()));
 }
 
 void MostVisitedSites::BuildCurrentTilesGivenSuggestionsProfile(
     const suggestions::SuggestionsProfile& suggestions_profile) {
   int num_tiles = suggestions_profile.suggestions_size();
   // With no server suggestions, fall back to local TopSites.
   if (num_tiles == 0 ||
       !base::FeatureList::IsEnabled(kDisplaySuggestionsServiceTiles)) {
-    mv_source_ = NTPTileSource::TOP_SITES;
+    mv_source_ = TileSource::TOP_SITES;
     InitiateTopSitesQuery();
     return;
   }
   if (num_sites_ < num_tiles)
     num_tiles = num_sites_;
 
   NTPTilesVector tiles;
   for (int i = 0; i < num_tiles; ++i) {
     const ChromeSuggestion& suggestion_pb = suggestions_profile.suggestions(i);
     GURL url(suggestion_pb.url());
     if (supervisor_ && supervisor_->IsBlocked(url))
       continue;
 
     NTPTile tile;
     tile.title = base::UTF8ToUTF16(suggestion_pb.title());
     tile.url = url;
-    tile.source = NTPTileSource::SUGGESTIONS_SERVICE;
+    tile.source = TileSource::SUGGESTIONS_SERVICE;
     tile.whitelist_icon_path = GetWhitelistLargeIconPath(url);
     tile.thumbnail_url = GURL(suggestion_pb.thumbnail());
     tile.favicon_url = GURL(suggestion_pb.favicon_url());
 
     tiles.push_back(std::move(tile));
   }
 
-  mv_source_ = NTPTileSource::SUGGESTIONS_SERVICE;
+  mv_source_ = TileSource::SUGGESTIONS_SERVICE;
   SaveNewTilesAndNotify(std::move(tiles));
 }
 
 NTPTilesVector MostVisitedSites::CreateWhitelistEntryPointTiles(
     const NTPTilesVector& personal_tiles) {
   if (!supervisor_) {
     return NTPTilesVector();
   }
 
   size_t num_personal_tiles = personal_tiles.size();
@@ skipping 19 matching lines @@
         personal_hosts.end())
       continue;
 
     // Skip whitelist entry points that are manually blocked.
     if (supervisor_->IsBlocked(whitelist.entry_point))
       continue;
 
     NTPTile tile;
     tile.title = whitelist.title;
     tile.url = whitelist.entry_point;
-    tile.source = NTPTileSource::WHITELIST;
+    tile.source = TileSource::WHITELIST;
     tile.whitelist_icon_path = whitelist.large_icon_path;
     whitelist_tiles.push_back(std::move(tile));
   }
 
   return whitelist_tiles;
 }
 
 NTPTilesVector MostVisitedSites::CreatePopularSitesTiles(
     const NTPTilesVector& personal_tiles,
     const NTPTilesVector& whitelist_tiles) {
@@ skipping 21 matching lines @@
       if (top_sites_ && top_sites_->IsBlacklisted(popular_site.url))
         continue;
       std::string host = popular_site.url.host();
       // Skip tiles already present in personal or whitelists.
       if (hosts.find(host) != hosts.end())
         continue;
 
       NTPTile tile;
       tile.title = popular_site.title;
       tile.url = GURL(popular_site.url);
-      tile.source = NTPTileSource::POPULAR;
+      tile.source = TileSource::POPULAR;
 
       popular_sites_tiles.push_back(std::move(tile));
       base::Closure icon_available =
           base::Bind(&MostVisitedSites::OnIconMadeAvailable,
                      base::Unretained(this), popular_site.url);
       icon_cacher_->StartFetch(popular_site, icon_available, icon_available);
       if (popular_sites_tiles.size() >= num_popular_sites_tiles)
         break;
     }
   }
@@ skipping 15 matching lines @@
                  std::move(popular_sites_tiles));
   if (current_tiles_.has_value() && (*current_tiles_ == new_tiles)) {
     return;
   }
 
   current_tiles_.emplace(std::move(new_tiles));
   DCHECK_EQ(num_actual_tiles, current_tiles_->size());
 
   int num_personal_tiles = 0;
   for (const auto& tile : *current_tiles_) {
-    if (tile.source != NTPTileSource::POPULAR)
+    if (tile.source != TileSource::POPULAR)
       num_personal_tiles++;
   }
   prefs_->SetInteger(prefs::kNumPersonalTiles, num_personal_tiles);
 
   if (!observer_)
     return;
   observer_->OnMostVisitedURLsAvailable(*current_tiles_);
 }
 
 // static
@@ skipping 23 matching lines @@
 }
 
 void MostVisitedSites::OnIconMadeAvailable(const GURL& site_url) {
   observer_->OnIconMadeAvailable(site_url);
 }
 
 void MostVisitedSites::TopSitesLoaded(TopSites* top_sites) {}
 
 void MostVisitedSites::TopSitesChanged(TopSites* top_sites,
                                        ChangeReason change_reason) {
-  if (mv_source_ == NTPTileSource::TOP_SITES) {
+  if (mv_source_ == TileSource::TOP_SITES) {
     // The displayed tiles are invalidated.
     InitiateTopSitesQuery();
   }
 }
 
 }  // namespace ntp_tiles