ntp_snippets: Use base::EraseIf()

components/ntp_snippets/remote/remote_suggestions_provider_impl.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_snippets/remote/remote_suggestions_provider_impl.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
@@ skipping 56 matching lines @@
     if (base::ContainsValue(b, item)) {
       return true;
     }
   }
   return false;
 }
 
 void EraseByPrimaryID(RemoteSuggestion::PtrVector* suggestions,
                       const std::vector<std::string>& ids) {
   std::set<std::string> ids_lookup(ids.begin(), ids.end());
-  suggestions->erase(
-      std::remove_if(
-          suggestions->begin(), suggestions->end(),
-          [&ids_lookup](const std::unique_ptr<RemoteSuggestion>& suggestion) {
-            return base::ContainsValue(ids_lookup, suggestion->id());
-          }),
-      suggestions->end());
+  base::EraseIf(
+      *suggestions,
+      [&ids_lookup](const std::unique_ptr<RemoteSuggestion>& suggestion) {
+        return base::ContainsValue(ids_lookup, suggestion->id());
+      });
 }
 
 void EraseMatchingSuggestions(
     RemoteSuggestion::PtrVector* suggestions,
     const RemoteSuggestion::PtrVector& compare_against) {
   std::set<std::string> compare_against_ids;
   for (const std::unique_ptr<RemoteSuggestion>& suggestion : compare_against) {
     const std::vector<std::string>& suggestion_ids = suggestion->GetAllIDs();
     compare_against_ids.insert(suggestion_ids.begin(), suggestion_ids.end());
   }
-  suggestions->erase(
-      std::remove_if(suggestions->begin(), suggestions->end(),
-                     [&compare_against_ids](
-                         const std::unique_ptr<RemoteSuggestion>& suggestion) {
-                       return HasIntersection(suggestion->GetAllIDs(),
-                                              compare_against_ids);
-                     }),
-      suggestions->end());
+  base::EraseIf(
+      *suggestions, [&compare_against_ids](
+                        const std::unique_ptr<RemoteSuggestion>& suggestion) {
+        return HasIntersection(suggestion->GetAllIDs(), compare_against_ids);
+      });
 }
 
 void RemoveNullPointers(RemoteSuggestion::PtrVector* suggestions) {
-  suggestions->erase(
-      std::remove_if(suggestions->begin(), suggestions->end(),
-                     [](const std::unique_ptr<RemoteSuggestion>& suggestion) {
-                       return !suggestion;
-                     }),
-      suggestions->end());
+  base::EraseIf(*suggestions,
+                [](const std::unique_ptr<RemoteSuggestion>& suggestion) {
+                  return !suggestion;
+                });
 }
 
 void RemoveIncompleteSuggestions(RemoteSuggestion::PtrVector* suggestions) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAddIncompleteSnippets)) {
     return;
   }
   int num_suggestions = suggestions->size();
   // Remove suggestions that do not have all the info we need to display it to
   // the user.
-  suggestions->erase(
-      std::remove_if(suggestions->begin(), suggestions->end(),
-                     [](const std::unique_ptr<RemoteSuggestion>& suggestion) {
-                       return !suggestion->is_complete();
-                     }),
-      suggestions->end());
+  base::EraseIf(*suggestions,
+                [](const std::unique_ptr<RemoteSuggestion>& suggestion) {
+                  return !suggestion->is_complete();
+                });
   int num_suggestions_removed = num_suggestions - suggestions->size();
   UMA_HISTOGRAM_BOOLEAN("NewTabPage.Snippets.IncompleteSnippetsAfterFetch",
                         num_suggestions_removed > 0);
   if (num_suggestions_removed > 0) {
     UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.NumIncompleteSnippets",
                                 num_suggestions_removed);
   }
 }
 
 std::vector<ContentSuggestion> ConvertToContentSuggestions(
@@ skipping 100 matching lines @@
   }
   // If decoding the image failed, delete the DB entry.
   database_->DeleteImage(suggestion_id.id_within_category());
   FetchImageFromNetwork(suggestion_id, url, callback);
 }
 
 void CachedImageFetcher::FetchImageFromNetwork(
     const ContentSuggestion::ID& suggestion_id,
     const GURL& url,
     const ImageFetchedCallback& callback) {
-  if (url.is_empty() ||
-      !thumbnail_requests_throttler_.DemandQuotaForRequest(
-          /*interactive_request=*/true)) {
+  if (url.is_empty() || !thumbnail_requests_throttler_.DemandQuotaForRequest(
+                            /*interactive_request=*/true)) {
     // Return an empty image. Directly, this is never synchronous with the
     // original FetchSuggestionImage() call - an asynchronous database query has
     // happened in the meantime.
     callback.Run(gfx::Image());
     return;
   }
 
   image_fetcher_->StartOrQueueNetworkRequest(
       suggestion_id.id_within_category(), url,
       base::Bind(&CachedImageFetcher::OnImageDecodingDone,
@@ skipping 11 matching lines @@
     std::unique_ptr<RemoteSuggestionsStatusService> status_service)
     : RemoteSuggestionsProvider(observer),
       state_(State::NOT_INITED),
       pref_service_(pref_service),
       articles_category_(
           Category::FromKnownCategory(KnownCategories::ARTICLES)),
       application_language_code_(application_language_code),
       category_ranker_(category_ranker),
       suggestions_fetcher_(std::move(suggestions_fetcher)),
       database_(std::move(database)),
-      image_fetcher_(std::move(image_fetcher),
-                     pref_service,
-                     database_.get()),
+      image_fetcher_(std::move(image_fetcher), pref_service, database_.get()),
       status_service_(std::move(status_service)),
       fetch_when_ready_(false),
       fetch_when_ready_interactive_(false),
       fetch_when_ready_callback_(nullptr),
       remote_suggestions_scheduler_(nullptr),
       clear_history_dependent_state_when_initialized_(false),
       clock_(base::MakeUnique<base::DefaultClock>()) {
   RestoreCategoriesFromPrefs();
   // The articles category always exists. Add it if we didn't get it from prefs.
   // TODO(treib): Rethink this.
@@ skipping 987 matching lines @@
 RemoteSuggestionsProviderImpl::CategoryContent::CategoryContent(
     CategoryContent&&) = default;
 
 RemoteSuggestionsProviderImpl::CategoryContent::~CategoryContent() = default;
 
 RemoteSuggestionsProviderImpl::CategoryContent&
 RemoteSuggestionsProviderImpl::CategoryContent::operator=(CategoryContent&&) =
     default;
 
 }  // namespace ntp_snippets