Break CloudPolicyRefreshScheduler's dependency on PrefService.

chrome/browser/policy/cloud_policy_refresh_scheduler.cc

 // Copyright (c) 2012 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 "chrome/browser/policy/cloud_policy_refresh_scheduler.h"
 
 #include <algorithm>
 
 #include "base/task_runner.h"
 #include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/prefs/pref_service.h"

[bartfab (slow), 2012/12/04 12:25:18]

Nit: No longer needed.

[Mattias Nissler (ping if slow), 2012/12/04 13:20:40]

Done.

 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_details.h"
 
 namespace policy {
 
+const int64 CloudPolicyRefreshScheduler::kDefaultRefreshDelayMs =
+    3 * 60 * 60 * 1000;  // 3 hours.
 const int64 CloudPolicyRefreshScheduler::kUnmanagedRefreshDelayMs =
     24 * 60 * 60 * 1000;  // 1 day.
 const int64 CloudPolicyRefreshScheduler::kInitialErrorRetryDelayMs =
     5 * 60 * 1000;  // 5 minutes.
 const int64 CloudPolicyRefreshScheduler::kRefreshDelayMinMs =
     30 * 60 * 1000;  // 30 minutes.
 const int64 CloudPolicyRefreshScheduler::kRefreshDelayMaxMs =
     24 * 60 * 60 * 1000;  // 1 day.
 
 CloudPolicyRefreshScheduler::CloudPolicyRefreshScheduler(
     CloudPolicyClient* client,
     CloudPolicyStore* store,
-    PrefService* prefs,
-    const std::string& refresh_pref,
     const scoped_refptr<base::TaskRunner>& task_runner)
     : client_(client),
       store_(store),
       task_runner_(task_runner),
-      error_retry_delay_ms_(kInitialErrorRetryDelayMs) {
+      error_retry_delay_ms_(kInitialErrorRetryDelayMs),
+      refresh_delay_ms_(kDefaultRefreshDelayMs) {
   client_->AddObserver(this);
   store_->AddObserver(this);
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
 
-  refresh_delay_.Init(
-      refresh_pref.c_str(), prefs,
-      base::Bind(&CloudPolicyRefreshScheduler::ScheduleRefresh,
-                 base::Unretained(this)));
-
   UpdateLastRefreshFromPolicy();
   ScheduleRefresh();
 }
 
 CloudPolicyRefreshScheduler::~CloudPolicyRefreshScheduler() {
   store_->RemoveObserver(this);
   client_->RemoveObserver(this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
+void CloudPolicyRefreshScheduler::SetRefreshDelay(int64 refresh_delay) {
+  refresh_delay_ms_ = refresh_delay;

[bartfab (slow), 2012/12/04 12:25:18]

Why not clamp when setting the value here instead of storing a potentially
invalid value and continuously clamping on-the-fly in the getter?

[Mattias Nissler (ping if slow), 2012/12/04 13:20:40]

Doesn't matter really, but I guess what you propose makes this simpler. Done.

+  ScheduleRefresh();
+}
+
 void CloudPolicyRefreshScheduler::OnPolicyFetched(CloudPolicyClient* client) {
   error_retry_delay_ms_ = kInitialErrorRetryDelayMs;
 
   // Schedule the next refresh.
   last_refresh_ = base::Time::NowFromSystemTime();
   ScheduleRefresh();
 }
 
 void CloudPolicyRefreshScheduler::OnRegistrationStateChanged(
     CloudPolicyClient* client) {
@@ skipping 131 matching lines @@
   base::TimeDelta delay =
       std::max((last_refresh_ + delta) - base::Time::NowFromSystemTime(),
                base::TimeDelta());
   refresh_callback_.Reset(
       base::Bind(&CloudPolicyRefreshScheduler::PerformRefresh,
                  base::Unretained(this)));
   task_runner_->PostDelayedTask(FROM_HERE, refresh_callback_.callback(), delay);
 }
 
 int64 CloudPolicyRefreshScheduler::GetRefreshDelay() {
-  return std::min(std::max<int64>(refresh_delay_.GetValue(),
-                                  kRefreshDelayMinMs),
+  return std::min(std::max(refresh_delay_ms_, kRefreshDelayMinMs),
                   kRefreshDelayMaxMs);
 }
 
 }  // namespace policy