[Remote suggestions] Do not fetch before EULA accepted

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 115 matching lines @@
 
   double value_hours = base::GetFieldTrialParamByFeatureAsDouble(
       ntp_snippets::kArticleSuggestionsFeature, param_name,
       default_value_hours);
 
   return base::TimeDelta::FromSecondsD(value_hours * 3600.0);
 }
 
 }  // namespace
 
+class EulaState : public web_resource::EulaAcceptedNotifier::Observer {
+ public:
+  EulaState(PrefService* local_state_prefs,
+            RemoteSuggestionsScheduler* scheduler)
+      : eula_notifier_(
+            web_resource::EulaAcceptedNotifier::Create(local_state_prefs)),
+        scheduler_(scheduler) {
+    // EulaNotifier is not constructed on some platforms (such as desktop).
+    if (!eula_notifier_) {
+      return;
+    }
+
+    // Register the observer.
+    eula_notifier_->Init(this);
+  }
+
+  ~EulaState() = default;
+
+  bool IsEulaAccepted() {
+    if (!eula_notifier_) {
+      return true;
+    }
+    return eula_notifier_->IsEulaAccepted();
+  }
+
+  // EulaAcceptedNotifier::Observer implementation.
+  void OnEulaAccepted() override {
+    // Emulate a browser foregrounded event.
+    scheduler_->OnBrowserForegrounded();
+  }
+
+ private:
+  std::unique_ptr<web_resource::EulaAcceptedNotifier> eula_notifier_;
+  RemoteSuggestionsScheduler* scheduler_;
+
+  DISALLOW_COPY_AND_ASSIGN(EulaState);
+};
+
 // static
 SchedulingRemoteSuggestionsProvider::FetchingSchedule
 SchedulingRemoteSuggestionsProvider::FetchingSchedule::Empty() {
   return FetchingSchedule{base::TimeDelta(), base::TimeDelta(),
                           base::TimeDelta(), base::TimeDelta()};
 }
 
 bool SchedulingRemoteSuggestionsProvider::FetchingSchedule::operator==(
     const FetchingSchedule& other) const {
   return interval_persistent_wifi == other.interval_persistent_wifi &&
@@ skipping 25 matching lines @@
   BROWSER_FOREGROUNDED = 2,
   BROWSER_COLD_START = 3,
   COUNT
 };
 
 SchedulingRemoteSuggestionsProvider::SchedulingRemoteSuggestionsProvider(
     Observer* observer,
     std::unique_ptr<RemoteSuggestionsProvider> provider,
     PersistentScheduler* persistent_scheduler,
     const UserClassifier* user_classifier,
-    PrefService* pref_service,
+    PrefService* profile_prefs,
+    PrefService* local_state_prefs,
     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,
+          profile_prefs,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_RARE_NTP_USER),
       request_throttler_active_ntp_user_(
-          pref_service,
+          profile_prefs,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_NTP_USER),
       request_throttler_active_suggestions_consumer_(
-          pref_service,
+          profile_prefs,
           RequestThrottler::RequestType::
               CONTENT_SUGGESTION_FETCHER_ACTIVE_SUGGESTIONS_CONSUMER),
-      pref_service_(pref_service),
+      eula_state_(base::MakeUnique<EulaState>(local_state_prefs, this)),
+      profile_prefs_(profile_prefs),
       clock_(std::move(clock)),
       enabled_triggers_(GetEnabledTriggerTypes()) {
   DCHECK(user_classifier);
-  DCHECK(pref_service);
+  DCHECK(profile_prefs);
 
   LoadLastFetchingSchedule();
 }
 
 SchedulingRemoteSuggestionsProvider::~SchedulingRemoteSuggestionsProvider() =
     default;
 
 // static
 void SchedulingRemoteSuggestionsProvider::RegisterProfilePrefs(
     PrefRegistrySimple* registry) {
@@ skipping 225 matching lines @@
   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() {
   schedule_.interval_persistent_wifi = base::TimeDelta::FromInternalValue(
-      pref_service_->GetInt64(prefs::kSnippetPersistentFetchingIntervalWifi));
+      profile_prefs_->GetInt64(prefs::kSnippetPersistentFetchingIntervalWifi));
   schedule_.interval_persistent_fallback =
-      base::TimeDelta::FromInternalValue(pref_service_->GetInt64(
+      base::TimeDelta::FromInternalValue(profile_prefs_->GetInt64(
           prefs::kSnippetPersistentFetchingIntervalFallback));
-  schedule_.interval_soft_on_usage_event = base::TimeDelta::FromInternalValue(
-      pref_service_->GetInt64(prefs::kSnippetSoftFetchingIntervalOnUsageEvent));
+  schedule_.interval_soft_on_usage_event =
+      base::TimeDelta::FromInternalValue(profile_prefs_->GetInt64(
+          prefs::kSnippetSoftFetchingIntervalOnUsageEvent));
   schedule_.interval_soft_on_ntp_opened = base::TimeDelta::FromInternalValue(
-      pref_service_->GetInt64(prefs::kSnippetSoftFetchingIntervalOnNtpOpened));
+      profile_prefs_->GetInt64(prefs::kSnippetSoftFetchingIntervalOnNtpOpened));
 }
 
 void SchedulingRemoteSuggestionsProvider::StoreFetchingSchedule() {
-  pref_service_->SetInt64(prefs::kSnippetPersistentFetchingIntervalWifi,
-                          schedule_.interval_persistent_wifi.ToInternalValue());
-  pref_service_->SetInt64(
+  profile_prefs_->SetInt64(
+      prefs::kSnippetPersistentFetchingIntervalWifi,
+      schedule_.interval_persistent_wifi.ToInternalValue());
+  profile_prefs_->SetInt64(
       prefs::kSnippetPersistentFetchingIntervalFallback,
       schedule_.interval_persistent_fallback.ToInternalValue());
-  pref_service_->SetInt64(
+  profile_prefs_->SetInt64(
       prefs::kSnippetSoftFetchingIntervalOnUsageEvent,
       schedule_.interval_soft_on_usage_event.ToInternalValue());
-  pref_service_->SetInt64(
+  profile_prefs_->SetInt64(
       prefs::kSnippetSoftFetchingIntervalOnNtpOpened,
       schedule_.interval_soft_on_ntp_opened.ToInternalValue());
 }
 
 void SchedulingRemoteSuggestionsProvider::RefetchInTheBackgroundIfEnabled(
     SchedulingRemoteSuggestionsProvider::TriggerType trigger) {
   if (BackgroundFetchesDisabled(trigger)) {
     return;
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "NewTabPage.ContentSuggestions.BackgroundFetchTrigger",
       static_cast<int>(trigger), static_cast<int>(TriggerType::COUNT));
 
   RefetchInTheBackground(/*callback=*/nullptr);
 }
 
 bool SchedulingRemoteSuggestionsProvider::ShouldRefetchInTheBackgroundNow(
     SchedulingRemoteSuggestionsProvider::TriggerType trigger) {
   const base::Time last_fetch_attempt_time = base::Time::FromInternalValue(
-      pref_service_->GetInt64(prefs::kSnippetLastFetchAttempt));
+      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;
@@ skipping 11 matching lines @@
 
 bool SchedulingRemoteSuggestionsProvider::BackgroundFetchesDisabled(
     SchedulingRemoteSuggestionsProvider::TriggerType trigger) const {
   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) {
   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:
@@ skipping 22 matching lines @@
     Status fetch_status) {
   background_fetch_in_progress_ = false;
   OnFetchCompleted(fetch_status);
   if (callback) {
     callback->Run(fetch_status);
   }
 }
 
 void SchedulingRemoteSuggestionsProvider::OnFetchCompleted(
     Status fetch_status) {
-  pref_service_->SetInt64(prefs::kSnippetLastFetchAttempt,
-                          clock_->Now().ToInternalValue());
+  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() {
-  pref_service_->ClearPref(prefs::kSnippetLastFetchAttempt);
+  profile_prefs_->ClearPref(prefs::kSnippetLastFetchAttempt);
 }
 
 std::set<SchedulingRemoteSuggestionsProvider::TriggerType>
 SchedulingRemoteSuggestionsProvider::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);
@@ skipping 28 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