[Remote suggestions] Prioritize wifi for soft fetches.

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 14 matching lines @@
 #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/remote/test_utils.h"
 #include "components/ntp_snippets/status.h"
 #include "components/ntp_snippets/user_classifier.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/testing_pref_service.h"
 #include "components/variations/variations_params_manager.h"
 #include "components/web_resource/web_resource_pref_names.h"
+#include "net/base/network_change_notifier.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Field;
 using testing::InSequence;
 using testing::Invoke;
 using testing::IsEmpty;
 using testing::Mock;
@@ skipping 13 matching lines @@
 class RemoteSuggestionsFetcher;
 
 namespace {
 
 class MockPersistentScheduler : public PersistentScheduler {
  public:
   MOCK_METHOD2(Schedule,
                bool(base::TimeDelta period_wifi,
                     base::TimeDelta period_fallback));
   MOCK_METHOD0(Unschedule, bool());
+  MOCK_METHOD0(IsOnUnmeteredConnection, bool());
 };
 
 // TODO(jkrcal): Move into its own library to reuse in other unit-tests?
 class MockRemoteSuggestionsProvider : public RemoteSuggestionsProvider {
  public:
   MockRemoteSuggestionsProvider(Observer* observer)
       : RemoteSuggestionsProvider(observer) {}
   MOCK_METHOD1(RefetchInTheBackground,
                void(const RemoteSuggestionsProvider::FetchStatusCallback&));
   MOCK_CONST_METHOD0(suggestions_fetcher_for_debugging,
@@ skipping 33 matching lines @@
                         {kArticleSuggestionsFeature.name}),
         user_classifier_(/*pref_service=*/nullptr,
                          base::MakeUnique<base::DefaultClock>()) {
     RemoteSuggestionsSchedulerImpl::RegisterProfilePrefs(
         utils_.pref_service()->registry());
     RequestThrottler::RegisterProfilePrefs(utils_.pref_service()->registry());
     // TODO(jkrcal) Create a static function in EulaAcceptedNotifier that
     // registers this pref and replace the call in browser_process_impl.cc & in
     // eula_accepted_notifier_unittest.cc with the new static function.
     local_state_.registry()->RegisterBooleanPref(::prefs::kEulaAccepted, false);
+    // By default pretend we are on WiFi.
+    EXPECT_CALL(*persistent_scheduler(), IsOnUnmeteredConnection())
+        .WillRepeatedly(Return(true));
     ResetProvider();
   }
 
   void ResetProvider() {
     provider_ = base::MakeUnique<StrictMock<MockRemoteSuggestionsProvider>>(
         /*observer=*/nullptr);
 
     auto test_clock = base::MakeUnique<base::SimpleTestClock>();
     test_clock_ = test_clock.get();
     test_clock_->SetNow(base::Time::Now());
@@ skipping 335 matching lines @@
   RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
   {
     InSequence s;
     // Initial scheduling after being enabled.
     EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
     // The first call to NTPOpened results in a fetch.
     EXPECT_CALL(*provider(), RefetchInTheBackground(_))
         .WillOnce(SaveArg<0>(&signal_fetch_done));
     // Rescheduling after a succesful fetch.
     EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
-    // The second call to NTPOpened 2hrs later again results in a fetch.
+    // 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 2hrs.
-  test_clock()->Advance(base::TimeDelta::FromHours(2));
+  // Open NTP again after 4hrs.
+  test_clock()->Advance(base::TimeDelta::FromHours(4));
   scheduler()->OnBrowserForegrounded();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
        ShouldRescheduleOnRescheduleFetching) {
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   scheduler()->RescheduleFetching();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest, ShouldScheduleOnActivation) {
@@ skipping 64 matching lines @@
     EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
     EXPECT_CALL(*persistent_scheduler(), Unschedule());
   }
   // First schedule so that later we really unschedule.
   ActivateProvider();
   DeactivateProvider();
   // No further call to Unschedule on second status callback.
   DeactivateProvider();
 }
 
-TEST_F(RemoteSuggestionsSchedulerImplTest, ReschedulesWhenWifiParamChanges) {
+TEST_F(RemoteSuggestionsSchedulerImplTest,
+       ReschedulesWhenPersistentWifiParamChanges) {
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _)).Times(2);
   ActivateProvider();
 
   // UserClassifier defaults to UserClass::ACTIVE_NTP_USER if PrefService is
   // null. Change the wifi interval for this class.
   SetVariationParameter("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,
-       ReschedulesWhenFallbackParamChanges) {
+       ReschedulesWhenPersistentFallbackParamChanges) {
   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("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,
-       ReschedulesWhenOnUsageEventParamChanges) {
+       ReschedulesWhenSoftWifiParamChanges) {
   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-active-active_ntp_user",
+  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,
-       ReschedulesWhenOnNtpOpenedParamChanges) {
+       ReschedulesWhenSoftFallbackParamChanges) {
   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_on_ntp_opened_interval_hours-active_ntp_user",
+  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, FetchIntervalForNtpOpenedTrigger) {
-  RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
-  {
-    InSequence s;
-    // Initial scheduling after being enabled.
-    EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
-    // The first call to NTPOpened results in a fetch.
-    EXPECT_CALL(*provider(), RefetchInTheBackground(_))
-        .WillOnce(SaveArg<0>(&signal_fetch_done));
-    // Rescheduling after a succesful fetch.
-    EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
-    // The third call to NTPOpened 35min later again results in a fetch.
-    EXPECT_CALL(*provider(), RefetchInTheBackground(_));
-  }
+TEST_F(RemoteSuggestionsSchedulerImplTest, FetchIntervalForSoftTriggerOnWifi) {
+  // Pretend we are on WiFi.
+  EXPECT_CALL(*persistent_scheduler(), IsOnUnmeteredConnection())
+      .WillRepeatedly(Return(true));

[Marc Treib, 2017/04/06 08:29:23]

Is this necessary, since it's already set in the ctor?
I guess you want to be explicit for this test?

[jkrcal, 2017/04/06 12:04:08]

Yep, updated the comment to make it clear.

+  // UserClassifier defaults to UserClass::ACTIVE_NTP_USER which uses a 2h time
+  // interval by default for soft background fetches 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());
 
-  // UserClassifier defaults to UserClass::ACTIVE_NTP_USER which uses a 2h time
-  // interval by default for soft backgroudn fetches on ntp open events.
-
-  // Open NTP again after 20min. This time no fetch is executed.
+  // Open NTP again after too short delay. This time no fetch is executed.
   test_clock()->Advance(base::TimeDelta::FromMinutes(20));
   scheduler()->OnNTPOpened();
 
-  // Open NTP again after 101min (121min since first opened). Since the default
-  // time interval has passed refetch again.
-  test_clock()->Advance(base::TimeDelta::FromMinutes(101));
+  // Open NTP after another delay, now together long enough to issue a fetch.
+  test_clock()->Advance(base::TimeDelta::FromMinutes(100));
+  EXPECT_CALL(*provider(), RefetchInTheBackground(_));
   scheduler()->OnNTPOpened();
 }
 
 TEST_F(RemoteSuggestionsSchedulerImplTest,
-       OverrideFetchIntervalForNtpOpenedTrigger) {
+       OverrideFetchIntervalForSoftTriggerOnWifi) {
+  // Pretend we are on WiFi.
+  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.
-  SetVariationParameter("soft_on_ntp_opened_interval_hours-active_ntp_user",
+  SetVariationParameter("soft_fetching_interval_hours-wifi-active_ntp_user",
                         "0.5");
 
-  RemoteSuggestionsProvider::FetchStatusCallback signal_fetch_done;
-  {
-    InSequence s;
-    // Initial scheduling after being enabled.
-    EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
-    // The first call to NTPOpened results in a fetch.
-    EXPECT_CALL(*provider(), RefetchInTheBackground(_))
-        .WillOnce(SaveArg<0>(&signal_fetch_done));
-    // Rescheduling after a succesful fetch.
-    EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
-    // The third call to NTPOpened 35min later again results in a fetch.
-    EXPECT_CALL(*provider(), RefetchInTheBackground(_));
-  }
-
+  // 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 20min. No fetch request is issues since the 30 min
-  // time interval has not passed yet.
+  // Open NTP again after too short delay. This time no fetch is executed.
   test_clock()->Advance(base::TimeDelta::FromMinutes(20));
   scheduler()->OnNTPOpened();
 
-  // Open NTP again after 15min (35min since first opened)
-  test_clock()->Advance(base::TimeDelta::FromMinutes(15));
+  // 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) {
+  // 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 4h time
+  // interval by default for soft background fetches 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(180));
+  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) {
+  // 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.
+  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(_))
+      .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,
        ShouldBlockFetchingForSomeTimeAfterHistoryCleared) {
   // First enable the scheduler -- this will trigger the persistent scheduling.
   EXPECT_CALL(*persistent_scheduler(), Schedule(_, _));
   ActivateProvider();
   // Clear the history.
   scheduler()->OnHistoryCleared();
 
   // A trigger after 15 minutes is ignored.
   test_clock()->Advance(base::TimeDelta::FromMinutes(15));
@@ skipping 63 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