[Remote suggestions] Refactor the scheduler

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 238 matching lines @@
       suggestion_id.id_within_category(), url,
       base::Bind(&CachedImageFetcher::OnImageDecodingDone,
                  base::Unretained(this), callback));
 }
 
 RemoteSuggestionsProviderImpl::RemoteSuggestionsProviderImpl(
     Observer* observer,
     PrefService* pref_service,
     const std::string& application_language_code,
     CategoryRanker* category_ranker,
+    RemoteSuggestionsScheduler* scheduler,
     std::unique_ptr<RemoteSuggestionsFetcher> suggestions_fetcher,
     std::unique_ptr<image_fetcher::ImageFetcher> image_fetcher,
     std::unique_ptr<RemoteSuggestionsDatabase> database,
     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),
+      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),
-      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.
   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 21 matching lines @@
 
 // static
 void RemoteSuggestionsProviderImpl::RegisterProfilePrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterListPref(prefs::kRemoteSuggestionCategories);
   registry->RegisterInt64Pref(prefs::kLastSuccessfulBackgroundFetchTime, 0);
 
   RemoteSuggestionsStatusService::RegisterProfilePrefs(registry);
 }
 
-void RemoteSuggestionsProviderImpl::SetRemoteSuggestionsScheduler(
-    RemoteSuggestionsScheduler* scheduler) {
-  remote_suggestions_scheduler_ = scheduler;
-  // Call the observer right away if we've reached any final state.
-  NotifyStateChanged();
-}
-
 void RemoteSuggestionsProviderImpl::ReloadSuggestions() {
-  FetchSuggestions(/*interactive_request=*/true,
-                   /*callback=*/nullptr);
+  if (!remote_suggestions_scheduler_->AcquireQuotaForInteractiveFetch()) {
+    return;
+  }
+  FetchSuggestions(
+      /*interactive_request=*/true,
+      base::MakeUnique<FetchStatusCallback>(base::Bind(
+          [](RemoteSuggestionsScheduler* scheduler, Status status_code) {
+            scheduler->OnInteractiveFetchFinished(status_code);
+          },
+          base::Unretained(remote_suggestions_scheduler_))));
 }
 
 void RemoteSuggestionsProviderImpl::RefetchInTheBackground(
     std::unique_ptr<FetchStatusCallback> callback) {
   FetchSuggestions(/*interactive_request=*/false, std::move(callback));
 }
 
 const RemoteSuggestionsFetcher*
 RemoteSuggestionsProviderImpl::suggestions_fetcher_for_debugging() const {
   return suggestions_fetcher_.get();
@@ skipping 22 matching lines @@
 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!"));
     return;
   }
+  if (!remote_suggestions_scheduler_->AcquireQuotaForInteractiveFetch()) {
+    CallWithEmptyResults(callback, Status(StatusCode::TEMPORARY_ERROR,
+                                          "Interactive quota exceeded!"));
+    return;
+  }
+  // Make sure after the fetch, the scheduler is informed about the status.
+  FetchDoneCallback callback_wrapper = base::Bind(
+      [](RemoteSuggestionsScheduler* scheduler,
+         const FetchDoneCallback& callback, Status status_code,
+         std::vector<ContentSuggestion> suggestions) {
+        scheduler->OnInteractiveFetchFinished(status_code);
+        callback.Run(status_code, std::move(suggestions));
+      },
+      base::Unretained(remote_suggestions_scheduler_), callback);
+
   RequestParams params = BuildFetchParams();
   params.excluded_ids.insert(known_suggestion_ids.begin(),
                              known_suggestion_ids.end());
   params.interactive_request = true;
   params.exclusive_category = category;
 
   suggestions_fetcher_->FetchSnippets(
       params,
       base::BindOnce(&RemoteSuggestionsProviderImpl::OnFetchMoreFinished,
-                     base::Unretained(this), callback));
+                     base::Unretained(this), callback_wrapper));
 }
 
 // Builds default fetcher params.
 RequestParams RemoteSuggestionsProviderImpl::BuildFetchParams() const {
   RequestParams result;
   result.language_code = application_language_code_;
   result.count_to_fetch = kMaxSuggestionCount;
   for (const auto& map_entry : category_contents_) {
     const CategoryContent& content = map_entry.second;
     for (const auto& dismissed_suggestion : content.dismissed) {
@@ skipping 244 matching lines @@
   DCHECK(existing_content->suggestions.empty());
 
   IntegrateSuggestions(existing_content,
                        std::move(fetched_category.suggestions));
 
   // 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);
-  // Notify callers and observers.
   fetching_callback.Run(Status::Success(), std::move(result));
   NotifyNewSuggestions(category, *existing_content);
 }
 
 void RemoteSuggestionsProviderImpl::OnFetchFinished(
     std::unique_ptr<FetchStatusCallback> callback,
     bool interactive_request,
     Status status,
     RemoteSuggestionsFetcher::OptionalFetchedCategories fetched_categories) {
   if (!ready()) {
@@ skipping 209 matching lines @@
   database_->GarbageCollectImages(std::move(alive_suggestions));
 }
 
 void RemoteSuggestionsProviderImpl::ClearHistoryDependentState() {
   if (!initialized()) {
     clear_history_dependent_state_when_initialized_ = true;
     return;
   }
 
   NukeAllSuggestions();
-  if (remote_suggestions_scheduler_) {
-    remote_suggestions_scheduler_->OnHistoryCleared();
-  }
+  remote_suggestions_scheduler_->OnHistoryCleared();
 }
 
 void RemoteSuggestionsProviderImpl::ClearSuggestions() {
   DCHECK(initialized());
 
   NukeAllSuggestions();
-  if (remote_suggestions_scheduler_) {
-    remote_suggestions_scheduler_->OnSuggestionsCleared();
-  }
+  remote_suggestions_scheduler_->OnSuggestionsCleared();
 }
 
 void RemoteSuggestionsProviderImpl::NukeAllSuggestions() {
   for (const auto& item : category_contents_) {
     Category category = item.first;
     const CategoryContent& content = item.second;
 
     ClearCachedSuggestions(category);
     // Update listeners about the new (empty) state.
     if (IsCategoryStatusAvailable(content.status)) {
@@ skipping 166 matching lines @@
       EnterStateError();
       break;
 
     case State::COUNT:
       NOTREACHED();
       break;
   }
 }
 
 void RemoteSuggestionsProviderImpl::NotifyStateChanged() {
-  if (!remote_suggestions_scheduler_) {
-    return;
-  }
-
   switch (state_) {
     case State::NOT_INITED:
       // Initial state, not sure yet whether active or not.
       break;
     case State::READY:
       remote_suggestions_scheduler_->OnProviderActivated();
       break;
     case State::DISABLED:
       remote_suggestions_scheduler_->OnProviderDeactivated();
       break;
@@ skipping 184 matching lines @@
 RemoteSuggestionsProviderImpl::CategoryContent::CategoryContent(
     CategoryContent&&) = default;
 
 RemoteSuggestionsProviderImpl::CategoryContent::~CategoryContent() = default;
 
 RemoteSuggestionsProviderImpl::CategoryContent&
 RemoteSuggestionsProviderImpl::CategoryContent::operator=(CategoryContent&&) =
     default;
 
 }  // namespace ntp_snippets