[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() {
+  if (!remote_suggestions_scheduler_->AcquireQuotaForInteractiveFetch()) {
+    return;
+  }
   FetchSuggestions(/*interactive_request=*/true,
                    /*callback=*/nullptr);
 }
 
 void RemoteSuggestionsProviderImpl::RefetchInTheBackground(
     std::unique_ptr<FetchStatusCallback> callback) {
   FetchSuggestions(/*interactive_request=*/false, std::move(callback));
 }
 
 const RemoteSuggestionsFetcher*
@@ skipping 24 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;
+  }
   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));
@@ skipping 255 matching lines @@
 
   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.
+  remote_suggestions_scheduler_->OnInteractiveFetchFinished(status);
   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 64 matching lines @@
   auto content_it = category_contents_.find(articles_category_);
   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 (interactive_request) {
+    remote_suggestions_scheduler_->OnInteractiveFetchFinished(status);
+  }
+
   if (callback) {
     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(),
@@ skipping 125 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