Revert 71656 - Allow policy refresh rate to be configured through policy

BUG=none
TEST=none
TBR=mnissler

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@71663 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 269 insertions, 463 deletions

diff --git a/chrome/browser/policy/config_dir_policy_provider_unittest.cc b/chrome/browser/policy/config_dir_policy_provider_unittest.cc
index 67ac917..30c2189 100644
--- a/chrome/browser/policy/config_dir_policy_provider_unittest.cc
+++ b/chrome/browser/policy/config_dir_policy_provider_unittest.cc
@@ -320,9 +320,6 @@ INSTANTIATE_TEST_CASE_P(
             key::kShowHomeButton),
         ValueTestParams::ForBooleanPolicy(
             kPolicyPrintingEnabled,
-            key::kPrintingEnabled),
-        ValueTestParams::ForIntegerPolicy(
-            kPolicyPolicyRefreshRate,
-            key::kPolicyRefreshRate)));
+            key::kPrintingEnabled)));
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_pref_store.cc b/chrome/browser/policy/configuration_policy_pref_store.cc
index 80e0dea..58b5cac 100644
--- a/chrome/browser/policy/configuration_policy_pref_store.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store.cc
@@ -223,8 +223,6 @@ const ConfigurationPolicyPrefKeeper::PolicyToPreferenceMapEntry
     prefs::kGSSAPILibraryName },
   { Value::TYPE_BOOLEAN, kPolicyDisable3DAPIs,
     prefs::kDisable3DAPIs },
-  { Value::TYPE_INTEGER, kPolicyPolicyRefreshRate,
-    prefs::kPolicyRefreshRate },
 
 #if defined(OS_CHROMEOS)
   { Value::TYPE_BOOLEAN, kPolicyChromeOsLockOnIdleSuspend,
@@ -836,8 +834,6 @@ ConfigurationPolicyPrefStore::GetChromePolicyDefinitionList() {
       key::kGSSAPILibraryName },
     { kPolicyDisable3DAPIs, Value::TYPE_BOOLEAN,
       key::kDisable3DAPIs },
-    { kPolicyPolicyRefreshRate, Value::TYPE_INTEGER,
-      key::kPolicyRefreshRate },
 
 #if defined(OS_CHROMEOS)
     { kPolicyChromeOsLockOnIdleSuspend, Value::TYPE_BOOLEAN,
diff --git a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
index e133bc9..d81ff91 100644
--- a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
@@ -220,9 +220,7 @@ INSTANTIATE_TEST_CASE_P(
     ConfigurationPolicyPrefStoreIntegerTest,
     testing::Values(
         TypeAndName(kPolicyRestoreOnStartup,
-                    prefs::kRestoreOnStartup),
-        TypeAndName(kPolicyPolicyRefreshRate,
-                    prefs::kPolicyRefreshRate)));
+                    prefs::kRestoreOnStartup)));
 
 // Test cases for the proxy policy settings.
 class ConfigurationPolicyPrefStoreProxyTest : public testing::Test {
diff --git a/chrome/browser/policy/configuration_policy_provider.cc b/chrome/browser/policy/configuration_policy_provider.cc
index 5282eae..3b82134 100644
--- a/chrome/browser/policy/configuration_policy_provider.cc
+++ b/chrome/browser/policy/configuration_policy_provider.cc
@@ -34,9 +34,7 @@ void ConfigurationPolicyProvider::DecodePolicyValueTree(
 
 // Class ConfigurationPolicyObserverRegistrar.
 
-ConfigurationPolicyObserverRegistrar::ConfigurationPolicyObserverRegistrar()
-  : provider_(NULL),
-    observer_(NULL) {}
+ConfigurationPolicyObserverRegistrar::ConfigurationPolicyObserverRegistrar() {}
 
 ConfigurationPolicyObserverRegistrar::~ConfigurationPolicyObserverRegistrar() {
   if (provider_)
diff --git a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
index d221f9a..11d04a7 100644
--- a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
@@ -294,9 +294,6 @@ INSTANTIATE_TEST_CASE_P(
             key::kShowHomeButton),
         PolicyTestParams::ForBooleanPolicy(
             kPolicyPrintingEnabled,
-            key::kPrintingEnabled),
-        PolicyTestParams::ForIntegerPolicy(
-            kPolicyPolicyRefreshRate,
-            key::kPolicyRefreshRate)));
+            key::kPrintingEnabled)));
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
index 1d2a9ee..481e1d8 100644
--- a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
@@ -449,9 +449,6 @@ INSTANTIATE_TEST_CASE_P(
             key::kShowHomeButton),
         PolicyTestParams::ForBooleanPolicy(
             kPolicyPrintingEnabled,
-            key::kPrintingEnabled),
-        PolicyTestParams::ForIntegerPolicy(
-            kPolicyPolicyRefreshRate,
-            key::kPolicyRefreshRate)));
+            key::kPrintingEnabled)));
 
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_store_interface.h b/chrome/browser/policy/configuration_policy_store_interface.h
index e697ed1..b7f2f05 100644
--- a/chrome/browser/policy/configuration_policy_store_interface.h
+++ b/chrome/browser/policy/configuration_policy_store_interface.h
@@ -68,8 +68,7 @@ enum ConfigurationPolicyType {
   kPolicyAuthServerWhitelist,
   kPolicyAuthNegotiateDelegateWhitelist,
   kPolicyGSSAPILibraryName,
-  kPolicyDisable3DAPIs,
-  kPolicyPolicyRefreshRate,
+  kPolicyDisable3DAPIs
 };
 
 
diff --git a/chrome/browser/policy/device_management_policy_provider.cc b/chrome/browser/policy/device_management_policy_provider.cc
index 4ea5f28..8b9d9b4 100644
--- a/chrome/browser/policy/device_management_policy_provider.cc
+++ b/chrome/browser/policy/device_management_policy_provider.cc
@@ -12,7 +12,6 @@
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_management_policy_cache.h"
-#include "chrome/browser/policy/profile_policy_context.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
@@ -24,13 +23,8 @@ namespace policy {
 
 namespace em = enterprise_management;
 
-// The maximum ratio in percent of the policy refresh rate we use for adjusting
-// the policy refresh time instant. The rationale is to avoid load spikes if
-// from many devices that were set up in sync for some reason.
-const int kPolicyRefreshDeviationFactorPercent = 10;
-// Maximum deviation we are willing to accept.
-const int64 kPolicyRefreshDeviationMaxInMilliseconds = 30 * 60 * 1000;
-
+const int64 kPolicyRefreshRateInMilliseconds = 3 * 60 * 60 * 1000;  // 3 hours
+const int64 kPolicyRefreshMaxEarlierInMilliseconds = 20 * 60 * 1000;  // 20 mins
 // These are the base values for delays before retrying after an error. They
 // will be doubled each time they are used.
 const int64 kPolicyRefreshErrorDelayInMilliseconds = 3 * 1000;  // 3 seconds
@@ -41,25 +35,44 @@ const int64 kPolicyRefreshUnmanagedDeviceInMilliseconds = 24 * 60 * 60 * 1000;
 const FilePath::StringType kDeviceTokenFilename = FILE_PATH_LITERAL("Token");
 const FilePath::StringType kPolicyFilename = FILE_PATH_LITERAL("Policy");
 
-// Calls back into the provider to refresh policy.
-class DeviceManagementPolicyProvider::RefreshTask : public CancelableTask {
+// Ensures that the portion of the policy provider implementation that requires
+// the IOThread is deferred until the IOThread is fully initialized. The policy
+// provider posts this task on the UI thread during its constructor, thereby
+// guaranteeing that the code won't get executed until after the UI and IO
+// threads are fully constructed.
+class DeviceManagementPolicyProvider::InitializeAfterIOThreadExistsTask
+    : public Task {
  public:
-  explicit RefreshTask(DeviceManagementPolicyProvider* provider)
-      : provider_(provider) {}
+  explicit InitializeAfterIOThreadExistsTask(
+      base::WeakPtr<DeviceManagementPolicyProvider> provider)
+      : provider_(provider) {
+  }
 
   // Task implementation:
   virtual void Run() {
-    if (provider_)
-      provider_->RefreshTaskExecute();
+    DeviceManagementPolicyProvider* provider = provider_.get();
+    if (provider)
+      provider->InitializeAfterIOThreadExists();
   }
 
-  // CancelableTask implementation:
-  virtual void Cancel() {
-    provider_ = NULL;
+ private:
+  base::WeakPtr<DeviceManagementPolicyProvider> provider_;
+};
+
+class DeviceManagementPolicyProvider::RefreshTask : public Task {
+ public:
+  explicit RefreshTask(base::WeakPtr<DeviceManagementPolicyProvider> provider)
+      : provider_(provider) {}
+
+  // Task implementation:
+  virtual void Run() {
+    DeviceManagementPolicyProvider* provider = provider_.get();
+    if (provider)
+      provider->RefreshTaskExecute();
   }
 
  private:
-  DeviceManagementPolicyProvider* provider_;
+  base::WeakPtr<DeviceManagementPolicyProvider> provider_;
 };
 
 DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
@@ -69,19 +82,36 @@ DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
     : ConfigurationPolicyProvider(policy_list) {
   Initialize(backend,
              profile,
-             ProfilePolicyContext::kDefaultPolicyRefreshRateInMilliseconds,
-             kPolicyRefreshDeviationFactorPercent,
-             kPolicyRefreshDeviationMaxInMilliseconds,
+             kPolicyRefreshRateInMilliseconds,
+             kPolicyRefreshMaxEarlierInMilliseconds,
              kPolicyRefreshErrorDelayInMilliseconds,
              kDeviceTokenRefreshErrorDelayInMilliseconds,
              kPolicyRefreshUnmanagedDeviceInMilliseconds);
 }
 
+DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
+    const PolicyDefinitionList* policy_list,
+    DeviceManagementBackend* backend,
+    Profile* profile,
+    int64 policy_refresh_rate_ms,
+    int64 policy_refresh_max_earlier_ms,
+    int64 policy_refresh_error_delay_ms,
+    int64 token_fetch_error_delay_ms,
+    int64 unmanaged_device_refresh_rate_ms)
+    : ConfigurationPolicyProvider(policy_list) {
+  Initialize(backend,
+             profile,
+             policy_refresh_rate_ms,
+             policy_refresh_max_earlier_ms,
+             policy_refresh_error_delay_ms,
+             token_fetch_error_delay_ms,
+             unmanaged_device_refresh_rate_ms);
+}
+
 DeviceManagementPolicyProvider::~DeviceManagementPolicyProvider() {
   FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                     observer_list_,
                     OnProviderGoingAway());
-  CancelRefreshTask();
 }
 
 bool DeviceManagementPolicyProvider::Provide(
@@ -92,141 +122,156 @@ bool DeviceManagementPolicyProvider::Provide(
 }
 
 bool DeviceManagementPolicyProvider::IsInitializationComplete() const {
-  return !cache_->last_policy_refresh_time().is_null();
+  return !waiting_for_initial_policies_;
 }
 
 void DeviceManagementPolicyProvider::HandlePolicyResponse(
     const em::DevicePolicyResponse& response) {
-  DCHECK(TokenAvailable());
-  if (cache_->SetPolicy(response)) {
-    initial_fetch_done_ = true;
+  if (cache_->SetPolicy(response))
     NotifyCloudPolicyUpdate();
-  }
-  SetState(STATE_POLICY_VALID);
+  policy_request_pending_ = false;
+  // Reset the error delay since policy fetching succeeded this time.
+  policy_refresh_error_delay_ms_ = kPolicyRefreshErrorDelayInMilliseconds;
+  ScheduleRefreshTask(GetRefreshTaskDelay());
+  // Update this provider's internal waiting state, but don't notify anyone
+  // else yet (that's done by the PrefValueStore that receives the policy).
+  waiting_for_initial_policies_ = false;
 }
 
 void DeviceManagementPolicyProvider::OnError(
     DeviceManagementBackend::ErrorCode code) {
-  DCHECK(TokenAvailable());
+  policy_request_pending_ = false;
   if (code == DeviceManagementBackend::kErrorServiceDeviceNotFound ||
       code == DeviceManagementBackend::kErrorServiceManagementTokenInvalid) {
     LOG(WARNING) << "The device token was either invalid or unknown to the "
                  << "device manager, re-registering device.";
-    SetState(STATE_TOKEN_RESET);
+    token_fetcher_->Restart();
   } else if (code ==
              DeviceManagementBackend::kErrorServiceManagementNotSupported) {
     VLOG(1) << "The device is no longer managed, resetting device token.";
-    SetState(STATE_TOKEN_RESET);
+    token_fetcher_->Restart();
   } else {
     LOG(WARNING) << "Could not provide policy from the device manager (error = "
                  << code << "), will retry in "
-                 << (effective_policy_refresh_error_delay_ms_ / 1000)
-                 << " seconds.";
-    SetState(STATE_POLICY_ERROR);
+                 << (policy_refresh_error_delay_ms_/1000) << " seconds.";
+    ScheduleRefreshTask(policy_refresh_error_delay_ms_);
+    policy_refresh_error_delay_ms_ *= 2;
+    if (policy_refresh_rate_ms_ &&
+        policy_refresh_rate_ms_ < policy_refresh_error_delay_ms_) {
+      policy_refresh_error_delay_ms_ = policy_refresh_rate_ms_;
+    }
   }
+  StopWaitingForInitialPolicies();
 }
 
 void DeviceManagementPolicyProvider::OnTokenSuccess() {
-  DCHECK(!TokenAvailable());
+  if (policy_request_pending_)
+    return;
   cache_->SetDeviceUnmanaged(false);
-  SetState(STATE_TOKEN_VALID);
+  SendPolicyRequest();
 }
 
 void DeviceManagementPolicyProvider::OnTokenError() {
-  DCHECK(!TokenAvailable());
   LOG(WARNING) << "Could not retrieve device token.";
-  SetState(STATE_TOKEN_ERROR);
+  ScheduleRefreshTask(token_fetch_error_delay_ms_);
+  token_fetch_error_delay_ms_ *= 2;
+  if (token_fetch_error_delay_ms_ > policy_refresh_rate_ms_)
+    token_fetch_error_delay_ms_ = policy_refresh_rate_ms_;
+  StopWaitingForInitialPolicies();
 }
 
 void DeviceManagementPolicyProvider::OnNotManaged() {
-  DCHECK(!TokenAvailable());
   VLOG(1) << "This device is not managed.";
   cache_->SetDeviceUnmanaged(true);
-  SetState(STATE_UNMANAGED);
+  ScheduleRefreshTask(unmanaged_device_refresh_rate_ms_);
+  StopWaitingForInitialPolicies();
 }
 
-void DeviceManagementPolicyProvider::SetRefreshRate(
-    int64 refresh_rate_milliseconds) {
-  policy_refresh_rate_ms_ = refresh_rate_milliseconds;
+void DeviceManagementPolicyProvider::AddObserver(
+    ConfigurationPolicyProvider::Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
 
-  // Reschedule the refresh task if necessary.
-  if (state_ == STATE_POLICY_VALID)
-    SetState(STATE_POLICY_VALID);
+void DeviceManagementPolicyProvider::RemoveObserver(
+    ConfigurationPolicyProvider::Observer* observer) {
+  observer_list_.RemoveObserver(observer);
 }
 
-DeviceManagementPolicyProvider::DeviceManagementPolicyProvider(
-    const PolicyDefinitionList* policy_list,
-    DeviceManagementBackend* backend,
-    Profile* profile,
-    int64 policy_refresh_rate_ms,
-    int policy_refresh_deviation_factor_percent,
-    int64 policy_refresh_deviation_max_ms,
-    int64 policy_refresh_error_delay_ms,
-    int64 token_fetch_error_delay_ms,
-    int64 unmanaged_device_refresh_rate_ms)
-    : ConfigurationPolicyProvider(policy_list) {
-  Initialize(backend,
-             profile,
-             policy_refresh_rate_ms,
-             policy_refresh_deviation_factor_percent,
-             policy_refresh_deviation_max_ms,
-             policy_refresh_error_delay_ms,
-             token_fetch_error_delay_ms,
-             unmanaged_device_refresh_rate_ms);
+void DeviceManagementPolicyProvider::NotifyCloudPolicyUpdate() {
+  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
+                    observer_list_,
+                    OnUpdatePolicy());
 }
 
 void DeviceManagementPolicyProvider::Initialize(
     DeviceManagementBackend* backend,
     Profile* profile,
     int64 policy_refresh_rate_ms,
-    int policy_refresh_deviation_factor_percent,
-    int64 policy_refresh_deviation_max_ms,
+    int64 policy_refresh_max_earlier_ms,
     int64 policy_refresh_error_delay_ms,
     int64 token_fetch_error_delay_ms,
     int64 unmanaged_device_refresh_rate_ms) {
-  DCHECK(profile);
   backend_.reset(backend);
   profile_ = profile;
   storage_dir_ = GetOrCreateDeviceManagementDir(profile_->GetPath());
-  state_ = STATE_INITIALIZING;
-  initial_fetch_done_ = false;
-  refresh_task_ = NULL;
+  policy_request_pending_ = false;
+  refresh_task_pending_ = false;
+  waiting_for_initial_policies_ = true;
   policy_refresh_rate_ms_ = policy_refresh_rate_ms;
-  policy_refresh_deviation_factor_percent_ =
-      policy_refresh_deviation_factor_percent;
-  policy_refresh_deviation_max_ms_ = policy_refresh_deviation_max_ms;
+  policy_refresh_max_earlier_ms_ = policy_refresh_max_earlier_ms;
   policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
-  effective_policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms;
   token_fetch_error_delay_ms_ = token_fetch_error_delay_ms;
-  effective_token_fetch_error_delay_ms_ = token_fetch_error_delay_ms;
   unmanaged_device_refresh_rate_ms_ = unmanaged_device_refresh_rate_ms;
 
   const FilePath policy_path = storage_dir_.Append(kPolicyFilename);
   cache_.reset(new DeviceManagementPolicyCache(policy_path));
   cache_->LoadPolicyFromFile();
 
-  SetDeviceTokenFetcher(new DeviceTokenFetcher(backend_.get(), profile,
-                                               GetTokenPath()));
-
   if (cache_->is_device_unmanaged()) {
     // This is a non-first login on an unmanaged device.
-    SetState(STATE_UNMANAGED);
+    waiting_for_initial_policies_ = false;
+    // Defer token_fetcher_ initialization until this device should ask for
+    // a device token again.
+    base::Time unmanaged_timestamp = cache_->last_policy_refresh_time();
+    int64 delay = unmanaged_device_refresh_rate_ms_ -
+        (base::Time::NowFromSystemTime().ToInternalValue() -
+            unmanaged_timestamp.ToInternalValue());
+    if (delay < 0)
+      delay = 0;
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI, FROM_HERE,
+        new InitializeAfterIOThreadExistsTask(AsWeakPtr()),
+        delay);
   } else {
-    SetState(STATE_INITIALIZING);
+    if (file_util::PathExists(
+        storage_dir_.Append(kDeviceTokenFilename))) {
+      // This is a non-first login on a managed device.
+      waiting_for_initial_policies_ = false;
+    }
+    // Defer initialization that requires the IOThread until after the IOThread
+    // has been initialized.
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            new InitializeAfterIOThreadExistsTask(AsWeakPtr()));
   }
 }
 
-void DeviceManagementPolicyProvider::AddObserver(
-    ConfigurationPolicyProvider::Observer* observer) {
-  observer_list_.AddObserver(observer);
-}
-
-void DeviceManagementPolicyProvider::RemoveObserver(
-    ConfigurationPolicyProvider::Observer* observer) {
-  observer_list_.RemoveObserver(observer);
+void DeviceManagementPolicyProvider::InitializeAfterIOThreadExists() {
+  if (profile_) {
+    if (!token_fetcher_) {
+      token_fetcher_ = new DeviceTokenFetcher(
+          backend_.get(), profile_, GetTokenPath());
+    }
+    registrar_.Init(token_fetcher_);
+    registrar_.AddObserver(this);
+    token_fetcher_->StartFetching();
+  }
 }
 
 void DeviceManagementPolicyProvider::SendPolicyRequest() {
+  if (policy_request_pending_)
+    return;
+
+  policy_request_pending_ = true;
   em::DevicePolicyRequest policy_request;
   policy_request.set_policy_scope(kChromePolicyScope);
   em::DevicePolicySettingRequest* setting =
@@ -239,39 +284,40 @@ void DeviceManagementPolicyProvider::SendPolicyRequest() {
 }
 
 void DeviceManagementPolicyProvider::RefreshTaskExecute() {
-  DCHECK(refresh_task_);
-  refresh_task_ = NULL;
-
-  switch (state_) {
-    case STATE_INITIALIZING:
-      token_fetcher_->StartFetching();
-      return;
-    case STATE_TOKEN_VALID:
-    case STATE_POLICY_VALID:
-    case STATE_POLICY_ERROR:
-      SendPolicyRequest();
-      return;
-    case STATE_UNMANAGED:
-    case STATE_TOKEN_ERROR:
-    case STATE_TOKEN_RESET:
-      token_fetcher_->Restart();
+  DCHECK(refresh_task_pending_);
+  refresh_task_pending_ = false;
+  // If there is no valid device token, the token_fetcher_ apparently failed,
+  // so it must be restarted.
+  if (!token_fetcher_->IsTokenValid()) {
+    if (token_fetcher_->IsTokenPending()) {
+      NOTREACHED();
       return;
+    }
+    token_fetcher_->Restart();
+    return;
   }
-
-  NOTREACHED() << "Unhandled state";
+  // If there is a device token, just refresh policies.
+  SendPolicyRequest();
 }
 
-void DeviceManagementPolicyProvider::CancelRefreshTask() {
-  if (refresh_task_) {
-    refresh_task_->Cancel();
-    refresh_task_ = NULL;
+void DeviceManagementPolicyProvider::ScheduleRefreshTask(
+    int64 delay_in_milliseconds) {
+  // This check is simply a safeguard, the situation currently cannot happen.
+  if (refresh_task_pending_) {
+    NOTREACHED();
+    return;
   }
+  refresh_task_pending_ = true;
+  BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
+                                 new RefreshTask(AsWeakPtr()),
+                                 delay_in_milliseconds);
 }
 
-void DeviceManagementPolicyProvider::NotifyCloudPolicyUpdate() {
-  FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
-                    observer_list_,
-                    OnUpdatePolicy());
+int64 DeviceManagementPolicyProvider::GetRefreshTaskDelay() {
+  int64 delay = policy_refresh_rate_ms_;
+  if (policy_refresh_max_earlier_ms_)
+    delay -= base::RandGenerator(policy_refresh_max_earlier_ms_);
+  return delay;
 }
 
 FilePath DeviceManagementPolicyProvider::GetTokenPath() {
@@ -280,88 +326,14 @@ FilePath DeviceManagementPolicyProvider::GetTokenPath() {
 
 void DeviceManagementPolicyProvider::SetDeviceTokenFetcher(
     DeviceTokenFetcher* token_fetcher) {
-  registrar_.Init(token_fetcher);
-  registrar_.AddObserver(this);
+  DCHECK(!token_fetcher_);
   token_fetcher_ = token_fetcher;
 }
 
-void DeviceManagementPolicyProvider::SetState(
-    DeviceManagementPolicyProvider::ProviderState new_state) {
-  state_ = new_state;
-
-  // If this state transition completes the initial policy fetch, let the
-  // observers now.
-  if (!initial_fetch_done_ &&
-      new_state != STATE_INITIALIZING &&
-      new_state != STATE_TOKEN_VALID) {
-    initial_fetch_done_ = true;
-    NotifyCloudPolicyUpdate();
-  }
-
-  base::Time now(base::Time::NowFromSystemTime());
-  base::Time refresh_at;
-  base::Time last_refresh(cache_->last_policy_refresh_time());
-  if (last_refresh.is_null())
-    last_refresh = now;
-
-  // Determine when to take the next step.
-  switch (state_) {
-    case STATE_INITIALIZING:
-      refresh_at = now;
-      break;
-    case STATE_TOKEN_VALID:
-      effective_token_fetch_error_delay_ms_ = token_fetch_error_delay_ms_;
-      refresh_at = now;
-      break;
-    case STATE_TOKEN_RESET:
-      refresh_at = now;
-      break;
-    case STATE_UNMANAGED:
-      refresh_at = last_refresh +
-          base::TimeDelta::FromMilliseconds(unmanaged_device_refresh_rate_ms_);
-      break;
-    case STATE_POLICY_VALID:
-      effective_policy_refresh_error_delay_ms_ = policy_refresh_error_delay_ms_;
-      refresh_at =
-          last_refresh + base::TimeDelta::FromMilliseconds(GetRefreshDelay());
-      break;
-    case STATE_TOKEN_ERROR:
-      refresh_at = now + base::TimeDelta::FromMilliseconds(
-                             effective_token_fetch_error_delay_ms_);
-      effective_token_fetch_error_delay_ms_ *= 2;
-      if (effective_token_fetch_error_delay_ms_ > policy_refresh_rate_ms_)
-        effective_token_fetch_error_delay_ms_ = policy_refresh_rate_ms_;
-      break;
-    case STATE_POLICY_ERROR:
-      refresh_at = now + base::TimeDelta::FromMilliseconds(
-                             effective_policy_refresh_error_delay_ms_);
-      effective_policy_refresh_error_delay_ms_ *= 2;
-      if (effective_policy_refresh_error_delay_ms_ > policy_refresh_rate_ms_)
-        effective_policy_refresh_error_delay_ms_ = policy_refresh_rate_ms_;
-      break;
-  }
-
-  // Update the refresh task.
-  CancelRefreshTask();
-  if (!refresh_at.is_null()) {
-    refresh_task_ = new RefreshTask(this);
-    int64 delay = std::max<int64>((refresh_at - now).InMilliseconds(), 0);
-    BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE, refresh_task_,
-                                   delay);
-  }
-}
-
-int64 DeviceManagementPolicyProvider::GetRefreshDelay() {
-  int64 deviation = (policy_refresh_deviation_factor_percent_ *
-                     policy_refresh_rate_ms_) / 100;
-  deviation = std::min(deviation, policy_refresh_deviation_max_ms_);
-  return policy_refresh_rate_ms_ - base::RandGenerator(deviation + 1);
-}
-
-bool DeviceManagementPolicyProvider::TokenAvailable() const {
-  return state_ == STATE_TOKEN_VALID ||
-         state_ == STATE_POLICY_VALID ||
-         state_ == STATE_POLICY_ERROR;
+void DeviceManagementPolicyProvider::StopWaitingForInitialPolicies() {
+  waiting_for_initial_policies_ = false;
+  // Notify observers that initial policy fetch is complete.
+  NotifyCloudPolicyUpdate();
 }
 
 // static
diff --git a/chrome/browser/policy/device_management_policy_provider.h b/chrome/browser/policy/device_management_policy_provider.h
index 592df9b..fd18bc3 100644
--- a/chrome/browser/policy/device_management_policy_provider.h
+++ b/chrome/browser/policy/device_management_policy_provider.h
@@ -12,6 +12,7 @@
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
+#include "base/weak_ptr.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/device_management_backend.h"
 #include "chrome/browser/policy/device_token_fetcher.h"
@@ -30,6 +31,7 @@ class DeviceManagementPolicyCache;
 class DeviceManagementPolicyProvider
     :  public ConfigurationPolicyProvider,
        public DeviceManagementBackend::DevicePolicyResponseDelegate,
+       public base::SupportsWeakPtr<DeviceManagementPolicyProvider>,
        public DeviceTokenFetcher::Observer {
  public:
   DeviceManagementPolicyProvider(const PolicyDefinitionList* policy_list,
@@ -52,28 +54,8 @@ class DeviceManagementPolicyProvider
   virtual void OnTokenError();
   virtual void OnNotManaged();
 
-  // Sets the refresh rate at which to re-fetch policy information.
-  void SetRefreshRate(int64 refresh_rate_milliseconds);
-
  private:
-  // Indicates the current state the provider is in.
-  enum ProviderState {
-    // The provider is initializing, policy information not yet available.
-    STATE_INITIALIZING,
-    // This device is not managed through policy.
-    STATE_UNMANAGED,
-    // The token is valid, but policy is yet to be fetched.
-    STATE_TOKEN_VALID,
-    // Policy information is available and valid.
-    STATE_POLICY_VALID,
-    // The token was found to be invalid and needs to be obtained again.
-    STATE_TOKEN_RESET,
-    // There has been an error fetching the token, retry later.
-    STATE_TOKEN_ERROR,
-    // The service returned an error when requesting policy, ask again later.
-    STATE_POLICY_ERROR,
-  };
-
+  class InitializeAfterIOThreadExistsTask;
   class RefreshTask;
 
   friend class DeviceManagementPolicyProviderTest;
@@ -83,8 +65,7 @@ class DeviceManagementPolicyProvider
                                  DeviceManagementBackend* backend,
                                  Profile* profile,
                                  int64 policy_refresh_rate_ms,
-                                 int policy_refresh_deviation_factor_percent,
-                                 int64 policy_refresh_deviation_max_ms,
+                                 int64 policy_refresh_max_earlier_ms,
                                  int64 policy_refresh_error_delay_ms,
                                  int64 token_fetch_error_delay_ms,
                                  int64 unmanaged_device_refresh_rate_ms);
@@ -96,12 +77,15 @@ class DeviceManagementPolicyProvider
   void Initialize(DeviceManagementBackend* backend,
                   Profile* profile,
                   int64 policy_refresh_rate_ms,
-                  int policy_refresh_deviation_factor_percent,
-                  int64 policy_refresh_deviation_max_ms,
+                  int64 policy_refresh_max_earlier_ms,
                   int64 policy_refresh_error_delay_ms,
                   int64 token_fetch_error_delay_ms,
                   int64 unmanaged_device_refresh_rate_ms);
 
+  // Called by a deferred task posted to the UI thread to complete the portion
+  // of initialization that requires the IOThread.
+  void InitializeAfterIOThreadExists();
+
   // ConfigurationPolicyProvider overrides:
   virtual void AddObserver(ConfigurationPolicyProvider::Observer* observer);
   virtual void RemoveObserver(ConfigurationPolicyProvider::Observer* observer);
@@ -114,8 +98,13 @@ class DeviceManagementPolicyProvider
   // as necessary.
   void RefreshTaskExecute();
 
-  // Cancels the refresh task.
-  void CancelRefreshTask();
+  // Schedules a new RefreshTask.
+  void ScheduleRefreshTask(int64 delay_in_milliseconds);
+
+  // Calculates when the next RefreshTask shall be executed.
+  int64 GetRefreshTaskDelay();
+
+  void StopWaitingForInitialPolicies();
 
   // Notify observers about a policy update.
   void NotifyCloudPolicyUpdate();
@@ -126,15 +115,6 @@ class DeviceManagementPolicyProvider
   // Used only by tests.
   void SetDeviceTokenFetcher(DeviceTokenFetcher* token_fetcher);
 
-  // Switches to a new state and triggers any appropriate actions.
-  void SetState(ProviderState new_state);
-
-  // Check whether the current state is one in which the token is available.
-  bool TokenAvailable() const;
-
-  // Computes the refresh delay to use.
-  int64 GetRefreshDelay();
-
   // Provides the URL at which requests are sent to from the device management
   // backend.
   static std::string GetDeviceManagementURL();
@@ -151,16 +131,13 @@ class DeviceManagementPolicyProvider
   DeviceTokenFetcher::ObserverRegistrar registrar_;
   ObserverList<ConfigurationPolicyProvider::Observer, true> observer_list_;
   FilePath storage_dir_;
-  ProviderState state_;
-  bool initial_fetch_done_;
-  RefreshTask* refresh_task_;
+  bool policy_request_pending_;
+  bool refresh_task_pending_;
+  bool waiting_for_initial_policies_;
   int64 policy_refresh_rate_ms_;
-  int policy_refresh_deviation_factor_percent_;
-  int64 policy_refresh_deviation_max_ms_;
+  int64 policy_refresh_max_earlier_ms_;
   int64 policy_refresh_error_delay_ms_;
-  int64 effective_policy_refresh_error_delay_ms_;
   int64 token_fetch_error_delay_ms_;
-  int64 effective_token_fetch_error_delay_ms_;
   int64 unmanaged_device_refresh_rate_ms_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementPolicyProvider);
diff --git a/chrome/browser/policy/device_management_policy_provider_unittest.cc b/chrome/browser/policy/device_management_policy_provider_unittest.cc
index 55ba883..eac2c5b 100644
--- a/chrome/browser/policy/device_management_policy_provider_unittest.cc
+++ b/chrome/browser/policy/device_management_policy_provider_unittest.cc
@@ -27,7 +27,6 @@ const char kTestToken[] = "device_policy_provider_test_auth_token";
 namespace policy {
 
 using ::testing::_;
-using ::testing::AtLeast;
 using ::testing::InSequence;
 using ::testing::Mock;
 
@@ -66,8 +65,7 @@ class DeviceManagementPolicyProviderTest : public testing::Test {
   }
 
   void CreateNewProvider(int64 policy_refresh_rate_ms,
-                         int policy_refresh_fuzz_factor_percent,
-                         int64 policy_refresh_fuzz_max,
+                         int64 policy_refresh_max_earlier_ms,
                          int64 policy_refresh_error_delay_ms,
                          int64 token_fetch_error_delay_ms,
                          int64 unmanaged_device_refresh_rate_ms) {
@@ -77,8 +75,7 @@ class DeviceManagementPolicyProviderTest : public testing::Test {
         backend_,
         profile_.get(),
         policy_refresh_rate_ms,
-        policy_refresh_fuzz_factor_percent,
-        policy_refresh_fuzz_max,
+        policy_refresh_max_earlier_ms,
         policy_refresh_error_delay_ms,
         token_fetch_error_delay_ms,
         unmanaged_device_refresh_rate_ms));
@@ -93,12 +90,6 @@ class DeviceManagementPolicyProviderTest : public testing::Test {
   }
 
   void SimulateSuccessfulLoginAndRunPending() {
-    // Make sure the notification for the initial policy fetch is generated.
-    MockConfigurationPolicyObserver observer;
-    ConfigurationPolicyObserverRegistrar registrar;
-    registrar.Init(provider_.get(), &observer);
-    EXPECT_CALL(observer, OnUpdatePolicy()).Times(AtLeast(1));
-
     loop_.RunAllPending();
     profile_->GetTokenService()->IssueAuthTokenForTest(
         GaiaConstants::kDeviceManagementService, kTestToken);
@@ -126,12 +117,11 @@ class DeviceManagementPolicyProviderTest : public testing::Test {
   }
 
   virtual void TearDown() {
-    provider_.reset();
     loop_.RunAllPending();
   }
 
   bool waiting_for_initial_policies() const {
-    return !provider_->IsInitializationComplete();
+    return provider_->waiting_for_initial_policies_;
   }
 
   MockDeviceManagementBackend* backend_;  // weak
@@ -206,6 +196,7 @@ TEST_F(DeviceManagementPolicyProviderTest, SecondProvide) {
   EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
       MockDeviceManagementBackendFailPolicy(
           DeviceManagementBackend::kErrorRequestFailed));
+  loop_.RunAllPending();
   SimulateSuccessfulLoginAndRunPending();
   EXPECT_CALL(store, Apply(kPolicyDisableSpdy, _)).Times(1);
   provider_->Provide(&store);
@@ -223,108 +214,90 @@ TEST_F(DeviceManagementPolicyProviderTest, FetchTriggersRefresh) {
 }
 
 TEST_F(DeviceManagementPolicyProviderTest, ErrorCausesNewRequest) {
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    CreateNewProvider(1000 * 1000, 0, 0, 0, 0, 0);
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailRegister(
-            DeviceManagementBackend::kErrorRequestFailed));
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailPolicy(
-            DeviceManagementBackend::kErrorRequestFailed));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailPolicy(
-            DeviceManagementBackend::kErrorRequestFailed));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-  }
+  InSequence s;
+  CreateNewProvider(1000 * 1000, 0, 0, 0, 0);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailRegister(
+          DeviceManagementBackend::kErrorRequestFailed));
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorRequestFailed));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorRequestFailed));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   SimulateSuccessfulLoginAndRunPending();
 }
 
 TEST_F(DeviceManagementPolicyProviderTest, RefreshPolicies) {
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    CreateNewProvider(0, 0, 0, 1000 * 1000, 1000, 0);
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailPolicy(
-            DeviceManagementBackend::kErrorRequestFailed));
-  }
+  InSequence s;
+  CreateNewProvider(0, 0, 1000 * 1000, 1000, 0);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorRequestFailed));
   SimulateSuccessfulLoginAndRunPending();
 }
 
 // The client should try to re-register the device if the device server reports
 // back that it doesn't recognize the device token on a policy request.
 TEST_F(DeviceManagementPolicyProviderTest, DeviceNotFound) {
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailPolicy(
-            DeviceManagementBackend::kErrorServiceDeviceNotFound));
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-  }
+  InSequence s;
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorServiceDeviceNotFound));
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   SimulateSuccessfulLoginAndRunPending();
 }
 
 // The client should try to re-register the device if the device server reports
 // back that the device token is invalid on a policy request.
 TEST_F(DeviceManagementPolicyProviderTest, InvalidTokenOnPolicyRequest) {
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailPolicy(
-            DeviceManagementBackend::kErrorServiceManagementTokenInvalid));
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-  }
+  InSequence s;
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorServiceManagementTokenInvalid));
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   SimulateSuccessfulLoginAndRunPending();
 }
 
 // If the client is successfully managed, but the admin stops managing the
 // device, the client should notice and throw away the device token and id.
 TEST_F(DeviceManagementPolicyProviderTest, DeviceNoLongerManaged) {
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    CreateNewProvider(0, 0, 0, 0, 0, 1000 * 1000);
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailPolicy(
-            DeviceManagementBackend::kErrorServiceManagementNotSupported));
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailRegister(
-            DeviceManagementBackend::kErrorServiceManagementNotSupported));
-  }
+  InSequence s;
+  CreateNewProvider(0, 0, 0, 0, 1000 * 1000);
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailPolicy(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailRegister(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
   SimulateSuccessfulLoginAndRunPending();
   FilePath token_path(GetTokenPath());
   EXPECT_FALSE(file_util::PathExists(token_path));
@@ -332,28 +305,22 @@ TEST_F(DeviceManagementPolicyProviderTest, DeviceNoLongerManaged) {
 
 // This test tests three things (see numbered comments below):
 TEST_F(DeviceManagementPolicyProviderTest, UnmanagedDevice) {
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendFailRegister(
-            DeviceManagementBackend::kErrorServiceManagementNotSupported));
-  }
+  InSequence s;
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendFailRegister(
+          DeviceManagementBackend::kErrorServiceManagementNotSupported));
   SimulateSuccessfulLoginAndRunPending();
   // (1) The provider's DMPolicyCache should know that the device is not
   // managed.
   EXPECT_TRUE(cache(provider_.get())->is_device_unmanaged());
   // (2) On restart, the provider should detect that this is not the first
   // login.
-  CreateNewProvider(1000 * 1000, 0, 0, 0, 0, 0);
+  CreateNewProvider(1000*1000, 0, 0, 0, 0);
   EXPECT_FALSE(waiting_for_initial_policies());
-  { // Scoping so SimulateSuccessfulLoginAndRunPending doesn't see the sequence.
-    InSequence s;
-    EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedRegister());
-    EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
-        MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy,
-                                                        true));
-  }
+  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedRegister());
+  EXPECT_CALL(*backend_, ProcessPolicyRequest(_, _, _, _)).WillOnce(
+      MockDeviceManagementBackendSucceedBooleanPolicy(key::kDisableSpdy, true));
   SimulateSuccessfulLoginAndRunPending();
   // (3) Since the backend call this time returned a device id, the "unmanaged"
   // marker should have been deleted.
diff --git a/chrome/browser/policy/device_token_fetcher.cc b/chrome/browser/policy/device_token_fetcher.cc
index 3f977c1..2d514b6 100644
--- a/chrome/browser/policy/device_token_fetcher.cc
+++ b/chrome/browser/policy/device_token_fetcher.cc
@@ -65,7 +65,6 @@ DeviceTokenFetcher::ObserverRegistrar::~ObserverRegistrar() {
 
 void DeviceTokenFetcher::ObserverRegistrar::Init(
     DeviceTokenFetcher* token_fetcher) {
-  RemoveAll();
   token_fetcher_ = token_fetcher;
 }
 
@@ -193,11 +192,7 @@ void DeviceTokenFetcher::OnError(DeviceManagementBackend::ErrorCode code) {
 }
 
 void DeviceTokenFetcher::Restart() {
-  // Complain if there's currently an asynchronous operation going on.
-  DCHECK(state_ == kStateNotStarted ||
-         state_ == kStateHasDeviceToken ||
-         state_ == kStateFailure ||
-         state_ == kStateNotManaged);
+  DCHECK(!IsTokenPending());
   device_token_.clear();
   device_token_load_complete_event_.Reset();
   MakeReadyToRequestDeviceToken();
diff --git a/chrome/browser/policy/device_token_fetcher_unittest.cc b/chrome/browser/policy/device_token_fetcher_unittest.cc
index 28d11b0..f4a7e23 100644
--- a/chrome/browser/policy/device_token_fetcher_unittest.cc
+++ b/chrome/browser/policy/device_token_fetcher_unittest.cc
@@ -224,28 +224,4 @@ TEST_F(DeviceTokenFetcherTest, FetchWithNonManagedUsername) {
   ASSERT_FALSE(fetcher_->IsTokenValid());
 }
 
-TEST_F(DeviceTokenFetcherTest, RestartImmediately) {
-  // Create a token.
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-      MockDeviceManagementBackendSucceedRegister());
-  SimulateSuccessfulLoginAndRunPending(kTestManagedDomainUsername);
-  ASSERT_FALSE(fetcher_->IsTokenPending());
-  std::string device_token = fetcher_->GetDeviceToken();
-
-  // Restart a new fetcher immediately without calling StartFetching(). The
-  // existing token should not be loaded, but rather a new token generated.
-  FilePath token_path;
-  GetDeviceTokenPath(fetcher_, &token_path);
-  scoped_refptr<TestingDeviceTokenFetcher> fetcher2(
-      new TestingDeviceTokenFetcher(
-          backend_.get(), profile_.get(), token_path));
-  fetcher2->Restart();
-  EXPECT_CALL(*backend_, ProcessRegisterRequest(_, _, _, _)).WillOnce(
-      MockDeviceManagementBackendSucceedRegister());
-  fetcher2->SimulateLogin(kTestManagedDomainUsername);
-  loop_.RunAllPending();
-  ASSERT_FALSE(fetcher2->IsTokenPending());
-  ASSERT_NE(device_token, fetcher2->GetDeviceToken());
-}
-
 }  // namespace policy
diff --git a/chrome/browser/policy/profile_policy_context.cc b/chrome/browser/policy/profile_policy_context.cc
index 7adffd3..c221529 100644
--- a/chrome/browser/policy/profile_policy_context.cc
+++ b/chrome/browser/policy/profile_policy_context.cc
@@ -7,20 +7,8 @@
 #include "chrome/browser/policy/device_management_policy_provider.h"
 #include "chrome/browser/policy/device_management_service.h"
 #include "chrome/browser/policy/profile_policy_context.h"
-#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/notification_details.h"
-#include "chrome/common/notification_source.h"
-#include "chrome/common/pref_names.h"
-
-namespace {
-
-// Refresh rate sanity interval bounds.
-const int64 kPolicyRefreshRateMinMs = 30 * 60 * 1000;  // 30 minutes
-const int64 kPolicyRefreshRateMaxMs = 24 * 60 * 60 * 1000;  // 1 day
-
-}
 
 namespace policy {
 
@@ -46,10 +34,6 @@ ProfilePolicyContext::~ProfilePolicyContext() {
 void ProfilePolicyContext::Initialize() {
   if (device_management_service_.get())
     device_management_service_->Initialize(profile_->GetRequestContext());
-
-  policy_refresh_rate_.Init(prefs::kPolicyRefreshRate, profile_->GetPrefs(),
-                            this);
-  UpdatePolicyRefreshRate();
 }
 
 void ProfilePolicyContext::Shutdown() {
@@ -62,32 +46,4 @@ ProfilePolicyContext::GetDeviceManagementPolicyProvider() {
   return device_management_policy_provider_.get();
 }
 
-// static
-void ProfilePolicyContext::RegisterUserPrefs(PrefService* user_prefs) {
-  user_prefs->RegisterIntegerPref(prefs::kPolicyRefreshRate,
-                                  kDefaultPolicyRefreshRateInMilliseconds);
-}
-
-void ProfilePolicyContext::UpdatePolicyRefreshRate() {
-  if (device_management_policy_provider_.get()) {
-    // Clamp to sane values.
-    int64 refresh_rate = policy_refresh_rate_.GetValue();
-    refresh_rate = std::max(kPolicyRefreshRateMinMs, refresh_rate);
-    refresh_rate = std::min(kPolicyRefreshRateMaxMs, refresh_rate);
-    device_management_policy_provider_->SetRefreshRate(refresh_rate);
-  }
-}
-
-void ProfilePolicyContext::Observe(NotificationType type,
-                                   const NotificationSource& source,
-                                   const NotificationDetails& details) {
-  if (type == NotificationType::PREF_CHANGED &&
-      prefs::kPolicyRefreshRate == *(Details<std::string>(details).ptr()) &&
-      profile_->GetPrefs() == Source<PrefService>(source).ptr()) {
-    UpdatePolicyRefreshRate();
-  } else {
-    NOTREACHED();
-  }
-}
-
 }  // namespace policy
diff --git a/chrome/browser/policy/profile_policy_context.h b/chrome/browser/policy/profile_policy_context.h
index 8650ec5..b343e15 100644
--- a/chrome/browser/policy/profile_policy_context.h
+++ b/chrome/browser/policy/profile_policy_context.h
@@ -7,8 +7,6 @@
 #pragma once
 
 #include "base/scoped_ptr.h"
-#include "chrome/browser/prefs/pref_member.h"
-#include "chrome/common/notification_observer.h"
 
 class Profile;
 
@@ -21,7 +19,7 @@ class DeviceManagementService;
 // profile. Since the context owns the policy provider, it's vital that it gets
 // initialized before the profile's prefs and destroyed after the prefs are
 // gone.
-class ProfilePolicyContext : public NotificationObserver {
+class ProfilePolicyContext {
  public:
   explicit ProfilePolicyContext(Profile* profile);
   ~ProfilePolicyContext();
@@ -37,27 +35,10 @@ class ProfilePolicyContext : public NotificationObserver {
   // Get the policy provider.
   DeviceManagementPolicyProvider* GetDeviceManagementPolicyProvider();
 
-  // Register preferences.
-  static void RegisterUserPrefs(PrefService* user_prefs);
-
-  static const int kDefaultPolicyRefreshRateInMilliseconds =
-      3 * 60 * 60 * 1000; // 3 hours.
-
  private:
-  // Updates the policy provider with a new refresh rate value.
-  void UpdatePolicyRefreshRate();
-
-  // NotificationObserver overrides.
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details);
-
   // The profile this context is associated with.
   Profile* profile_;
 
-  // Tracks the pref value for the policy refresh rate.
-  IntegerPrefMember policy_refresh_rate_;
-
   // The device management service.
   scoped_ptr<DeviceManagementService> device_management_service_;