[Soft fetches] Set-up different intervals for <Chrome started> events.

components/ntp_snippets/remote/remote_suggestions_scheduler_impl_unittest.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/remote_suggestions_scheduler_impl.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 471 matching lines @@
     EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
     // The second call to NTPOpened 4hrs later again results in a fetch.
     EXPECT_CALL(*provider(), RefetchInTheBackground(_));
   }
 
   // First enable the scheduler.
   ActivateProvider();
   // Make the first soft fetch successful.
   scheduler()->OnBrowserForegrounded();
   signal_fetch_done.Run(Status::Success());
-  // Open NTP again after 4hrs.
-  test_clock()->Advance(base::TimeDelta::FromHours(4));
+  // Open NTP again after 9hrs.
+  test_clock()->Advance(base::TimeDelta::FromHours(9));
   scheduler()->OnBrowserForegrounded();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
        ShouldRescheduleOnRescheduleFetching) {
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   scheduler()->RescheduleFetching();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest, ShouldScheduleOnActivation) {
@@ skipping 92 matching lines @@
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
   // null. Change the fallback interval for this class.
   SetVariationParameter("fetching_interval_hours-fallback-active_ntp_user",
                         "1.5");
 
   // Schedule() should get called for the second time after params have changed.
   ActivateProvider();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
-       ReschedulesWhenSoftWifiParamChanges) {
+       ReschedulesWhenShownWifiParamChanges) {
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _)).Times(2);
   ActivateProvider();
 
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
   // null. Change the on usage interval for this class.
   SetVariationParameter("soft_fetching_interval_hours-wifi-active_ntp_user",
                         "1.5");
 
   // Schedule() should get called for the second time after params have changed.
   ActivateProvider();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
-       ReschedulesWhenSoftFallbackParamChanges) {
+       ReschedulesWhenShownFallbackParamChanges) {
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _)).Times(2);
   ActivateProvider();
 
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
   // null. Change the fallback interval for this class.
   SetVariationParameter("soft_fetching_interval_hours-fallback-active_ntp_user",
                         "1.5");
 
   // Schedule() should get called for the second time after params have changed.
   ActivateProvider();
 }
 
-TEST_F(RemoteSuggestionsSchedulerImplTest, FetchIntervalForSoftTriggerOnWifi) {
+TEST_F(RemoteSuggestionsSchedulerImplTest,
+       ReschedulesWhenStartupWifiParamChanges) {
+  EXPECT_CALL(*persistent_scheduler(), Schedule(_, _)).Times(2);
+  ActivateProvider();
+
+  // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
+  // null. Change the on usage interval for this class.
+  SetVariationParameter("startup_fetching_interval_hours-wifi-active_ntp_user",
+                        "1.5");
+
+  // Schedule() should get called for the second time after params have changed.
+  ActivateProvider();
+}
+
+TEST_F(RemoteSuggestionsSchedulerImplTest,
+       ReschedulesWhenStartupFallbackParamChanges) {
+  EXPECT_CALL(*persistent_scheduler(), Schedule(_, _)).Times(2);
+  ActivateProvider();
+
+  // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
+  // null. Change the fallback interval for this class.
+  SetVariationParameter(
+      "startup_fetching_interval_hours-fallback-active_ntp_user", "1.5");
+
+  // Schedule() should get called for the second time after params have changed.
+  ActivateProvider();
+}
+
+TEST_F(RemoteSuggestionsSchedulerImplTest, FetchIntervalForShownTriggerOnWifi) {
   // Pretend we are on WiFi (already done in ctor, we make it explicit here).
   EXPECT_CALL(*persistent_scheduler(), IsOnUnmeteredConnection())
       .WillRepeatedly(Return(true));
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER which uses a 3h time
-  // interval by default for soft background fetches on WiFi.
+  // interval by default for shown trigger on WiFi.
 
   // Initial scheduling after being enabled.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   ActivateProvider();
 
   // The first call to NTPOpened results in a fetch.
   RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
   EXPECT_CALL(*provider(), RefetchInTheBackground(_))
       .WillOnce(SaveArg<0>(&signal_fetch_done));
   scheduler()->OnNTPOpened();
   // Rescheduling after a succesful fetch.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   signal_fetch_done.Run(Status::Success());
 
   // Open NTP again after too short delay. This time no fetch is executed.
   test_clock()->Advance(base::TimeDelta::FromMinutes(30));
   scheduler()->OnNTPOpened();
 
   // Open NTP after another delay, now together long enough to issue a fetch.
   test_clock()->Advance(base::TimeDelta::FromMinutes(150));
   EXPECT_CALL(*provider(), RefetchInTheBackground(_));
   scheduler()->OnNTPOpened();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
-       OverrideFetchIntervalForSoftTriggerOnWifi) {
+       OverrideFetchIntervalForShownTriggerOnWifi) {
   // Pretend we are on WiFi (already done in ctor, we make it explicit here).
   EXPECT_CALL(*persistent_scheduler(), IsOnUnmeteredConnection())
       .WillRepeatedly(Return(true));
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
-  // null. Change the on usage interval for this class from 2h to 30min.
+  // null. Change the interval for this class from 4h to 30min.
   SetVariationParameter("soft_fetching_interval_hours-wifi-active_ntp_user",
                         "0.5");
 
   // Initial scheduling after being enabled.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   ActivateProvider();
 
   // The first call to NTPOpened results in a fetch.
   RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
   EXPECT_CALL(*provider(), RefetchInTheBackground(_))
       .WillOnce(SaveArg<0>(&signal_fetch_done));
   scheduler()->OnNTPOpened();
   // Rescheduling after a succesful fetch.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   signal_fetch_done.Run(Status::Success());
 
   // Open NTP again after too short delay. This time no fetch is executed.
   test_clock()->Advance(base::TimeDelta::FromMinutes(20));
   scheduler()->OnNTPOpened();
 
   // Open NTP after another delay, now together long enough to issue a fetch.
   test_clock()->Advance(base::TimeDelta::FromMinutes(10));
   EXPECT_CALL(*provider(), RefetchInTheBackground(_));
   scheduler()->OnNTPOpened();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
-       FetchIntervalForSoftTriggerOnFallback) {
+       FetchIntervalForShownTriggerOnFallback) {
   // Pretend we are not on wifi -> fallback connection.
   EXPECT_CALL(*persistent_scheduler(), IsOnUnmeteredConnection())
       .WillRepeatedly(Return(false));
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER which uses a 6h time
-  // interval by default for soft background fetches not on WiFi.
+  // interval by default for shown trigger not on WiFi.
 
   // Initial scheduling after being enabled.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   ActivateProvider();
 
   // The first call to NTPOpened results in a fetch.
   RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
   EXPECT_CALL(*provider(), RefetchInTheBackground(_))
       .WillOnce(SaveArg<0>(&signal_fetch_done));
   scheduler()->OnNTPOpened();
   // Rescheduling after a succesful fetch.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   signal_fetch_done.Run(Status::Success());
 
   // Open NTP again after too short delay. This time no fetch is executed.
   test_clock()->Advance(base::TimeDelta::FromMinutes(300));
   scheduler()->OnNTPOpened();
 
   // Open NTP after another delay, now together long enough to issue a fetch.
   test_clock()->Advance(base::TimeDelta::FromMinutes(60));
   EXPECT_CALL(*provider(), RefetchInTheBackground(_));
   scheduler()->OnNTPOpened();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
-       OverrideFetchIntervalForSoftTriggerOnFallback) {
+       OverrideFetchIntervalForShownTriggerOnFallback) {
   // Pretend we are not on wifi -> fallback connection.
   EXPECT_CALL(*persistent_scheduler(), IsOnUnmeteredConnection())
       .WillRepeatedly(Return(false));
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
-  // null. Change the on usage interval for this class from 4h to 30min.
+  // null. Change the interval for this class from 4h to 30min.
   SetVariationParameter("soft_fetching_interval_hours-fallback-active_ntp_user",
                         "0.5");
 
   // Initial scheduling after being enabled.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   ActivateProvider();
 
   // The first call to NTPOpened results in a fetch.
   RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
   EXPECT_CALL(*provider(), RefetchInTheBackground(_))
@@ skipping 89 matching lines @@
   for (int x = 0; x < 5; ++x) {
     scheduler()->OnPersistentSchedulerWakeUp();
     signal_fetch_done.Run(Status::Success());
   }
 
   // For the 6th time, it is blocked by the scheduling provider.
   scheduler()->OnPersistentSchedulerWakeUp();
 }
 
 }  // namespace ntp_snippets