[Remote suggestions] Remove the unique_ptr wrapper around callbacks

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 257 matching lines @@
           Category::FromKnownCategory(KnownCategories::ARTICLES)),
       application_language_code_(application_language_code),
       category_ranker_(category_ranker),
       remote_suggestions_scheduler_(scheduler),
       suggestions_fetcher_(std::move(suggestions_fetcher)),
       database_(std::move(database)),
       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),
       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.
   category_contents_.insert(
       std::make_pair(articles_category_,
                      CategoryContent(BuildArticleCategoryInfo(base::nullopt))));
   // Tell the observer about all the categories.
   for (const auto& entry : category_contents_) {
@@ skipping 27 matching lines @@
 
   RemoteSuggestionsStatusService::RegisterProfilePrefs(registry);
 }
 
 void RemoteSuggestionsProviderImpl::ReloadSuggestions() {
   if (!remote_suggestions_scheduler_->AcquireQuotaForInteractiveFetch()) {
     return;
   }
   FetchSuggestions(
       /*interactive_request=*/true,
-      base::MakeUnique<FetchStatusCallback>(base::Bind(
+      base::Bind(
           [](RemoteSuggestionsScheduler* scheduler, Status status_code) {
             scheduler->OnInteractiveFetchFinished(status_code);
           },
-          base::Unretained(remote_suggestions_scheduler_))));
+          base::Unretained(remote_suggestions_scheduler_)));
 }
 
 void RemoteSuggestionsProviderImpl::RefetchInTheBackground(
-    std::unique_ptr<FetchStatusCallback> callback) {
-  FetchSuggestions(/*interactive_request=*/false, std::move(callback));
+    const FetchStatusCallback& callback) {
+  FetchSuggestions(/*interactive_request=*/false, callback);
 }
 
 const RemoteSuggestionsFetcher*
 RemoteSuggestionsProviderImpl::suggestions_fetcher_for_debugging() const {
   return suggestions_fetcher_.get();
 }
 
 void RemoteSuggestionsProviderImpl::FetchSuggestions(
     bool interactive_request,
-    std::unique_ptr<FetchStatusCallback> callback) {
+    const FetchStatusCallback& callback) {
   if (!ready()) {
     fetch_when_ready_ = true;
     fetch_when_ready_interactive_ = interactive_request;
-    fetch_when_ready_callback_ = std::move(callback);
+    fetch_when_ready_callback_ = callback;
     return;
   }
 
   MarkEmptyCategoriesAsLoading();
 
   RequestParams params = BuildFetchParams();
   params.interactive_request = interactive_request;
   suggestions_fetcher_->FetchSnippets(
-      params, base::BindOnce(&RemoteSuggestionsProviderImpl::OnFetchFinished,
-                             base::Unretained(this), std::move(callback),
-                             interactive_request));
+      params,
+      base::BindOnce(&RemoteSuggestionsProviderImpl::OnFetchFinished,
+                     base::Unretained(this), callback, interactive_request));
 }
 
 void RemoteSuggestionsProviderImpl::Fetch(
     const Category& category,
     const std::set<std::string>& known_suggestion_ids,
     const FetchDoneCallback& callback) {
   if (!ready()) {
     CallWithEmptyResults(callback,
                          Status(StatusCode::TEMPORARY_ERROR,
                                 "RemoteSuggestionsProvider is not ready!"));
@@ skipping 286 matching lines @@
   // TODO(tschumann): We should properly honor the existing category state,
   // e.g. to make sure we don't serve results after the sign-out. Revisit this:
   // Should Nuke also cancel outstanding requests, or do we want to check the
   // status?
   UpdateCategoryStatus(category, CategoryStatus::AVAILABLE);
   fetching_callback.Run(Status::Success(), std::move(result));
   NotifyNewSuggestions(category, *existing_content);
 }
 
 void RemoteSuggestionsProviderImpl::OnFetchFinished(
-    std::unique_ptr<FetchStatusCallback> callback,
+    const FetchStatusCallback& callback,
     bool interactive_request,
     Status status,
     RemoteSuggestionsFetcher::OptionalFetchedCategories fetched_categories) {
   if (!ready()) {
     // TODO(tschumann): What happens if this was a user-triggered, interactive
     // request? Is the UI waiting indefinitely now?
     return;
   }
 
   // Record the fetch time of a successfull background fetch.
@@ skipping 59 matching lines @@
   DCHECK(content_it != category_contents_.end());
   const CategoryContent& content = content_it->second;
   UMA_HISTOGRAM_SPARSE_SLOWLY("NewTabPage.Snippets.NumArticles",
                               content.suggestions.size());
   if (content.suggestions.empty() && !content.dismissed.empty()) {
     UMA_HISTOGRAM_COUNTS("NewTabPage.Snippets.NumArticlesZeroDueToDiscarded",
                          content.dismissed.size());
   }
 
   if (callback) {
-    callback->Run(status);
+    callback.Run(status);
   }
 }
 
 void RemoteSuggestionsProviderImpl::ArchiveSuggestions(
     CategoryContent* content,
     RemoteSuggestion::PtrVector* to_archive) {
   // Archive previous suggestions - move them at the beginning of the list.
   content->archived.insert(content->archived.begin(),
                            std::make_move_iterator(to_archive->begin()),
                            std::make_move_iterator(to_archive->end()));
@@ skipping 179 matching lines @@
 
 void RemoteSuggestionsProviderImpl::EnterStateReady() {
   if (clear_history_dependent_state_when_initialized_) {
     clear_history_dependent_state_when_initialized_ = false;
     ClearHistoryDependentState();
   }
 
   auto article_category_it = category_contents_.find(articles_category_);
   DCHECK(article_category_it != category_contents_.end());
   if (fetch_when_ready_) {
-    FetchSuggestions(fetch_when_ready_interactive_,
-                     std::move(fetch_when_ready_callback_));
+    FetchSuggestions(fetch_when_ready_interactive_, fetch_when_ready_callback_);
     fetch_when_ready_ = false;
   }
 
   for (const auto& item : category_contents_) {
     Category category = item.first;
     const CategoryContent& content = item.second;
     // FetchSuggestions has set the status to |AVAILABLE_LOADING| if relevant,
     // otherwise we transition to |AVAILABLE| here.
     if (content.status != CategoryStatus::AVAILABLE_LOADING) {
       UpdateCategoryStatus(category, CategoryStatus::AVAILABLE);
@@ skipping 320 matching lines @@
 RemoteSuggestionsProviderImpl::CategoryContent::CategoryContent(
     CategoryContent&&) = default;
 
 RemoteSuggestionsProviderImpl::CategoryContent::~CategoryContent() = default;
 
 RemoteSuggestionsProviderImpl::CategoryContent&
 RemoteSuggestionsProviderImpl::CategoryContent::operator=(CategoryContent&&) =
     default;
 
 }  // namespace ntp_snippets