[remote suggestions] Add separte fetch interval for NTP open trigger

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 19 matching lines @@
 // for each interval. Initially all the timers are started at the same time.
 // Fetches are
 // only performed when certain conditions associated with the intervals are
 // met. If a fetch failed, then only the corresponding timer is reset. The
 // other timers are not touched.
 // TODO(markusheintz): Describe the individual intervals.
 enum class FetchingInterval {
   PERSISTENT_FALLBACK,
   PERSISTENT_WIFI,
   SOFT_ON_USAGE_EVENT,
+  SOFT_ON_NTP_OPENED,
   COUNT
 };
 
 // The following arrays specify default values for remote suggestions fetch
 // intervals corresponding to individual user classes. The user classes are
 // defined by the user classifier. There must be an array for each user class.
 // The values of each array specify a default time interval for the intervals
 // defined by the enum FetchingInterval. The default time intervals defined in
 // the arrays can be overridden using different variation parameters.
-const double kDefaultFetchingIntervalHoursRareNtpUser[] = {48.0, 24.0, 12.0};
-const double kDefaultFetchingIntervalHoursActiveNtpUser[] = {24.0, 6.0, 2.0};
+const double kDefaultFetchingIntervalHoursRareNtpUser[] = {48.0, 24.0, 12.0,
+                                                           6.0};
+const double kDefaultFetchingIntervalHoursActiveNtpUser[] = {24.0, 6.0, 2.0,
+                                                             2.0};
 const double kDefaultFetchingIntervalHoursActiveSuggestionsConsumer[] = {
-    24.0, 6.0, 2.0};
+    24.0, 6.0, 2.0, 1.0};
 
 // Variation parameters than can be used to override the default fetching
 // intervals.
 const char* kFetchingIntervalParamNameRareNtpUser[] = {
     "fetching_interval_hours-fallback-rare_ntp_user",
     "fetching_interval_hours-wifi-rare_ntp_user",
-    "soft_fetching_interval_hours-active-rare_ntp_user"};
+    "soft_fetching_interval_hours-active-rare_ntp_user",
+    "soft_on_ntp_opened_interval_hours-rare_ntp_user"};
 const char* kFetchingIntervalParamNameActiveNtpUser[] = {
     "fetching_interval_hours-fallback-active_ntp_user",
     "fetching_interval_hours-wifi-active_ntp_user",
-    "soft_fetching_interval_hours-active-active_ntp_user"};
+    "soft_fetching_interval_hours-active-active_ntp_user",
+    "soft_on_ntp_opened_interval_hours-active_ntp_user"};
 const char* kFetchingIntervalParamNameActiveSuggestionsConsumer[] = {
     "fetching_interval_hours-fallback-active_suggestions_consumer",
     "fetching_interval_hours-wifi-active_suggestions_consumer",
-    "soft_fetching_interval_hours-active-active_suggestions_consumer"};
+    "soft_fetching_interval_hours-active-active_suggestions_consumer",
+    "soft_on_ntp_opened_interval_hours-active_suggestions_consumer"};
 
 static_assert(
     static_cast<unsigned int>(FetchingInterval::COUNT) ==
             arraysize(kDefaultFetchingIntervalHoursRareNtpUser) &&
         static_cast<unsigned int>(FetchingInterval::COUNT) ==
             arraysize(kDefaultFetchingIntervalHoursActiveNtpUser) &&
         static_cast<unsigned int>(FetchingInterval::COUNT) ==
             arraysize(kDefaultFetchingIntervalHoursActiveSuggestionsConsumer) &&
         static_cast<unsigned int>(FetchingInterval::COUNT) ==
             arraysize(kFetchingIntervalParamNameRareNtpUser) &&
@@ skipping 46 matching lines @@
 
   return base::TimeDelta::FromSecondsD(value_hours * 3600.0);
 }
 
 }  // namespace
 
 // static
 SchedulingRemoteSuggestionsProvider::FetchingSchedule
 SchedulingRemoteSuggestionsProvider::FetchingSchedule::Empty() {
   return FetchingSchedule{base::TimeDelta(), base::TimeDelta(),
-                          base::TimeDelta()};
+                          base::TimeDelta(), base::TimeDelta()};
 }
 
 bool SchedulingRemoteSuggestionsProvider::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_usage_event == other.interval_soft_on_usage_event &&
+         interval_soft_on_ntp_opened == other.interval_soft_on_ntp_opened;
 }
 
 bool SchedulingRemoteSuggestionsProvider::FetchingSchedule::operator!=(
     const FetchingSchedule& other) const {
   return !operator==(other);
 }
 
 bool SchedulingRemoteSuggestionsProvider::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_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 {
   PERSISTENT_SCHEDULER_WAKE_UP = 0,
   NTP_OPENED = 1,
@@ skipping 35 matching lines @@
 
 // static
 void SchedulingRemoteSuggestionsProvider::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::RescheduleFetching() {
   // Force the reschedule by stopping and starting it again.
   StopScheduling();
   StartScheduling();
 }
 
 void SchedulingRemoteSuggestionsProvider::OnPersistentSchedulerWakeUp() {
   RefetchInTheBackgroundIfEnabled(TriggerType::PERSISTENT_SCHEDULER_WAKE_UP);
 }
 
 void SchedulingRemoteSuggestionsProvider::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()) {
+  if (!ShouldRefetchInTheBackgroundNow(TriggerType::BROWSER_FOREGROUNDED)) {
     return;
   }
 
   RefetchInTheBackgroundIfEnabled(TriggerType::BROWSER_FOREGROUNDED);
 }
 
 void SchedulingRemoteSuggestionsProvider::OnBrowserColdStart() {
   // TODO(fhorschig|jkrcal): Consider that work here must be kept light for fast
   // cold start ups.
-  if (!ShouldRefetchInTheBackgroundNow()) {
+  if (!ShouldRefetchInTheBackgroundNow(TriggerType::BROWSER_COLD_START)) {
     return;
   }
 
   RefetchInTheBackgroundIfEnabled(TriggerType::BROWSER_COLD_START);
 }
 
 void SchedulingRemoteSuggestionsProvider::OnNTPOpened() {
-  if (!ShouldRefetchInTheBackgroundNow()) {
+  if (!ShouldRefetchInTheBackgroundNow(TriggerType::NTP_OPENED)) {
     return;
   }
 
   RefetchInTheBackgroundIfEnabled(TriggerType::NTP_OPENED);
 }
 
 void SchedulingRemoteSuggestionsProvider::SetProviderStatusCallback(
     std::unique_ptr<ProviderStatusCallback> callback) {
   provider_->SetProviderStatusCallback(std::move(callback));
 }
@@ skipping 137 matching lines @@
 SchedulingRemoteSuggestionsProvider::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() {
   schedule_.interval_persistent_wifi = base::TimeDelta::FromInternalValue(
       pref_service_->GetInt64(prefs::kSnippetPersistentFetchingIntervalWifi));
   schedule_.interval_persistent_fallback =
       base::TimeDelta::FromInternalValue(pref_service_->GetInt64(
           prefs::kSnippetPersistentFetchingIntervalFallback));
   schedule_.interval_soft_on_usage_event = base::TimeDelta::FromInternalValue(
       pref_service_->GetInt64(prefs::kSnippetSoftFetchingIntervalOnUsageEvent));
+  schedule_.interval_soft_on_ntp_opened = base::TimeDelta::FromInternalValue(
+      pref_service_->GetInt64(prefs::kSnippetSoftFetchingIntervalOnNtpOpened));
 }
 
 void SchedulingRemoteSuggestionsProvider::StoreFetchingSchedule() {
   pref_service_->SetInt64(prefs::kSnippetPersistentFetchingIntervalWifi,
                           schedule_.interval_persistent_wifi.ToInternalValue());
   pref_service_->SetInt64(
       prefs::kSnippetPersistentFetchingIntervalFallback,
       schedule_.interval_persistent_fallback.ToInternalValue());
   pref_service_->SetInt64(
       prefs::kSnippetSoftFetchingIntervalOnUsageEvent,
       schedule_.interval_soft_on_usage_event.ToInternalValue());
+  pref_service_->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() {
-  base::Time first_allowed_fetch_time =
-      base::Time::FromInternalValue(
-          pref_service_->GetInt64(prefs::kSnippetLastFetchAttempt)) +
-      schedule_.interval_soft_on_usage_event;
+bool SchedulingRemoteSuggestionsProvider::ShouldRefetchInTheBackgroundNow(
+    SchedulingRemoteSuggestionsProvider::TriggerType trigger) {
+  const base::Time last_fetch_attempt_time = base::Time::FromInternalValue(
+      pref_service_->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;
+  }
   return first_allowed_fetch_time <= clock_->Now();
 }
 
 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) {
@@ skipping 76 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