[Doodle] Don't refresh more than once per 15 mins

components/doodle/doodle_service.cc

 // Copyright 2017 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/doodle/doodle_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/time/time.h"
 #include "base/values.h"
 #include "components/doodle/pref_names.h"
 #include "components/prefs/pref_registry.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 
 namespace doodle {
 
 namespace {
 
+// The maximum time-to-live we'll accept; any larger values will be clamped to
+// this one. This is a last resort in case the server sends bad data.
 const int64_t kMaxTimeToLiveSecs = 30 * 24 * 60 * 60;  // 30 days
 
+// The default value for DoodleService::min_refresh_interval_.
+const int64_t kDefaultMinRefreshIntervalSecs = 15 * 60;  // 15 minutes
+
 }  // namespace
 
 // static
 void DoodleService::RegisterProfilePrefs(PrefRegistrySimple* pref_registry) {
   pref_registry->RegisterDictionaryPref(prefs::kCachedConfig,
                                         new base::DictionaryValue(),
                                         PrefRegistry::LOSSY_PREF);
   pref_registry->RegisterInt64Pref(prefs::kCachedConfigExpiry, 0,
                                    PrefRegistry::LOSSY_PREF);
 }
 
-DoodleService::DoodleService(PrefService* pref_service,
-                             std::unique_ptr<DoodleFetcher> fetcher,
-                             std::unique_ptr<base::OneShotTimer> expiry_timer,
-                             std::unique_ptr<base::Clock> clock,
-                             std::unique_ptr<base::TickClock> tick_clock)
+DoodleService::DoodleService(
+    PrefService* pref_service,
+    std::unique_ptr<DoodleFetcher> fetcher,
+    std::unique_ptr<base::OneShotTimer> expiry_timer,
+    std::unique_ptr<base::Clock> clock,
+    std::unique_ptr<base::TickClock> tick_clock,
+    base::Optional<base::TimeDelta> override_min_refresh_interval)
     : pref_service_(pref_service),
       fetcher_(std::move(fetcher)),
       expiry_timer_(std::move(expiry_timer)),
       clock_(std::move(clock)),
-      tick_clock_(std::move(tick_clock)) {
+      tick_clock_(std::move(tick_clock)),
+      min_refresh_interval_(
+          override_min_refresh_interval.has_value()
+              ? override_min_refresh_interval.value()
+              : base::TimeDelta::FromSeconds(kDefaultMinRefreshIntervalSecs)) {
   DCHECK(pref_service_);
   DCHECK(fetcher_);
   DCHECK(expiry_timer_);
   DCHECK(clock_);
   DCHECK(tick_clock_);
 
   base::Time expiry_date = base::Time::FromInternalValue(
       pref_service_->GetInt64(prefs::kCachedConfigExpiry));
   base::Optional<DoodleConfig> config = DoodleConfig::FromDictionary(
       *pref_service_->GetDictionary(prefs::kCachedConfig), base::nullopt);
   DoodleState state =
       config.has_value() ? DoodleState::AVAILABLE : DoodleState::NO_DOODLE;
   HandleNewConfig(state, expiry_date - clock_->Now(), config);
 }
 
 DoodleService::~DoodleService() = default;
 
 void DoodleService::Shutdown() {}
 
 void DoodleService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DoodleService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void DoodleService::Refresh() {
+  base::TimeTicks now_ticks = tick_clock_->NowTicks();
+  // Check if we have passed the minimum refresh interval.
+  base::TimeDelta time_since_fetch = now_ticks - last_successful_fetch_;
+  if (time_since_fetch < min_refresh_interval_) {
+    RecordDownloadMetrics(OUTCOME_REFRESH_INTERVAL_NOT_PASSED,
+                          base::TimeDelta());
+    return;
+  }
   fetcher_->FetchDoodle(base::BindOnce(&DoodleService::DoodleFetched,
-                                       base::Unretained(this),
-                                       tick_clock_->NowTicks()));
+                                       base::Unretained(this), now_ticks));
 }
 
 // static
 bool DoodleService::DownloadOutcomeIsSuccess(DownloadOutcome outcome) {
   switch (outcome) {
     case OUTCOME_NEW_DOODLE:
     case OUTCOME_REVALIDATED_DOODLE:
     case OUTCOME_CHANGED_DOODLE:
     case OUTCOME_NO_DOODLE:
       return true;
     case OUTCOME_EXPIRED:
     case OUTCOME_DOWNLOAD_ERROR:
     case OUTCOME_PARSING_ERROR:
+    case OUTCOME_REFRESH_INTERVAL_NOT_PASSED:
       return false;
     case OUTCOME_COUNT:
       NOTREACHED();
   }
   return false;
 }
 
 // static
 void DoodleService::RecordDownloadMetrics(DownloadOutcome outcome,
                                           base::TimeDelta download_time) {
@@ skipping 39 matching lines @@
     return OUTCOME_CHANGED_DOODLE;
   }
   return OUTCOME_REVALIDATED_DOODLE;
 }
 
 void DoodleService::DoodleFetched(
     base::TimeTicks start_time,
     DoodleState state,
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
-  base::TimeDelta download_time = tick_clock_->NowTicks() - start_time;
+  base::TimeTicks now_ticks = tick_clock_->NowTicks();
   DownloadOutcome outcome = HandleNewConfig(state, time_to_live, doodle_config);
+  if (DownloadOutcomeIsSuccess(outcome)) {
+    last_successful_fetch_ = now_ticks;
+  }
+  base::TimeDelta download_time = now_ticks - start_time;
   RecordDownloadMetrics(outcome, download_time);
 }
 
 DoodleService::DownloadOutcome DoodleService::HandleNewConfig(
     DoodleState state,
     base::TimeDelta time_to_live,
     const base::Optional<DoodleConfig>& doodle_config) {
   // Clamp the time-to-live to some reasonable maximum.
   if (time_to_live.InSeconds() > kMaxTimeToLiveSecs) {
     time_to_live = base::TimeDelta::FromSeconds(kMaxTimeToLiveSecs);
@@ skipping 50 matching lines @@
     pref_service_->ClearPref(prefs::kCachedConfigExpiry);
   }
 }
 
 void DoodleService::DoodleExpired() {
   DCHECK(cached_config_.has_value());
   HandleNewConfig(DoodleState::NO_DOODLE, base::TimeDelta(), base::nullopt);
 }
 
 }  // namespace doodle