[NTP Snippets] Scheduler: Fetch on Wifi (without charging) only 6AM-10PM

components/ntp_snippets/ntp_snippets_service.cc

 // Copyright 2015 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/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 17 matching lines @@
 using suggestions::SuggestionsService;
 
 namespace ntp_snippets {
 
 namespace {
 
 const int kFetchingIntervalWifiChargingSeconds = 30 * 60;
 const int kFetchingIntervalWifiSeconds = 2 * 60 * 60;
 const int kFetchingIntervalFallbackSeconds = 24 * 60 * 60;
 
+// These define the times of day during which we will fetch via Wifi (without
+// charging) - 6 AM to 10 PM.
+const int kWifiFetchingHourMin = 6;
+const int kWifiFetchingHourMax = 22;
+
 const int kDefaultExpiryTimeMins = 24 * 60;
 
 base::TimeDelta GetFetchingInterval(const char* switch_name,
                                     int default_value_seconds) {
   int value_seconds = default_value_seconds;
   const base::CommandLine& cmdline = *base::CommandLine::ForCurrentProcess();
   if (cmdline.HasSwitch(switch_name)) {
     std::string str = cmdline.GetSwitchValueASCII(switch_name);
     int switch_value_seconds = 0;
     if (base::StringToInt(str, &switch_value_seconds))
       value_seconds = switch_value_seconds;
     else
       LOG(WARNING) << "Invalid value for switch " << switch_name;
   }
   return base::TimeDelta::FromSeconds(value_seconds);
 }
 
 base::TimeDelta GetFetchingIntervalWifiCharging() {
   return GetFetchingInterval(switches::kFetchingIntervalWifiChargingSeconds,
                              kFetchingIntervalWifiChargingSeconds);
 }
 
-base::TimeDelta GetFetchingIntervalWifi() {
-  return GetFetchingInterval(switches::kFetchingIntervalWifiSeconds,
-                             kFetchingIntervalWifiSeconds);
+base::TimeDelta GetFetchingIntervalWifi(const base::Time& now) {
+  // Only fetch via Wifi (without charging) during the proper times of day.
+  base::Time::Exploded exploded;
+  now.LocalExplode(&exploded);
+  if (kWifiFetchingHourMin <= exploded.hour &&
+      exploded.hour < kWifiFetchingHourMax) {
+    return GetFetchingInterval(switches::kFetchingIntervalWifiSeconds,
+                               kFetchingIntervalWifiSeconds);
+  }
+  return base::TimeDelta();
 }
 
 base::TimeDelta GetFetchingIntervalFallback() {
   return GetFetchingInterval(switches::kFetchingIntervalFallbackSeconds,
                              kFetchingIntervalFallbackSeconds);
 }
 
+base::Time GetRescheduleTime(const base::Time& now) {
+  base::Time::Exploded exploded;
+  now.LocalExplode(&exploded);
+  // The scheduling changes at both |kWifiFetchingHourMin| and
+  // |kWifiFetchingHourMax|. Find the time of the next one that we'll hit.
+  bool next_day = false;
+  if (exploded.hour < kWifiFetchingHourMin) {
+    exploded.hour = kWifiFetchingHourMin;
+  } else if (exploded.hour < kWifiFetchingHourMax) {
+    exploded.hour = kWifiFetchingHourMax;
+  } else {
+    next_day = true;
+    exploded.hour = kWifiFetchingHourMin;
+  }
+  // In any case, reschedule at the full hour.
+  exploded.minute = 0;
+  exploded.second = 0;
+  exploded.millisecond = 0;
+  base::Time reschedule = base::Time::FromLocalExploded(exploded);
+  if (next_day)
+    reschedule += base::TimeDelta::FromDays(1);
+
+  return reschedule;
+}
+
 // Extracts the hosts from |suggestions| and returns them in a set.
 std::set<std::string> GetSuggestionsHostsImpl(
     const SuggestionsProfile& suggestions) {
   std::set<std::string> hosts;
   for (int i = 0; i < suggestions.suggestions_size(); ++i) {
     const ChromeSuggestion& suggestion = suggestions.suggestions(i);
     GURL url(suggestion.url());
     if (url.is_valid())
       hosts.insert(url.host());
   }
@@ skipping 37 matching lines @@
 }  // namespace
 
 NTPSnippetsService::NTPSnippetsService(
     PrefService* pref_service,
     SuggestionsService* suggestions_service,
     scoped_refptr<base::SequencedTaskRunner> file_task_runner,
     const std::string& application_language_code,
     NTPSnippetsScheduler* scheduler,
     scoped_ptr<NTPSnippetsFetcher> snippets_fetcher,
     const ParseJSONCallback& parse_json_callback)
-    : pref_service_(pref_service),
+    : enabled_(false),
+      pref_service_(pref_service),
       suggestions_service_(suggestions_service),
       file_task_runner_(file_task_runner),
       application_language_code_(application_language_code),
       scheduler_(scheduler),
       snippets_fetcher_(std::move(snippets_fetcher)),
       parse_json_callback_(parse_json_callback),
       weak_ptr_factory_(this) {
   snippets_fetcher_subscription_ = snippets_fetcher_->AddCallback(base::Bind(
       &NTPSnippetsService::OnSnippetsDownloaded, base::Unretained(this)));
 }
 
 NTPSnippetsService::~NTPSnippetsService() {}
 
 // static
 void NTPSnippetsService::RegisterProfilePrefs(PrefRegistrySimple* registry) {
   registry->RegisterListPref(prefs::kSnippets);
   registry->RegisterListPref(prefs::kDiscardedSnippets);
   registry->RegisterListPref(prefs::kSnippetHosts);
 }
 
 void NTPSnippetsService::Init(bool enabled) {
-  if (enabled) {
+  enabled_ = enabled;
+  if (enabled_) {
     // |suggestions_service_| can be null in tests.
     if (suggestions_service_) {
       suggestions_service_subscription_ = suggestions_service_->AddCallback(
           base::Bind(&NTPSnippetsService::OnSuggestionsChanged,
                      base::Unretained(this)));
     }
 
     // Get any existing snippets immediately from prefs.
     LoadDiscardedSnippetsFromPrefs();
     LoadSnippetsFromPrefs();
 
     // If we don't have any snippets yet, start a fetch.
     if (snippets_.empty())
       FetchSnippets();
   }
 
-  // The scheduler only exists on Android so far, it's null on other platforms.
-  if (!scheduler_)
-    return;
-
-  if (enabled) {
-    scheduler_->Schedule(GetFetchingIntervalWifiCharging(),
-                         GetFetchingIntervalWifi(),
-                         GetFetchingIntervalFallback());
-  } else {
-    scheduler_->Unschedule();
-  }
+  RescheduleFetching();
 }
 
 void NTPSnippetsService::Shutdown() {
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceShutdown());
+  enabled_ = false;
 }
 
 void NTPSnippetsService::FetchSnippets() {
   FetchSnippetsFromHosts(GetSuggestionsHosts());
 }
 
 void NTPSnippetsService::FetchSnippetsFromHosts(
     const std::set<std::string>& hosts) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDontRestrict)) {
     snippets_fetcher_->FetchSnippets(std::set<std::string>());
     return;
   }
   if (!hosts.empty())
     snippets_fetcher_->FetchSnippets(hosts);
 }
 
+void NTPSnippetsService::RescheduleFetching() {
+  // The scheduler only exists on Android so far, it's null on other platforms.
+  if (!scheduler_)
+    return;
+
+  if (enabled_) {
+    base::Time now = base::Time::Now();
+    scheduler_->Schedule(
+        GetFetchingIntervalWifiCharging(), GetFetchingIntervalWifi(now),
+        GetFetchingIntervalFallback(), GetRescheduleTime(now));
+  } else {
+    scheduler_->Unschedule();
+  }
+}
+
 void NTPSnippetsService::ClearSnippets() {
   snippets_.clear();
 
   StoreSnippetsToPrefs();
 
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded());
 }
 
 std::set<std::string> NTPSnippetsService::GetSuggestionsHosts() const {
@@ skipping 215 matching lines @@
     if (snippet->expiry_date() < next_expiry)
       next_expiry = snippet->expiry_date();
   }
   DCHECK_GT(next_expiry, expiry);
   expiry_timer_.Start(FROM_HERE, next_expiry - expiry,
                       base::Bind(&NTPSnippetsService::RemoveExpiredSnippets,
                                  base::Unretained(this)));
 }
 
 }  // namespace ntp_snippets