[Remote suggestions] Refactor the scheduler

components/ntp_snippets/remote/remote_suggestions_scheduler_impl.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 "components/ntp_snippets/remote/remote_suggestions_scheduler_impl.h"
 
 #include <random>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial_params.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_split.h"
 #include "base/time/clock.h"
 #include "components/ntp_snippets/features.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/remote/persistent_scheduler.h"
+#include "components/ntp_snippets/remote/remote_suggestions_provider.h"
 #include "components/ntp_snippets/status.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 
 namespace ntp_snippets {
 
 namespace {
 
 // The FetchingInterval enum specifies overlapping time intervals that are used
@@ skipping 135 matching lines @@
   }
 
  private:
   std::unique_ptr<web_resource::EulaAcceptedNotifier> eula_notifier_;
   RemoteSuggestionsScheduler* scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(EulaState);
 };
 
 // static
-SchedulingRemoteSuggestionsProvider::FetchingSchedule
-SchedulingRemoteSuggestionsProvider::FetchingSchedule::Empty() {
+RemoteSuggestionsSchedulerImpl::FetchingSchedule
+RemoteSuggestionsSchedulerImpl::FetchingSchedule::Empty() {
   return FetchingSchedule{base::TimeDelta(), base::TimeDelta(),
                           base::TimeDelta(), base::TimeDelta()};
 }
 
-bool SchedulingRemoteSuggestionsProvider::FetchingSchedule::operator==(
+bool RemoteSuggestionsSchedulerImpl::FetchingSchedule::operator==(
     const FetchingSchedule& other) const {
   return interval_persistent_wifi == other.interval_persistent_wifi &&
          interval_persistent_fallback == other.interval_persistent_fallback &&
          interval_soft_on_usage_event == other.interval_soft_on_usage_event &&
          interval_soft_on_ntp_opened == other.interval_soft_on_ntp_opened;
 }
 
-bool SchedulingRemoteSuggestionsProvider::FetchingSchedule::operator!=(
+bool RemoteSuggestionsSchedulerImpl::FetchingSchedule::operator!=(
     const FetchingSchedule& other) const {
   return !operator==(other);
 }
 
-bool SchedulingRemoteSuggestionsProvider::FetchingSchedule::is_empty() const {
+bool RemoteSuggestionsSchedulerImpl::FetchingSchedule::is_empty() const {
   return interval_persistent_wifi.is_zero() &&
          interval_persistent_fallback.is_zero() &&
          interval_soft_on_usage_event.is_zero() &&
          interval_soft_on_ntp_opened.is_zero();
 }
 
 // The TriggerType enum specifies values for the events that can trigger
 // fetching remote suggestions. These values are written to logs. New enum
 // values can be added, but existing enums must never be renumbered or deleted
 // and reused. When adding new entries, also update the array
 // |kTriggerTypeNames| above.
-enum class SchedulingRemoteSuggestionsProvider::TriggerType {
+enum class RemoteSuggestionsSchedulerImpl::TriggerType {
   PERSISTENT_SCHEDULER_WAKE_UP = 0,
   NTP_OPENED = 1,
   BROWSER_FOREGROUNDED = 2,
   BROWSER_COLD_START = 3,
   COUNT
 };
 
-SchedulingRemoteSuggestionsProvider::SchedulingRemoteSuggestionsProvider(
-    Observer* observer,
-    std::unique_ptr<RemoteSuggestionsProvider> provider,
+RemoteSuggestionsSchedulerImpl::RemoteSuggestionsSchedulerImpl(
     PersistentScheduler* persistent_scheduler,
     const UserClassifier* user_classifier,
     PrefService* profile_prefs,
     PrefService* local_state_prefs,
     std::unique_ptr<base::Clock> clock)
-    : RemoteSuggestionsProvider(observer),
-      RemoteSuggestionsScheduler(),
-      provider_(std::move(provider)),
-      persistent_scheduler_(persistent_scheduler),
+    : persistent_scheduler_(persistent_scheduler),
       background_fetch_in_progress_(false),
       user_classifier_(user_classifier),
       request_throttler_rare_ntp_user_(
           profile_prefs,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_RARE_NTP_USER),
       request_throttler_active_ntp_user_(
           profile_prefs,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_NTP_USER),
       request_throttler_active_suggestions_consumer_(
           profile_prefs,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_SUGGESTIONS_CONSUMER),
       eula_state_(base::MakeUnique<EulaState>(local_state_prefs, this)),
       profile_prefs_(profile_prefs),
       clock_(std::move(clock)),
       enabled_triggers_(GetEnabledTriggerTypes()) {
   DCHECK(user_classifier);
   DCHECK(profile_prefs);
 
   LoadLastFetchingSchedule();
 }
 
-SchedulingRemoteSuggestionsProvider::~SchedulingRemoteSuggestionsProvider() =
-    default;
+RemoteSuggestionsSchedulerImpl::~RemoteSuggestionsSchedulerImpl() = default;
 
 // static
-void SchedulingRemoteSuggestionsProvider::RegisterProfilePrefs(
+void RemoteSuggestionsSchedulerImpl::RegisterProfilePrefs(
     PrefRegistrySimple* registry) {
   registry->RegisterInt64Pref(prefs::kSnippetPersistentFetchingIntervalWifi, 0);
   registry->RegisterInt64Pref(prefs::kSnippetPersistentFetchingIntervalFallback,
                               0);
   registry->RegisterInt64Pref(prefs::kSnippetSoftFetchingIntervalOnUsageEvent,
                               0);
   registry->RegisterInt64Pref(prefs::kSnippetLastFetchAttempt, 0);
   registry->RegisterInt64Pref(prefs::kSnippetSoftFetchingIntervalOnNtpOpened,
                               0);
 }
 
-void SchedulingRemoteSuggestionsProvider::OnProviderActivated() {
+void RemoteSuggestionsSchedulerImpl::SetProvider(
+    RemoteSuggestionsProvider* provider) {
+  DCHECK(provider);
+  provider_ = provider;
+}
+
+void RemoteSuggestionsSchedulerImpl::OnProviderActivated() {
   StartScheduling();
 }
 
-void SchedulingRemoteSuggestionsProvider::OnProviderDeactivated() {
+void RemoteSuggestionsSchedulerImpl::OnProviderDeactivated() {
   StopScheduling();
 }
 
-void SchedulingRemoteSuggestionsProvider::OnSuggestionsCleared() {
+void RemoteSuggestionsSchedulerImpl::OnSuggestionsCleared() {
+  // This should be called by |provider_| so it should exist.
+  DCHECK(provider_);
   // Some user action causes suggestions to be cleared, fetch now (as an
   // interactive request).
-  ReloadSuggestions();
+  provider_->ReloadSuggestions();
 }
 
-void SchedulingRemoteSuggestionsProvider::OnHistoryCleared() {
+void RemoteSuggestionsSchedulerImpl::OnHistoryCleared() {
   // Due to privacy, we should not fetch for a while (unless the user explicitly
   // asks for new suggestions) to give sync the time to propagate the changes in
   // history to the server.
   background_fetches_allowed_after_ =
       clock_->Now() + base::TimeDelta::FromMinutes(
                           kBlockBackgroundFetchesMinutesAfterClearingHistory);
   // After that time elapses, we should fetch as soon as possible.
   ClearLastFetchAttemptTime();
 }
 
-void SchedulingRemoteSuggestionsProvider::RescheduleFetching() {
+void RemoteSuggestionsSchedulerImpl::RescheduleFetching() {
   // Force the reschedule by stopping and starting it again.
   StopScheduling();
   StartScheduling();
 }
 
-void SchedulingRemoteSuggestionsProvider::OnPersistentSchedulerWakeUp() {
+bool RemoteSuggestionsSchedulerImpl::AcquireQuotaForInteractiveFetch() {
+  return AcquireQuota(/*interactive_request=*/true);
+}
+
+void RemoteSuggestionsSchedulerImpl::OnInteractiveFetchFinished(
+    Status fetch_status) {
+  OnFetchCompleted(fetch_status);
+}
+
+void RemoteSuggestionsSchedulerImpl::OnPersistentSchedulerWakeUp() {
   RefetchInTheBackgroundIfEnabled(TriggerType::PERSISTENT_SCHEDULER_WAKE_UP);
 }
 
-void SchedulingRemoteSuggestionsProvider::OnBrowserForegrounded() {
+void RemoteSuggestionsSchedulerImpl::OnBrowserForegrounded() {
   // TODO(jkrcal): Consider that this is called whenever we open or return to an
   // Activity. Therefore, keep work light for fast start up calls.
   if (!ShouldRefetchInTheBackgroundNow(TriggerType::BROWSER_FOREGROUNDED)) {
     return;
   }
 
   RefetchInTheBackgroundIfEnabled(TriggerType::BROWSER_FOREGROUNDED);
 }
 
-void SchedulingRemoteSuggestionsProvider::OnBrowserColdStart() {
+void RemoteSuggestionsSchedulerImpl::OnBrowserColdStart() {
   // TODO(fhorschig|jkrcal): Consider that work here must be kept light for fast
   // cold start ups.
   if (!ShouldRefetchInTheBackgroundNow(TriggerType::BROWSER_COLD_START)) {
     return;
   }
 
   RefetchInTheBackgroundIfEnabled(TriggerType::BROWSER_COLD_START);
 }
 
-void SchedulingRemoteSuggestionsProvider::OnNTPOpened() {
+void RemoteSuggestionsSchedulerImpl::OnNTPOpened() {
   if (!ShouldRefetchInTheBackgroundNow(TriggerType::NTP_OPENED)) {
     return;
   }
 
   RefetchInTheBackgroundIfEnabled(TriggerType::NTP_OPENED);
 }
 
-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*
-SchedulingRemoteSuggestionsProvider::suggestions_fetcher_for_debugging() const {
-  return provider_->suggestions_fetcher_for_debugging();
-}
-
-CategoryStatus SchedulingRemoteSuggestionsProvider::GetCategoryStatus(
-    Category category) {
-  return provider_->GetCategoryStatus(category);
-}
-
-CategoryInfo SchedulingRemoteSuggestionsProvider::GetCategoryInfo(
-    Category category) {
-  return provider_->GetCategoryInfo(category);
-}
-
-void SchedulingRemoteSuggestionsProvider::DismissSuggestion(
-    const ContentSuggestion::ID& suggestion_id) {
-  provider_->DismissSuggestion(suggestion_id);
-}
-
-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);
-}
-
-void SchedulingRemoteSuggestionsProvider::ClearCachedSuggestions(
-    Category category) {
-  provider_->ClearCachedSuggestions(category);
-}
-
-void SchedulingRemoteSuggestionsProvider::OnSignInStateChanged() {
-  provider_->OnSignInStateChanged();
-}
-
-void SchedulingRemoteSuggestionsProvider::GetDismissedSuggestionsForDebugging(
-    Category category,
-    const DismissedSuggestionsCallback& callback) {
-  provider_->GetDismissedSuggestionsForDebugging(category, callback);
-}
-
-void SchedulingRemoteSuggestionsProvider::ClearDismissedSuggestionsForDebugging(
-    Category category) {
-  provider_->ClearDismissedSuggestionsForDebugging(category);
-}
-
-void SchedulingRemoteSuggestionsProvider::StartScheduling() {
+void RemoteSuggestionsSchedulerImpl::StartScheduling() {
   FetchingSchedule new_schedule = GetDesiredFetchingSchedule();
 
   if (schedule_ == new_schedule) {
     // Do not schedule if nothing has changed;
     return;
   }
 
   schedule_ = new_schedule;
   StoreFetchingSchedule();
   ApplyPersistentFetchingSchedule();
 }
 
-void SchedulingRemoteSuggestionsProvider::StopScheduling() {
+void RemoteSuggestionsSchedulerImpl::StopScheduling() {
   if (schedule_.is_empty()) {
     // Do not unschedule if already switched off.
     return;
   }
 
   schedule_ = FetchingSchedule::Empty();
   StoreFetchingSchedule();
   ApplyPersistentFetchingSchedule();
 }
 
-void SchedulingRemoteSuggestionsProvider::ApplyPersistentFetchingSchedule() {
+void RemoteSuggestionsSchedulerImpl::ApplyPersistentFetchingSchedule() {
   // The scheduler only exists on Android so far, it's null on other platforms.
   if (persistent_scheduler_) {
     if (schedule_.is_empty()) {
       persistent_scheduler_->Unschedule();
     } else {
       persistent_scheduler_->Schedule(schedule_.interval_persistent_wifi,
                                       schedule_.interval_persistent_fallback);
     }
   }
 }
 
-SchedulingRemoteSuggestionsProvider::FetchingSchedule
-SchedulingRemoteSuggestionsProvider::GetDesiredFetchingSchedule() const {
+RemoteSuggestionsSchedulerImpl::FetchingSchedule
+RemoteSuggestionsSchedulerImpl::GetDesiredFetchingSchedule() const {
   UserClassifier::UserClass user_class = user_classifier_->GetUserClass();
 
   FetchingSchedule schedule;
   schedule.interval_persistent_wifi =
       GetDesiredFetchingInterval(FetchingInterval::PERSISTENT_WIFI, user_class);
   schedule.interval_persistent_fallback = GetDesiredFetchingInterval(
       FetchingInterval::PERSISTENT_FALLBACK, user_class);
   schedule.interval_soft_on_usage_event = GetDesiredFetchingInterval(
       FetchingInterval::SOFT_ON_USAGE_EVENT, user_class);
   schedule.interval_soft_on_ntp_opened = GetDesiredFetchingInterval(
       FetchingInterval::SOFT_ON_NTP_OPENED, user_class);
 
   return schedule;
 }
 
-void SchedulingRemoteSuggestionsProvider::LoadLastFetchingSchedule() {
+void RemoteSuggestionsSchedulerImpl::LoadLastFetchingSchedule() {
   schedule_.interval_persistent_wifi = base::TimeDelta::FromInternalValue(
       profile_prefs_->GetInt64(prefs::kSnippetPersistentFetchingIntervalWifi));
   schedule_.interval_persistent_fallback =
       base::TimeDelta::FromInternalValue(profile_prefs_->GetInt64(
           prefs::kSnippetPersistentFetchingIntervalFallback));
   schedule_.interval_soft_on_usage_event =
       base::TimeDelta::FromInternalValue(profile_prefs_->GetInt64(
           prefs::kSnippetSoftFetchingIntervalOnUsageEvent));
   schedule_.interval_soft_on_ntp_opened = base::TimeDelta::FromInternalValue(
       profile_prefs_->GetInt64(prefs::kSnippetSoftFetchingIntervalOnNtpOpened));
 }
 
-void SchedulingRemoteSuggestionsProvider::StoreFetchingSchedule() {
+void RemoteSuggestionsSchedulerImpl::StoreFetchingSchedule() {
   profile_prefs_->SetInt64(
       prefs::kSnippetPersistentFetchingIntervalWifi,
       schedule_.interval_persistent_wifi.ToInternalValue());
   profile_prefs_->SetInt64(
       prefs::kSnippetPersistentFetchingIntervalFallback,
       schedule_.interval_persistent_fallback.ToInternalValue());
   profile_prefs_->SetInt64(
       prefs::kSnippetSoftFetchingIntervalOnUsageEvent,
       schedule_.interval_soft_on_usage_event.ToInternalValue());
   profile_prefs_->SetInt64(
       prefs::kSnippetSoftFetchingIntervalOnNtpOpened,
       schedule_.interval_soft_on_ntp_opened.ToInternalValue());
 }
 
-void SchedulingRemoteSuggestionsProvider::RefetchInTheBackgroundIfEnabled(
-    SchedulingRemoteSuggestionsProvider::TriggerType trigger) {
+void RemoteSuggestionsSchedulerImpl::RefetchInTheBackgroundIfEnabled(
+    TriggerType trigger) {
   if (BackgroundFetchesDisabled(trigger)) {
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "NewTabPage.ContentSuggestions.BackgroundFetchTrigger",
       static_cast<int>(trigger), static_cast<int>(TriggerType::COUNT));
 
-  RefetchInTheBackground(/*callback=*/nullptr);
+  RefetchInTheBackground();
 }
 
-bool SchedulingRemoteSuggestionsProvider::ShouldRefetchInTheBackgroundNow(
-    SchedulingRemoteSuggestionsProvider::TriggerType trigger) {
+void RemoteSuggestionsSchedulerImpl::RefetchInTheBackground() {
+  if (background_fetch_in_progress_) {
+    return;
+  }
+
+  if (!AcquireQuota(/*interactive_request=*/false)) {
+    return;
+  }
+
+  background_fetch_in_progress_ = true;
+  provider_->RefetchInTheBackground(
+      base::MakeUnique<RemoteSuggestionsProvider::FetchStatusCallback>(
+          base::Bind(
+              &RemoteSuggestionsSchedulerImpl::RefetchInTheBackgroundFinished,
+              base::Unretained(this))));
+}
+
+bool RemoteSuggestionsSchedulerImpl::ShouldRefetchInTheBackgroundNow(
+    TriggerType trigger) {
   const base::Time last_fetch_attempt_time = base::Time::FromInternalValue(
       profile_prefs_->GetInt64(prefs::kSnippetLastFetchAttempt));
   base::Time first_allowed_fetch_time;
   switch (trigger) {
     case TriggerType::NTP_OPENED:
       first_allowed_fetch_time =
           last_fetch_attempt_time + schedule_.interval_soft_on_ntp_opened;
       break;
     case TriggerType::BROWSER_FOREGROUNDED:
     case TriggerType::BROWSER_COLD_START:
       first_allowed_fetch_time =
           last_fetch_attempt_time + schedule_.interval_soft_on_usage_event;
       break;
     case TriggerType::PERSISTENT_SCHEDULER_WAKE_UP:
     case TriggerType::COUNT:
       NOTREACHED();
       break;
   }
   base::Time now = clock_->Now();
 
   return background_fetches_allowed_after_ <= now &&
          first_allowed_fetch_time <= now;
 }
 
-bool SchedulingRemoteSuggestionsProvider::BackgroundFetchesDisabled(
-    SchedulingRemoteSuggestionsProvider::TriggerType trigger) const {
+bool RemoteSuggestionsSchedulerImpl::BackgroundFetchesDisabled(
+    TriggerType trigger) const {
+  if (!provider_) {
+    return true;  // Cannot fetch as remote suggestions provider does not exist.
+  }
+
   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.
   }
 
   if (!eula_state_->IsEulaAccepted()) {
     return true;  // No background fetches are allowed before EULA is accepted.
   }
 
   return false;
 }
 
-bool SchedulingRemoteSuggestionsProvider::AcquireQuota(
-    bool interactive_request) {
+bool RemoteSuggestionsSchedulerImpl::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));
-  }
-}
-
-void SchedulingRemoteSuggestionsProvider::RefetchInTheBackgroundFinished(
-    std::unique_ptr<FetchStatusCallback> callback,
+void RemoteSuggestionsSchedulerImpl::RefetchInTheBackgroundFinished(
     Status fetch_status) {
   background_fetch_in_progress_ = false;
   OnFetchCompleted(fetch_status);
-  if (callback) {
-    callback->Run(fetch_status);
-  }
 }
 
-void SchedulingRemoteSuggestionsProvider::OnFetchCompleted(
-    Status fetch_status) {
+void RemoteSuggestionsSchedulerImpl::OnFetchCompleted(Status fetch_status) {
   profile_prefs_->SetInt64(prefs::kSnippetLastFetchAttempt,
                            clock_->Now().ToInternalValue());
 
   // Reschedule after a fetch. The persistent schedule is applied only after a
   // successful fetch. After a failed fetch, we want to keep the previous
   // persistent schedule intact so that we eventually get a persistent
   // fallback fetch (if the wifi persistent fetches keep failing).
   if (fetch_status.code != StatusCode::SUCCESS) {
     return;
   }
   ApplyPersistentFetchingSchedule();
 }
 
-void SchedulingRemoteSuggestionsProvider::ClearLastFetchAttemptTime() {
+void RemoteSuggestionsSchedulerImpl::ClearLastFetchAttemptTime() {
   profile_prefs_->ClearPref(prefs::kSnippetLastFetchAttempt);
 }
 
-std::set<SchedulingRemoteSuggestionsProvider::TriggerType>
-SchedulingRemoteSuggestionsProvider::GetEnabledTriggerTypes() {
+std::set<RemoteSuggestionsSchedulerImpl::TriggerType>
+RemoteSuggestionsSchedulerImpl::GetEnabledTriggerTypes() {
   static_assert(static_cast<unsigned int>(TriggerType::COUNT) ==
                     arraysize(kTriggerTypeNames),
                 "Fill in names for trigger types.");
 
   std::string param_value = base::GetFieldTrialParamValueByFeature(
       ntp_snippets::kArticleSuggestionsFeature, kTriggerTypesParamName);
   if (param_value == kTriggerTypesParamValueForEmptyList) {
     return std::set<TriggerType>();
   }
 
@@ skipping 17 matching lines @@
       return GetDefaultEnabledTriggerTypes();
     }
 
     // Add the enabled type represented by |token| into the result set.
     enabled_types.insert(
         static_cast<TriggerType>(it - std::begin(kTriggerTypeNames)));
   }
   return enabled_types;
 }
 
-std::set<SchedulingRemoteSuggestionsProvider::TriggerType>
-SchedulingRemoteSuggestionsProvider::GetDefaultEnabledTriggerTypes() {
+std::set<RemoteSuggestionsSchedulerImpl::TriggerType>
+RemoteSuggestionsSchedulerImpl::GetDefaultEnabledTriggerTypes() {
   return {TriggerType::PERSISTENT_SCHEDULER_WAKE_UP, TriggerType::NTP_OPENED,
           TriggerType::BROWSER_FOREGROUNDED};
 }
 
 }  // namespace ntp_snippets