MostVisitedSites cleanup: kill SuggestionsPtrVector

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 <utility>
 
@@ skipping 146 matching lines @@
     case MostVisitedSites::SUGGESTIONS_SERVICE:
       return suggestion.provider_index >= 0
                  ? base::StringPrintf(kHistogramServerFormat,
                                       suggestion.provider_index)
                  : kHistogramServerName;
   }
   NOTREACHED();
   return std::string();
 }
 
+void AppendSuggestions(MostVisitedSites::SuggestionsVector src,
+                       MostVisitedSites::SuggestionsVector* dst) {
+  dst->insert(dst->end(),
+              std::make_move_iterator(src.begin()),
+              std::make_move_iterator(src.end()));
+}
+
 }  // namespace
 
 MostVisitedSites::Suggestion::Suggestion() : provider_index(-1) {}
 
 MostVisitedSites::Suggestion::~Suggestion() {}
 
 MostVisitedSites::Suggestion::Suggestion(Suggestion&&) = default;
 MostVisitedSites::Suggestion&
 MostVisitedSites::Suggestion::operator=(Suggestion&&) = default;
 
@@ skipping 216 matching lines @@
 base::FilePath MostVisitedSites::GetWhitelistLargeIconPath(const GURL& url) {
   for (const auto& whitelist : supervisor_->whitelists()) {
     if (AreURLsEquivalent(whitelist.entry_point, url))
       return whitelist.large_icon_path;
   }
   return base::FilePath();
 }
 
 void MostVisitedSites::OnMostVisitedURLsAvailable(
     const history::MostVisitedURLList& visited_list) {
-  SuggestionsPtrVector suggestions;
+  SuggestionsVector suggestions;
   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()) {
       num_tiles = i;
       break;  // This is the signal that there are no more real visited sites.
     }
     if (supervisor_->IsBlocked(visited.url))
       continue;
 
-    std::unique_ptr<Suggestion> suggestion(new Suggestion());
-    suggestion->title = visited.title;
-    suggestion->url = visited.url;
-    suggestion->source = TOP_SITES;
-    suggestion->whitelist_icon_path = GetWhitelistLargeIconPath(visited.url);
+    Suggestion suggestion;
+    suggestion.title = visited.title;
+    suggestion.url = visited.url;
+    suggestion.source = TOP_SITES;
+    suggestion.whitelist_icon_path = GetWhitelistLargeIconPath(visited.url);
 
     suggestions.push_back(std::move(suggestion));
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = TOP_SITES;
-  SaveNewSuggestions(&suggestions);
+  SaveNewSuggestions(std::move(suggestions));
   NotifyMostVisitedURLsObserver();
 }
 
 void MostVisitedSites::OnSuggestionsProfileAvailable(
     const 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)) {
     InitiateTopSitesQuery();
     return;
   }
   if (num_sites_ < num_tiles)
     num_tiles = num_sites_;
 
-  SuggestionsPtrVector suggestions;
+  SuggestionsVector suggestions;
   for (int i = 0; i < num_tiles; ++i) {
     const ChromeSuggestion& suggestion = suggestions_profile.suggestions(i);
     if (supervisor_->IsBlocked(GURL(suggestion.url())))
       continue;
 
-    std::unique_ptr<Suggestion> generated_suggestion(new Suggestion());
-    generated_suggestion->title = base::UTF8ToUTF16(suggestion.title());
-    generated_suggestion->url = GURL(suggestion.url());
-    generated_suggestion->source = SUGGESTIONS_SERVICE;
-    generated_suggestion->whitelist_icon_path = GetWhitelistLargeIconPath(
-        GURL(suggestion.url()));
+    Suggestion generated_suggestion;
+    generated_suggestion.title = base::UTF8ToUTF16(suggestion.title());
+    generated_suggestion.url = GURL(suggestion.url());
+    generated_suggestion.source = SUGGESTIONS_SERVICE;
+    generated_suggestion.whitelist_icon_path =
+        GetWhitelistLargeIconPath(GURL(suggestion.url()));
     if (suggestion.providers_size() > 0)
-      generated_suggestion->provider_index = suggestion.providers(0);
+      generated_suggestion.provider_index = suggestion.providers(0);
 
     suggestions.push_back(std::move(generated_suggestion));
   }
 
   received_most_visited_sites_ = true;
   mv_source_ = SUGGESTIONS_SERVICE;
-  SaveNewSuggestions(&suggestions);
+  SaveNewSuggestions(std::move(suggestions));
   NotifyMostVisitedURLsObserver();
 }
 
-MostVisitedSites::SuggestionsPtrVector
+MostVisitedSites::SuggestionsVector
 MostVisitedSites::CreateWhitelistEntryPointSuggestions(
-    const SuggestionsPtrVector& personal_suggestions) {
+    const SuggestionsVector& personal_suggestions) {
   size_t num_personal_suggestions = personal_suggestions.size();
   DCHECK_LE(num_personal_suggestions, static_cast<size_t>(num_sites_));
 
   size_t num_whitelist_suggestions = num_sites_ - num_personal_suggestions;
-  SuggestionsPtrVector whitelist_suggestions;
+  SuggestionsVector whitelist_suggestions;
 
   std::set<std::string> personal_hosts;
   for (const auto& suggestion : personal_suggestions)
-    personal_hosts.insert(suggestion->url.host());
+    personal_hosts.insert(suggestion.url.host());
 
   for (const auto& whitelist : supervisor_->whitelists()) {
     // Skip blacklisted sites.
     if (top_sites_->IsBlacklisted(whitelist.entry_point))
       continue;
 
     // Skip suggestions already present.
     if (personal_hosts.find(whitelist.entry_point.host()) !=
         personal_hosts.end())
       continue;
 
     // Skip whitelist entry points that are manually blocked.
     if (supervisor_->IsBlocked(whitelist.entry_point))
       continue;
 
-    std::unique_ptr<Suggestion> suggestion(new Suggestion());
-    suggestion->title = whitelist.title;
-    suggestion->url = whitelist.entry_point;
-    suggestion->source = WHITELIST;
-    suggestion->whitelist_icon_path = whitelist.large_icon_path;
+    Suggestion suggestion;
+    suggestion.title = whitelist.title;
+    suggestion.url = whitelist.entry_point;
+    suggestion.source = WHITELIST;
+    suggestion.whitelist_icon_path = whitelist.large_icon_path;
 
     whitelist_suggestions.push_back(std::move(suggestion));
     if (whitelist_suggestions.size() >= num_whitelist_suggestions)
       break;
   }
 
   return whitelist_suggestions;
 }
 
-MostVisitedSites::SuggestionsPtrVector
+MostVisitedSites::SuggestionsVector
 MostVisitedSites::CreatePopularSitesSuggestions(
-    const SuggestionsPtrVector& personal_suggestions,
-    const SuggestionsPtrVector& whitelist_suggestions) {
+    const SuggestionsVector& personal_suggestions,
+    const SuggestionsVector& whitelist_suggestions) {
   // For child accounts popular sites suggestions will not be added.
   if (supervisor_->IsChildProfile())
-    return SuggestionsPtrVector();
+    return SuggestionsVector();
 
   size_t num_suggestions =
       personal_suggestions.size() + whitelist_suggestions.size();
   DCHECK_LE(num_suggestions, static_cast<size_t>(num_sites_));
 
   // Collect non-blacklisted popular suggestions, skipping those already present
   // in the personal suggestions.
   size_t num_popular_sites_suggestions = num_sites_ - num_suggestions;
-  SuggestionsPtrVector popular_sites_suggestions;
+  SuggestionsVector popular_sites_suggestions;
 
   if (num_popular_sites_suggestions > 0 && popular_sites_) {
     std::set<std::string> hosts;
     for (const auto& suggestion : personal_suggestions)
-      hosts.insert(suggestion->url.host());
+      hosts.insert(suggestion.url.host());
     for (const auto& suggestion : whitelist_suggestions)
-      hosts.insert(suggestion->url.host());
+      hosts.insert(suggestion.url.host());
     for (const PopularSites::Site& popular_site : popular_sites_->sites()) {
       // Skip blacklisted sites.
       if (top_sites_->IsBlacklisted(popular_site.url))
         continue;
       std::string host = popular_site.url.host();
       // Skip suggestions already present in personal or whitelists.
       if (hosts.find(host) != hosts.end())
         continue;
 
-      std::unique_ptr<Suggestion> suggestion(new Suggestion());
-      suggestion->title = popular_site.title;
-      suggestion->url = GURL(popular_site.url);
-      suggestion->source = POPULAR;
+      Suggestion suggestion;
+      suggestion.title = popular_site.title;
+      suggestion.url = GURL(popular_site.url);
+      suggestion.source = POPULAR;
 
       popular_sites_suggestions.push_back(std::move(suggestion));
       if (popular_sites_suggestions.size() >= num_popular_sites_suggestions)
         break;
     }
   }
   return popular_sites_suggestions;
 }
 
 void MostVisitedSites::SaveNewSuggestions(
-    SuggestionsPtrVector* personal_suggestions) {
-  SuggestionsPtrVector whitelist_suggestions =
-      CreateWhitelistEntryPointSuggestions(*personal_suggestions);
-  SuggestionsPtrVector popular_sites_suggestions =
-      CreatePopularSitesSuggestions(*personal_suggestions,
+    SuggestionsVector personal_suggestions) {
+  SuggestionsVector whitelist_suggestions =
+      CreateWhitelistEntryPointSuggestions(personal_suggestions);
+  SuggestionsVector popular_sites_suggestions =
+      CreatePopularSitesSuggestions(personal_suggestions,
                                     whitelist_suggestions);
 
-  size_t num_actual_tiles = personal_suggestions->size() +
+  size_t num_actual_tiles = personal_suggestions.size() +
                             whitelist_suggestions.size() +
                             popular_sites_suggestions.size();
   DCHECK_LE(num_actual_tiles, static_cast<size_t>(num_sites_));
 
-  SuggestionsPtrVector merged_suggestions = MergeSuggestions(
-      personal_suggestions, &whitelist_suggestions, &popular_sites_suggestions);
-  DCHECK_EQ(num_actual_tiles, merged_suggestions.size());
-
-  current_suggestions_.resize(merged_suggestions.size());
-  for (size_t i = 0; i < merged_suggestions.size(); ++i)
-    std::swap(*merged_suggestions[i], current_suggestions_[i]);
+  current_suggestions_ = MergeSuggestions(std::move(personal_suggestions),
+                                          std::move(whitelist_suggestions),
+                                          std::move(popular_sites_suggestions));
+  DCHECK_EQ(num_actual_tiles, current_suggestions_.size());
 
   if (received_popular_sites_)
     SaveCurrentSuggestionsToPrefs();
 }
 
 // static
-MostVisitedSites::SuggestionsPtrVector MostVisitedSites::MergeSuggestions(
-    SuggestionsPtrVector* personal_suggestions,
-    SuggestionsPtrVector* whitelist_suggestions,
-    SuggestionsPtrVector* popular_suggestions) {
-  size_t num_personal_suggestions = personal_suggestions->size();
-  size_t num_whitelist_suggestions = whitelist_suggestions->size();
-  size_t num_popular_suggestions = popular_suggestions->size();
-  size_t num_tiles = num_popular_suggestions + num_whitelist_suggestions +
-                     num_personal_suggestions;
-  SuggestionsPtrVector merged_suggestions;
-  AppendSuggestions(personal_suggestions, &merged_suggestions);
-  AppendSuggestions(whitelist_suggestions, &merged_suggestions);
-  AppendSuggestions(popular_suggestions, &merged_suggestions);
-  DCHECK_EQ(num_tiles, merged_suggestions.size());
-
+MostVisitedSites::SuggestionsVector MostVisitedSites::MergeSuggestions(
+    SuggestionsVector personal_suggestions,
+    SuggestionsVector whitelist_suggestions,
+    SuggestionsVector popular_suggestions) {
+  SuggestionsVector merged_suggestions;
+  AppendSuggestions(std::move(personal_suggestions), &merged_suggestions);
+  AppendSuggestions(std::move(whitelist_suggestions), &merged_suggestions);
+  AppendSuggestions(std::move(popular_suggestions), &merged_suggestions);
   return merged_suggestions;
 }
 
-// TODO(treib): Once we use SuggestionsVector (non-Ptr) everywhere, move this
-// into an anonymous namespace.
-// static
-void MostVisitedSites::AppendSuggestions(SuggestionsPtrVector* src,
-                                         SuggestionsPtrVector* dst) {
-  dst->insert(dst->end(),
-              std::make_move_iterator(src->begin()),
-              std::make_move_iterator(src->end()));
-}
-
 void MostVisitedSites::SaveCurrentSuggestionsToPrefs() {
   base::ListValue url_list;
   base::ListValue source_list;
   for (const auto& suggestion : current_suggestions_) {
     url_list.AppendString(suggestion.url.spec());
     source_list.AppendBoolean(suggestion.source != POPULAR);
   }
   prefs_->Set(ntp_tiles::prefs::kNTPSuggestionsIsPersonal, source_list);
   prefs_->Set(ntp_tiles::prefs::kNTPSuggestionsURL, url_list);
 }
@@ skipping 42 matching lines @@
 
 void MostVisitedSites::TopSitesChanged(TopSites* top_sites,
                                        ChangeReason change_reason) {
   if (mv_source_ == TOP_SITES) {
     // The displayed suggestions are invalidated.
     InitiateTopSitesQuery();
   }
 }
 
 }  // namespace ntp_tiles