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"
 #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_ = std::min(std::max(refresh_delay, kRefreshDelayMinMs),
+                               kRefreshDelayMaxMs);
+  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 10 matching lines @@
 
   // Schedule an error retry if applicable.
   last_refresh_ = base::Time::NowFromSystemTime();
   ScheduleRefresh();
 
   // Update the retry delay.
   if (client->is_registered() &&
       (status == DM_STATUS_REQUEST_FAILED ||
        status == DM_STATUS_TEMPORARY_UNAVAILABLE)) {
     error_retry_delay_ms_ = std::min(error_retry_delay_ms_ * 2,
-                                     GetRefreshDelay());
+                                     refresh_delay_ms_);
   } else {
     error_retry_delay_ms_ = kInitialErrorRetryDelayMs;
   }
 }
 
 void CloudPolicyRefreshScheduler::OnStoreLoaded(CloudPolicyStore* store) {
   UpdateLastRefreshFromPolicy();
 
   // Re-schedule the next refresh in case the is_managed bit changed.
   ScheduleRefresh();
@@ skipping 38 matching lines @@
   if (!client_->is_registered()) {
     refresh_callback_.Cancel();
     return;
   }
 
   // If there is a registration, go by the client's status. That will tell us
   // what the appropriate refresh delay should be.
   switch (client_->status()) {
     case DM_STATUS_SUCCESS:
       if (store_->is_managed())
-        RefreshAfter(GetRefreshDelay());
+        RefreshAfter(refresh_delay_ms_);
       else
         RefreshAfter(kUnmanagedRefreshDelayMs);
       return;
     case DM_STATUS_SERVICE_ACTIVATION_PENDING:
     case DM_STATUS_SERVICE_POLICY_NOT_FOUND:
-      RefreshAfter(GetRefreshDelay());
+      RefreshAfter(refresh_delay_ms_);
       return;
     case DM_STATUS_REQUEST_FAILED:
     case DM_STATUS_TEMPORARY_UNAVAILABLE:
       RefreshAfter(error_retry_delay_ms_);
       return;
     case DM_STATUS_REQUEST_INVALID:
     case DM_STATUS_HTTP_STATUS_ERROR:
     case DM_STATUS_RESPONSE_DECODING_ERROR:
     case DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED:
       RefreshAfter(kUnmanagedRefreshDelayMs);
@@ skipping 34 matching lines @@
   // Schedule the callback.
   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),
-                  kRefreshDelayMaxMs);
-}
-
 }  // namespace policy