[Remote suggestions] Move the throttler into the Scheduler

components/ntp_snippets/remote/scheduling_remote_suggestions_provider.cc

 // Copyright 2016 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/scheduling_remote_suggestions_provider.h"
 
 #include <random>
 #include <string>
 #include <utility>
 
@@ skipping 168 matching lines @@
     PersistentScheduler* persistent_scheduler,
     const UserClassifier* user_classifier,
     PrefService* pref_service,
     std::unique_ptr<base::Clock> clock)
     : RemoteSuggestionsProvider(observer),
       RemoteSuggestionsScheduler(),
       provider_(std::move(provider)),
       persistent_scheduler_(persistent_scheduler),
       background_fetch_in_progress_(false),
       user_classifier_(user_classifier),
+      request_throttler_rare_ntp_user_(
+          pref_service,
+          RequestThrottler::RequestType::
+              CONTENT_SUGGESTION_FETCHER_RARE_NTP_USER),
+      request_throttler_active_ntp_user_(
+          pref_service,
+          RequestThrottler::RequestType::
+              CONTENT_SUGGESTION_FETCHER_ACTIVE_NTP_USER),
+      request_throttler_active_suggestions_consumer_(
+          pref_service,
+          RequestThrottler::RequestType::
+              CONTENT_SUGGESTION_FETCHER_ACTIVE_SUGGESTIONS_CONSUMER),
       pref_service_(pref_service),
       clock_(std::move(clock)),
       enabled_triggers_(GetEnabledTriggerTypes()) {
   DCHECK(user_classifier);
   DCHECK(pref_service);
 
   LoadLastFetchingSchedule();
 }
 
 SchedulingRemoteSuggestionsProvider::~SchedulingRemoteSuggestionsProvider() =
@@ skipping 77 matching lines @@
 void SchedulingRemoteSuggestionsProvider::RefetchInTheBackground(
     std::unique_ptr<FetchStatusCallback> callback) {
   if (background_fetch_in_progress_) {
     if (callback) {
       callback->Run(
           Status(StatusCode::TEMPORARY_ERROR, "Background fetch in progress"));
     }
     return;
   }
 
+  if (!AcquireQuota(/*interactive_request=*/false)) {
+    if (callback) {
+      callback->Run(Status(StatusCode::TEMPORARY_ERROR,
+                           "Non-interactive quota exceeded"));
+    }
+    return;
+  }
+
   background_fetch_in_progress_ = true;
   RemoteSuggestionsProvider::FetchStatusCallback wrapper_callback = base::Bind(
       &SchedulingRemoteSuggestionsProvider::RefetchInTheBackgroundFinished,
       base::Unretained(this), base::Passed(&callback));
   provider_->RefetchInTheBackground(
       base::MakeUnique<RemoteSuggestionsProvider::FetchStatusCallback>(
           std::move(wrapper_callback)));
 }
 
 const RemoteSuggestionsFetcher*
@@ skipping 19 matching lines @@
 void SchedulingRemoteSuggestionsProvider::FetchSuggestionImage(
     const ContentSuggestion::ID& suggestion_id,
     const ImageFetchedCallback& callback) {
   provider_->FetchSuggestionImage(suggestion_id, callback);
 }
 
 void SchedulingRemoteSuggestionsProvider::Fetch(
     const Category& category,
     const std::set<std::string>& known_suggestion_ids,
     const FetchDoneCallback& callback) {
+  if (!AcquireQuota(/*interactive_request=*/true)) {
+    if (callback) {
+      callback.Run(
+          Status(StatusCode::TEMPORARY_ERROR, "Interactive quota exceeded"),
+          std::vector<ContentSuggestion>());
+    }
+    return;
+  }
+
   provider_->Fetch(
       category, known_suggestion_ids,
       base::Bind(&SchedulingRemoteSuggestionsProvider::FetchFinished,
                  base::Unretained(this), callback));
 }
 
 void SchedulingRemoteSuggestionsProvider::ReloadSuggestions() {
+  if (!AcquireQuota(/*interactive_request=*/true)) {
+    return;
+  }
+
   provider_->ReloadSuggestions();
 }
 
 void SchedulingRemoteSuggestionsProvider::ClearHistory(
     base::Time begin,
     base::Time end,
     const base::Callback<bool(const GURL& url)>& filter) {
   provider_->ClearHistory(begin, end, filter);
 }
 
@@ skipping 140 matching lines @@
   if (schedule_.is_empty()) {
     return true;  // Background fetches are disabled in general.
   }
 
   if (enabled_triggers_.count(trigger) == 0) {
     return true;  // Background fetches for |trigger| are not enabled.
   }
   return false;
 }
 
+bool SchedulingRemoteSuggestionsProvider::AcquireQuota(
+    bool interactive_request) {
+  switch (user_classifier_->GetUserClass()) {
+    case UserClassifier::UserClass::RARE_NTP_USER:
+      return request_throttler_rare_ntp_user_.DemandQuotaForRequest(
+          interactive_request);
+    case UserClassifier::UserClass::ACTIVE_NTP_USER:
+      return request_throttler_active_ntp_user_.DemandQuotaForRequest(
+          interactive_request);
+    case UserClassifier::UserClass::ACTIVE_SUGGESTIONS_CONSUMER:
+      return request_throttler_active_suggestions_consumer_
+          .DemandQuotaForRequest(interactive_request);
+  }
+  NOTREACHED();
+  return false;
+}
+
 void SchedulingRemoteSuggestionsProvider::FetchFinished(
     const FetchDoneCallback& callback,
     Status fetch_status,
     std::vector<ContentSuggestion> suggestions) {
   OnFetchCompleted(fetch_status);
   if (callback) {
     callback.Run(fetch_status, std::move(suggestions));
   }
 }
 
@@ skipping 65 matching lines @@
   return enabled_types;
 }
 
 std::set<SchedulingRemoteSuggestionsProvider::TriggerType>
 SchedulingRemoteSuggestionsProvider::GetDefaultEnabledTriggerTypes() {
   return {TriggerType::PERSISTENT_SCHEDULER_WAKE_UP, TriggerType::NTP_OPENED,
           TriggerType::BROWSER_FOREGROUNDED};
 }
 
 }  // namespace ntp_snippets