Added ConfigurationPolicyProvider::RefreshPolicies.

This call has guaranteed behavior regarding notifications of observers, which
can be relied upon to build test infrastructure that sets up policy.

Added the provider as an argument to OnUpdatePolicy.
Added BrowserPolicyConnector::FetchCloudPolicy and ResetCloudPolicy.

TEST=All works as before


Review URL: http://codereview.chromium.org/8586030

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

32 files changed, 420 insertions, 208 deletions

diff --git a/chrome/browser/policy/asynchronous_policy_loader_unittest.cc b/chrome/browser/policy/asynchronous_policy_loader_unittest.cc
index 3280b47..f60e06b 100644
--- a/chrome/browser/policy/asynchronous_policy_loader_unittest.cc
+++ b/chrome/browser/policy/asynchronous_policy_loader_unittest.cc
@@ -24,13 +24,6 @@ void IgnoreCallback() {
 
 }  // namespace
 
-class MockConfigurationPolicyObserver
-    : public ConfigurationPolicyProvider::Observer {
- public:
-  MOCK_METHOD0(OnUpdatePolicy, void());
-  void OnProviderGoingAway() {}
-};
-
 class AsynchronousPolicyLoaderTest : public AsynchronousPolicyTestBase {
  public:
   AsynchronousPolicyLoaderTest() {}
@@ -135,16 +128,16 @@ TEST_F(AsynchronousPolicyLoaderTest, ProviderNotificationOnPolicyChange) {
 
   EXPECT_CALL(*delegate, Load()).WillOnce(
       CreateSequencedTestDictionary(&dictionary_number_2));
-  EXPECT_CALL(observer, OnUpdatePolicy()).Times(1);
-  loader->Reload(true);
+  EXPECT_CALL(observer, OnUpdatePolicy(_)).Times(1);
+  provider.RefreshPolicies();
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(delegate);
   Mock::VerifyAndClearExpectations(&observer);
 
   EXPECT_CALL(*delegate, Load()).WillOnce(
       CreateSequencedTestDictionary(&dictionary_number_1));
-  EXPECT_CALL(observer, OnUpdatePolicy()).Times(1);
-  loader->Reload(true);
+  EXPECT_CALL(observer, OnUpdatePolicy(_)).Times(1);
+  provider.RefreshPolicies();
   loop_.RunAllPending();
   Mock::VerifyAndClearExpectations(delegate);
   Mock::VerifyAndClearExpectations(&observer);
diff --git a/chrome/browser/policy/asynchronous_policy_provider.cc b/chrome/browser/policy/asynchronous_policy_provider.cc
index 54057ab..06ea9a7 100644
--- a/chrome/browser/policy/asynchronous_policy_provider.cc
+++ b/chrome/browser/policy/asynchronous_policy_provider.cc
@@ -7,6 +7,9 @@
 #include "base/bind.h"
 #include "chrome/browser/policy/asynchronous_policy_loader.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
 
 namespace policy {
 
@@ -14,9 +17,11 @@ AsynchronousPolicyProvider::AsynchronousPolicyProvider(
     const PolicyDefinitionList* policy_list,
     scoped_refptr<AsynchronousPolicyLoader> loader)
     : ConfigurationPolicyProvider(policy_list),
-      loader_(loader) {
+      loader_(loader),
+      pending_refreshes_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   loader_->Init(
-      base::Bind(&AsynchronousPolicyProvider::NotifyPolicyUpdated,
+      base::Bind(&AsynchronousPolicyProvider::OnLoaderReloaded,
                  base::Unretained(this)));
 }
 
@@ -27,15 +32,43 @@ AsynchronousPolicyProvider::~AsynchronousPolicyProvider() {
   loader_->Stop();
 }
 
-void AsynchronousPolicyProvider::ForceReload() {
-  loader_->Reload(true);
-}
-
 bool AsynchronousPolicyProvider::ProvideInternal(PolicyMap* map) {
   DCHECK(CalledOnValidThread());
-  DCHECK(loader_->policy());
+  if (!loader_->policy())
+    return false;
   map->LoadFrom(loader_->policy(), policy_definition_list());
   return true;
 }
 
+void AsynchronousPolicyProvider::RefreshPolicies() {
+  DCHECK(CalledOnValidThread());
+  pending_refreshes_++;
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&AsynchronousPolicyProvider::PostReloadOnFileThread,
+                 loader_),
+      base::Bind(&AsynchronousPolicyProvider::OnReloadPosted,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+// static
+void AsynchronousPolicyProvider::PostReloadOnFileThread(
+    AsynchronousPolicyLoader* loader) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&AsynchronousPolicyLoader::Reload, loader, true));
+}
+
+void AsynchronousPolicyProvider::OnReloadPosted() {
+  DCHECK(CalledOnValidThread());
+  pending_refreshes_--;
+}
+
+void AsynchronousPolicyProvider::OnLoaderReloaded() {
+  DCHECK(CalledOnValidThread());
+  if (pending_refreshes_ == 0)
+    NotifyPolicyUpdated();
+}
+
 }  // namespace policy
diff --git a/chrome/browser/policy/asynchronous_policy_provider.h b/chrome/browser/policy/asynchronous_policy_provider.h
index b0dbed3..79720e9 100644
--- a/chrome/browser/policy/asynchronous_policy_provider.h
+++ b/chrome/browser/policy/asynchronous_policy_provider.h
@@ -7,6 +7,7 @@
 #pragma once
 
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
@@ -37,17 +38,31 @@ class AsynchronousPolicyProvider
       scoped_refptr<AsynchronousPolicyLoader> loader);
   virtual ~AsynchronousPolicyProvider();
 
-  // Force a policy reload from the underlying data source.
-  void ForceReload();
-
- protected:
   // ConfigurationPolicyProvider implementation.
   virtual bool ProvideInternal(PolicyMap* map) OVERRIDE;
+  virtual void RefreshPolicies() OVERRIDE;
+
+ private:
+  // Used to trigger a Reload on |loader| on the FILE thread.
+  static void PostReloadOnFileThread(AsynchronousPolicyLoader* loader);
+
+  // Used to notify UI that a reload task has been submitted.
+  void OnReloadPosted();
+
+  // Callback from the loader. This is invoked whenever the loader has completed
+  // a reload of the policies.
+  void OnLoaderReloaded();
 
   // The loader object used internally.
   scoped_refptr<AsynchronousPolicyLoader> loader_;
 
- private:
+  // Number of refreshes requested whose reload is still pending. Used to only
+  // fire notifications when all pending refreshes are done.
+  int pending_refreshes_;
+
+  // Used to post tasks to self on UI.
+  base::WeakPtrFactory<AsynchronousPolicyProvider> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(AsynchronousPolicyProvider);
 };
 
diff --git a/chrome/browser/policy/asynchronous_policy_provider_unittest.cc b/chrome/browser/policy/asynchronous_policy_provider_unittest.cc
index 95c51ab..bd8c162 100644
--- a/chrome/browser/policy/asynchronous_policy_provider_unittest.cc
+++ b/chrome/browser/policy/asynchronous_policy_provider_unittest.cc
@@ -6,6 +6,8 @@
 #include "chrome/browser/policy/asynchronous_policy_provider.h"
 #include "chrome/browser/policy/asynchronous_policy_test_base.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/policy/configuration_policy_provider.h"
+#include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -48,12 +50,26 @@ TEST_F(AsynchronousPolicyTestBase, ProvideAfterRefresh) {
   EXPECT_CALL(*delegate, Load()).WillOnce(Return(refresh_policies));
   AsynchronousPolicyLoader* loader = new AsynchronousPolicyLoader(delegate, 10);
   AsynchronousPolicyProvider provider(GetChromePolicyDefinitionList(), loader);
-  loop_.RunAllPending();
-  provider.ForceReload();
+
+  // The original policies have been loaded.
   PolicyMap policy_map;
   provider.Provide(&policy_map);
+  EXPECT_EQ(1U, policy_map.size());
   EXPECT_TRUE(policy_map.Get(policy::kPolicySyncDisabled));
+  EXPECT_FALSE(policy_map.Get(policy::kPolicyJavascriptEnabled));
+
+  MockConfigurationPolicyObserver observer;
+  ConfigurationPolicyObserverRegistrar registrar;
+  registrar.Init(&provider, &observer);
+  EXPECT_CALL(observer, OnUpdatePolicy(&provider)).Times(1);
+  provider.RefreshPolicies();
+  loop_.RunAllPending();
+  // The refreshed policies are now provided.
+  policy_map.Clear();
+  provider.Provide(&policy_map);
   EXPECT_EQ(1U, policy_map.size());
+  EXPECT_FALSE(policy_map.Get(policy::kPolicySyncDisabled));
+  EXPECT_TRUE(policy_map.Get(policy::kPolicyJavascriptEnabled));
 }
 
 }  // namespace policy
diff --git a/chrome/browser/policy/browser_policy_connector.cc b/chrome/browser/policy/browser_policy_connector.cc
index bd27f72..85a21c4 100644
--- a/chrome/browser/policy/browser_policy_connector.cc
+++ b/chrome/browser/policy/browser_policy_connector.cc
@@ -81,10 +81,8 @@ const char* kMachineInfoSerialNumberKeys[] = {
 
 }  // namespace
 
-// static
-BrowserPolicyConnector* BrowserPolicyConnector::Create() {
-  return new BrowserPolicyConnector();
-}
+BrowserPolicyConnector::BrowserPolicyConnector()
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {}
 
 BrowserPolicyConnector::~BrowserPolicyConnector() {
   // Shutdown device cloud policy.
@@ -103,6 +101,29 @@ BrowserPolicyConnector::~BrowserPolicyConnector() {
   user_data_store_.reset();
 }
 
+void BrowserPolicyConnector::Init() {
+  managed_platform_provider_.reset(CreateManagedPlatformProvider());
+  recommended_platform_provider_.reset(CreateRecommendedPlatformProvider());
+
+  managed_cloud_provider_.reset(new CloudPolicyProviderImpl(
+      this,
+      GetChromePolicyDefinitionList(),
+      CloudPolicyCacheBase::POLICY_LEVEL_MANDATORY));
+  recommended_cloud_provider_.reset(new CloudPolicyProviderImpl(
+      this,
+      GetChromePolicyDefinitionList(),
+      CloudPolicyCacheBase::POLICY_LEVEL_RECOMMENDED));
+
+#if defined(OS_CHROMEOS)
+  InitializeDevicePolicy();
+
+  network_configuration_updater_.reset(
+      new NetworkConfigurationUpdater(
+          managed_cloud_provider_.get(),
+          chromeos::CrosLibrary::Get()->GetNetworkLibrary()));
+#endif
+}
+
 ConfigurationPolicyProvider*
     BrowserPolicyConnector::GetManagedPlatformProvider() const {
   return managed_platform_provider_.get();
@@ -202,20 +223,24 @@ void BrowserPolicyConnector::ResetDevicePolicy() {
 #endif
 }
 
-void BrowserPolicyConnector::FetchDevicePolicy() {
+void BrowserPolicyConnector::FetchCloudPolicy() {
 #if defined(OS_CHROMEOS)
-  if (device_data_store_.get()) {
+  if (device_data_store_.get())
     device_data_store_->NotifyDeviceTokenChanged();
-  }
+  if (user_data_store_.get())
+    user_data_store_->NotifyDeviceTokenChanged();
 #endif
 }
 
-void BrowserPolicyConnector::FetchUserPolicy() {
-#if defined(OS_CHROMEOS)
-  if (user_data_store_.get()) {
-    user_data_store_->NotifyDeviceTokenChanged();
-  }
-#endif
+void BrowserPolicyConnector::RefreshPolicies() {
+  if (managed_platform_provider_.get())
+    managed_platform_provider_->RefreshPolicies();
+  if (recommended_platform_provider_.get())
+    recommended_platform_provider_->RefreshPolicies();
+  if (managed_cloud_provider_.get())
+    managed_cloud_provider_->RefreshPolicies();
+  if (recommended_cloud_provider_.get())
+    recommended_cloud_provider_->RefreshPolicies();
 }
 
 void BrowserPolicyConnector::ScheduleServiceInitialization(
@@ -347,40 +372,6 @@ CloudPolicyDataStore::UserAffiliation
   return CloudPolicyDataStore::USER_AFFILIATION_NONE;
 }
 
-BrowserPolicyConnector::BrowserPolicyConnector()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
-  managed_platform_provider_.reset(CreateManagedPlatformProvider());
-  recommended_platform_provider_.reset(CreateRecommendedPlatformProvider());
-
-  managed_cloud_provider_.reset(new CloudPolicyProviderImpl(
-      GetChromePolicyDefinitionList(),
-      CloudPolicyCacheBase::POLICY_LEVEL_MANDATORY));
-  recommended_cloud_provider_.reset(new CloudPolicyProviderImpl(
-      GetChromePolicyDefinitionList(),
-      CloudPolicyCacheBase::POLICY_LEVEL_RECOMMENDED));
-
-#if defined(OS_CHROMEOS)
-  InitializeDevicePolicy();
-
-  network_configuration_updater_.reset(
-      new NetworkConfigurationUpdater(
-          managed_cloud_provider_.get(),
-          chromeos::CrosLibrary::Get()->GetNetworkLibrary()));
-#endif
-}
-
-BrowserPolicyConnector::BrowserPolicyConnector(
-    ConfigurationPolicyProvider* managed_platform_provider,
-    ConfigurationPolicyProvider* recommended_platform_provider,
-    CloudPolicyProvider* managed_cloud_provider,
-    CloudPolicyProvider* recommended_cloud_provider)
-    : managed_platform_provider_(managed_platform_provider),
-      recommended_platform_provider_(recommended_platform_provider),
-      managed_cloud_provider_(managed_cloud_provider),
-      recommended_cloud_provider_(recommended_cloud_provider),
-      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
-}
-
 void BrowserPolicyConnector::Observe(
     int type,
     const content::NotificationSource& source,
@@ -446,11 +437,6 @@ void BrowserPolicyConnector::InitializeDevicePolicySubsystem() {
 }
 
 // static
-BrowserPolicyConnector* BrowserPolicyConnector::CreateForTests() {
-  return new BrowserPolicyConnector(NULL, NULL, NULL, NULL);
-}
-
-// static
 ConfigurationPolicyProvider*
     BrowserPolicyConnector::CreateManagedPlatformProvider() {
   const PolicyDefinitionList* policy_list = GetChromePolicyDefinitionList();
diff --git a/chrome/browser/policy/browser_policy_connector.h b/chrome/browser/policy/browser_policy_connector.h
index 2dbd1b4..50d4462 100644
--- a/chrome/browser/policy/browser_policy_connector.h
+++ b/chrome/browser/policy/browser_policy_connector.h
@@ -40,9 +40,16 @@ class BrowserPolicyConnector : public content::NotificationObserver {
     TOKEN_TYPE_OAUTH, // An OAuth v2 access token.
   };
 
-  static BrowserPolicyConnector* Create();
+  // Builds an uninitialized BrowserPolicyConnector, suitable for testing.
+  // Init() should be called to create and start the policy machinery.
+  BrowserPolicyConnector();
   virtual ~BrowserPolicyConnector();
 
+  // Creates the policy providers and finalizes the initialization of the
+  // connector. This call can be skipped on tests that don't require the full
+  // policy system running.
+  void Init();
+
   ConfigurationPolicyProvider* GetManagedPlatformProvider() const;
   ConfigurationPolicyProvider* GetManagedCloudProvider() const;
   ConfigurationPolicyProvider* GetRecommendedPlatformProvider() const;
@@ -86,12 +93,12 @@ class BrowserPolicyConnector : public content::NotificationObserver {
   // and clears the error flags, so potential retries have a chance to succeed.
   void ResetDevicePolicy();
 
-  // Initiates a policy fetch after a successful device registration.
-  void FetchDevicePolicy();
+  // Initiates device and user policy fetches, if possible. Pending fetches
+  // will be cancelled.
+  void FetchCloudPolicy();
 
-  // Initiates a user policy fetch after a successful device registration. This
-  // is only safe to call when a user device token is available.
-  void FetchUserPolicy();
+  // Refreshes policies on each existing provider.
+  void RefreshPolicies();
 
   // Schedules initialization of the cloud policy backend services, if the
   // services are already constructed.
@@ -124,18 +131,6 @@ class BrowserPolicyConnector : public content::NotificationObserver {
       const std::string& user_name);
 
  private:
-  friend class ::TestingBrowserProcess;
-
-  BrowserPolicyConnector();
-
-  // Constructor for tests that allows tests to use fake platform and cloud
-  // policy providers instead of using the actual ones.
-  BrowserPolicyConnector(
-      ConfigurationPolicyProvider* managed_platform_provider,
-      ConfigurationPolicyProvider* recommended_platform_provider,
-      CloudPolicyProvider* managed_cloud_provider,
-      CloudPolicyProvider* recommended_cloud_provider);
-
   // content::NotificationObserver method overrides:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
@@ -149,7 +144,6 @@ class BrowserPolicyConnector : public content::NotificationObserver {
   // be running.
   void InitializeDevicePolicySubsystem();
 
-  static BrowserPolicyConnector* CreateForTests();
   static ConfigurationPolicyProvider* CreateManagedPlatformProvider();
   static ConfigurationPolicyProvider* CreateRecommendedPlatformProvider();
 
diff --git a/chrome/browser/policy/cloud_policy_cache_base.cc b/chrome/browser/policy/cloud_policy_cache_base.cc
index 6e88043..57118f4 100644
--- a/chrome/browser/policy/cloud_policy_cache_base.cc
+++ b/chrome/browser/policy/cloud_policy_cache_base.cc
@@ -25,6 +25,11 @@ CloudPolicyCacheBase::~CloudPolicyCacheBase() {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnCacheGoingAway(this));
 }
 
+void CloudPolicyCacheBase::SetFetchingDone() {
+  // NotifyObservers only fires notifications if the cache is ready.
+  NotifyObservers();
+}
+
 void CloudPolicyCacheBase::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
@@ -109,8 +114,6 @@ bool CloudPolicyCacheBase::SetPolicyInternal(
                               kMetricPolicySize);
   }
 
-  NotifyObservers();
-
   InformNotifier(CloudPolicySubsystem::SUCCESS,
                  CloudPolicySubsystem::NO_DETAILS);
   return true;
@@ -122,8 +125,6 @@ void CloudPolicyCacheBase::SetUnmanagedInternal(const base::Time& timestamp) {
   mandatory_policy_.Clear();
   recommended_policy_.Clear();
   last_policy_refresh_time_ = timestamp;
-
-  NotifyObservers();
 }
 
 void CloudPolicyCacheBase::SetReady() {
diff --git a/chrome/browser/policy/cloud_policy_cache_base.h b/chrome/browser/policy/cloud_policy_cache_base.h
index 69869527..330e9e7 100644
--- a/chrome/browser/policy/cloud_policy_cache_base.h
+++ b/chrome/browser/policy/cloud_policy_cache_base.h
@@ -57,7 +57,7 @@ class CloudPolicyCacheBase : public base::NonThreadSafe {
   // Invoked whenever an attempt to fetch policy has been completed. The fetch
   // may or may not have suceeded. This can be triggered by failed attempts to
   // fetch oauth tokens, register with dmserver or fetch policy.
-  virtual void SetFetchingDone() = 0;
+  virtual void SetFetchingDone();
 
   bool is_unmanaged() const {
     return is_unmanaged_;
diff --git a/chrome/browser/policy/cloud_policy_provider_impl.cc b/chrome/browser/policy/cloud_policy_provider_impl.cc
index d1c3f3b..ee09b78 100644
--- a/chrome/browser/policy/cloud_policy_provider_impl.cc
+++ b/chrome/browser/policy/cloud_policy_provider_impl.cc
@@ -4,14 +4,19 @@
 
 #include "chrome/browser/policy/cloud_policy_provider_impl.h"
 
+#include <algorithm>
+
+#include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
 
 namespace policy {
 
 CloudPolicyProviderImpl::CloudPolicyProviderImpl(
+    BrowserPolicyConnector* browser_policy_connector,
     const PolicyDefinitionList* policy_list,
     CloudPolicyCacheBase::PolicyLevel level)
     : CloudPolicyProvider(policy_list),
+      browser_policy_connector_(browser_policy_connector),
       level_(level),
       initialization_complete_(true) {}
 
@@ -29,19 +34,23 @@ bool CloudPolicyProviderImpl::IsInitializationComplete() const {
   return initialization_complete_;
 }
 
+void CloudPolicyProviderImpl::RefreshPolicies() {
+  pending_update_caches_ = caches_;
+  if (pending_update_caches_.empty())
+    NotifyPolicyUpdated();
+  else
+    browser_policy_connector_->FetchCloudPolicy();
+}
+
 void CloudPolicyProviderImpl::OnCacheUpdate(CloudPolicyCacheBase* cache) {
+  RemoveCache(cache, &pending_update_caches_);
   RecombineCachesAndTriggerUpdate();
 }
 
 void CloudPolicyProviderImpl::OnCacheGoingAway(CloudPolicyCacheBase* cache) {
   cache->RemoveObserver(this);
-  for (ListType::iterator i = caches_.begin(); i != caches_.end(); ++i) {
-    if (*i == cache) {
-      caches_.erase(i);
-      break;
-    }
-  }
-
+  RemoveCache(cache, &caches_);
+  RemoveCache(cache, &pending_update_caches_);
   RecombineCachesAndTriggerUpdate();
 }
 
@@ -112,7 +121,16 @@ void CloudPolicyProviderImpl::RecombineCachesAndTriggerUpdate() {
 
   // Trigger a notification.
   combined_.Swap(&newly_combined);
-  NotifyPolicyUpdated();
+  if (pending_update_caches_.empty())
+    NotifyPolicyUpdated();
+}
+
+// static
+void CloudPolicyProviderImpl::RemoveCache(CloudPolicyCacheBase* cache,
+                                          ListType* caches) {
+  ListType::iterator it = std::find(caches->begin(), caches->end(), cache);
+  if (it != caches->end())
+    caches->erase(it);
 }
 
 }  // namespace policy
diff --git a/chrome/browser/policy/cloud_policy_provider_impl.h b/chrome/browser/policy/cloud_policy_provider_impl.h
index 71ef32c..06f2b9c 100644
--- a/chrome/browser/policy/cloud_policy_provider_impl.h
+++ b/chrome/browser/policy/cloud_policy_provider_impl.h
@@ -14,16 +14,20 @@
 
 namespace policy {
 
+class BrowserPolicyConnector;
+
 class CloudPolicyProviderImpl : public CloudPolicyProvider,
                                 public CloudPolicyCacheBase::Observer {
  public:
-  CloudPolicyProviderImpl(const PolicyDefinitionList* policy_list,
+  CloudPolicyProviderImpl(BrowserPolicyConnector* browser_policy_connector,
+                          const PolicyDefinitionList* policy_list,
                           CloudPolicyCacheBase::PolicyLevel level);
   virtual ~CloudPolicyProviderImpl();
 
   // ConfigurationPolicyProvider implementation.
   virtual bool ProvideInternal(PolicyMap* result) OVERRIDE;
   virtual bool IsInitializationComplete() const OVERRIDE;
+  virtual void RefreshPolicies() OVERRIDE;
 
   // CloudPolicyCacheBase::Observer implementation.
   virtual void OnCacheUpdate(CloudPolicyCacheBase* cache) OVERRIDE;
@@ -34,6 +38,8 @@ class CloudPolicyProviderImpl : public CloudPolicyProvider,
  private:
   friend class CloudPolicyProviderTest;
 
+  typedef std::vector<CloudPolicyCacheBase*> ListType;
+
   // Combines two PolicyMap and stores the result in out_map. The policies in
   // |base| take precedence over the policies in |overlay|. Proxy policies are
   // only applied in groups, that is if at least one proxy policy is present in
@@ -50,10 +56,19 @@ class CloudPolicyProviderImpl : public CloudPolicyProvider,
   // groups.
   void RecombineCachesAndTriggerUpdate();
 
+  // Removes |cache| from |caches|, if contained therein.
+  static void RemoveCache(CloudPolicyCacheBase* cache, ListType* caches);
+
+  // Weak pointer to the connector. Guaranteed to outlive |this|.
+  BrowserPolicyConnector* browser_policy_connector_;
+
   // The underlying policy caches.
-  typedef std::vector<CloudPolicyCacheBase*> ListType;
   ListType caches_;
 
+  // Caches with pending updates. Used by RefreshPolicies to determine if a
+  // refresh has fully completed.
+  ListType pending_update_caches_;
+
   // Policy level this provider will handle.
   CloudPolicyCacheBase::PolicyLevel level_;
 
diff --git a/chrome/browser/policy/cloud_policy_provider_unittest.cc b/chrome/browser/policy/cloud_policy_provider_unittest.cc
index 1af5037..40e2f77 100644
--- a/chrome/browser/policy/cloud_policy_provider_unittest.cc
+++ b/chrome/browser/policy/cloud_policy_provider_unittest.cc
@@ -6,13 +6,17 @@
 
 #include "base/basictypes.h"
 #include "base/values.h"
+#include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
 #include "chrome/browser/policy/cloud_policy_provider_impl.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/policy/configuration_policy_provider.h"
+#include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::AnyNumber;
+using testing::Mock;
 using testing::_;
 
 namespace policy {
@@ -23,15 +27,16 @@ class MockCloudPolicyCache : public CloudPolicyCacheBase {
   virtual ~MockCloudPolicyCache() {}
 
   // CloudPolicyCacheBase implementation.
-  void Load() {}
-  void SetPolicy(const em::PolicyFetchResponse& policy) {}
+  void Load() OVERRIDE {}
+  void SetPolicy(const em::PolicyFetchResponse& policy) OVERRIDE {}
   bool DecodePolicyData(const em::PolicyData& policy_data,
                         PolicyMap* mandatory,
-                        PolicyMap* recommended) {
+                        PolicyMap* recommended) OVERRIDE {
     return true;
   }
-  bool IsReady() {
-    return true;
+
+  void SetUnmanaged() OVERRIDE {
+    is_unmanaged_ = true;
   }
 
   // Non-const accessors for underlying PolicyMaps.
@@ -43,14 +48,6 @@ class MockCloudPolicyCache : public CloudPolicyCacheBase {
     return &recommended_policy_;
   }
 
-  void SetUnmanaged() {
-    is_unmanaged_ = true;
-  }
-
-  void SetFetchingDone() {
-    // Implement pure virtual method.
-  }
-
   void set_initialized(bool initialized) {
     initialization_complete_ = initialized;
   }
@@ -62,8 +59,11 @@ class MockCloudPolicyCache : public CloudPolicyCacheBase {
 class CloudPolicyProviderTest : public testing::Test {
  protected:
   void CreateCloudPolicyProvider(CloudPolicyCacheBase::PolicyLevel level) {
-    cloud_policy_provider_.reset(new CloudPolicyProviderImpl(
-        GetChromePolicyDefinitionList(), level));
+    cloud_policy_provider_.reset(
+        new CloudPolicyProviderImpl(
+            &browser_policy_connector_,
+            GetChromePolicyDefinitionList(),
+            level));
   }
 
   // Appends the caches to a provider and then provides the policies to
@@ -71,6 +71,7 @@ class CloudPolicyProviderTest : public testing::Test {
   void RunCachesThroughProvider(MockCloudPolicyCache caches[], int n,
                                 CloudPolicyCacheBase::PolicyLevel level) {
     CloudPolicyProviderImpl provider(
+        &browser_policy_connector_,
         GetChromePolicyDefinitionList(),
         level);
     for (int i = 0; i < n; i++) {
@@ -110,13 +111,10 @@ class CloudPolicyProviderTest : public testing::Test {
     cloud_policy_provider_->CombineTwoPolicyMaps(base, overlay, out_map);
   }
 
- private:
-  // Some tests need a list of policies that doesn't contain any proxy
-  // policies. Note: these policies will be handled as if they had the
-  // type of Value::TYPE_INTEGER.
-  static const ConfigurationPolicyType simple_policies[];
-
   scoped_ptr<CloudPolicyProviderImpl> cloud_policy_provider_;
+
+ private:
+  BrowserPolicyConnector browser_policy_connector_;
   scoped_ptr<PolicyMap> policy_map_;
 };
 
@@ -240,4 +238,64 @@ TEST_F(CloudPolicyProviderTest, CombineTwoPolicyMapsProxies) {
   EXPECT_FALSE(B.Equals(C));
 }
 
+TEST_F(CloudPolicyProviderTest, RefreshPolicies) {
+  CreateCloudPolicyProvider(CloudPolicyCacheBase::POLICY_LEVEL_MANDATORY);
+  MockCloudPolicyCache cache0;
+  MockCloudPolicyCache cache1;
+  MockCloudPolicyCache cache2;
+  MockConfigurationPolicyObserver observer;
+  ConfigurationPolicyObserverRegistrar registrar;
+  registrar.Init(cloud_policy_provider_.get(), &observer);
+
+  // OnUpdatePolicy is called when the provider doesn't have any caches.
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(1);
+  cloud_policy_provider_->RefreshPolicies();
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // OnUpdatePolicy is called when all the caches have updated.
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(2);
+  cloud_policy_provider_->AppendCache(&cache0);
+  cloud_policy_provider_->AppendCache(&cache1);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(0);
+  cloud_policy_provider_->RefreshPolicies();
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(0);
+  // Updating just one of the caches is not enough.
+  cloud_policy_provider_->OnCacheUpdate(&cache0);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(0);
+  // This cache wasn't available when RefreshPolicies was called, so it isn't
+  // required to fire the update.
+  cloud_policy_provider_->AppendCache(&cache2);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(1);
+  cloud_policy_provider_->OnCacheUpdate(&cache1);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(0);
+  cloud_policy_provider_->RefreshPolicies();
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(0);
+  cloud_policy_provider_->OnCacheUpdate(&cache0);
+  cloud_policy_provider_->OnCacheUpdate(&cache1);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // If a cache refreshes more than once, the provider should still wait for
+  // the others before firing the update.
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(0);
+  cloud_policy_provider_->OnCacheUpdate(&cache0);
+  Mock::VerifyAndClearExpectations(&observer);
+
+  // Fire updates if one of the required caches goes away while waiting.
+  EXPECT_CALL(observer, OnUpdatePolicy(cloud_policy_provider_.get())).Times(1);
+  cloud_policy_provider_->OnCacheGoingAway(&cache2);
+  Mock::VerifyAndClearExpectations(&observer);
+}
+
 }  // namespace policy
diff --git a/chrome/browser/policy/configuration_policy_pref_store.cc b/chrome/browser/policy/configuration_policy_pref_store.cc
index d928691..02aceb2 100644
--- a/chrome/browser/policy/configuration_policy_pref_store.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store.cc
@@ -81,11 +81,13 @@ ConfigurationPolicyPrefStore::GetValue(const std::string& key,
   return PrefStore::READ_OK;
 }
 
-void ConfigurationPolicyPrefStore::OnUpdatePolicy() {
+void ConfigurationPolicyPrefStore::OnUpdatePolicy(
+    ConfigurationPolicyProvider* provider) {
   Refresh();
 }
 
-void ConfigurationPolicyPrefStore::OnProviderGoingAway() {
+void ConfigurationPolicyPrefStore::OnProviderGoingAway(
+    ConfigurationPolicyProvider* provider) {
   provider_ = NULL;
 }
 
diff --git a/chrome/browser/policy/configuration_policy_pref_store.h b/chrome/browser/policy/configuration_policy_pref_store.h
index 82fc3a1..40c3635 100644
--- a/chrome/browser/policy/configuration_policy_pref_store.h
+++ b/chrome/browser/policy/configuration_policy_pref_store.h
@@ -54,8 +54,9 @@ class ConfigurationPolicyPrefStore
                               const Value** result) const OVERRIDE;
 
   // ConfigurationPolicyProvider::Observer methods:
-  virtual void OnUpdatePolicy() OVERRIDE;
-  virtual void OnProviderGoingAway() OVERRIDE;
+  virtual void OnUpdatePolicy(ConfigurationPolicyProvider* provider) OVERRIDE;
+  virtual void OnProviderGoingAway(
+      ConfigurationPolicyProvider* provider) OVERRIDE;
 
   // Creates a ConfigurationPolicyPrefStore that reads managed platform policy.
   static ConfigurationPolicyPrefStore* CreateManagedPlatformPolicyPrefStore();
diff --git a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
index 337f097..cb2494a 100644
--- a/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_pref_store_unittest.cc
@@ -61,7 +61,7 @@ TEST_P(ConfigurationPolicyPrefStoreListTest, SetValue) {
   in_value->Append(Value::CreateStringValue("test1"));
   in_value->Append(Value::CreateStringValue("test2,"));
   provider_.AddPolicy(GetParam().type(), in_value);
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
@@ -108,7 +108,7 @@ TEST_P(ConfigurationPolicyPrefStoreStringTest, GetDefault) {
 TEST_P(ConfigurationPolicyPrefStoreStringTest, SetValue) {
   provider_.AddPolicy(GetParam().type(),
                       Value::CreateStringValue("http://chromium.org"));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
@@ -158,7 +158,7 @@ TEST_P(ConfigurationPolicyPrefStoreBooleanTest, GetDefault) {
 
 TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
   provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(false));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
@@ -169,7 +169,7 @@ TEST_P(ConfigurationPolicyPrefStoreBooleanTest, SetValue) {
   EXPECT_FALSE(boolean_value);
 
   provider_.AddPolicy(GetParam().type(), Value::CreateBooleanValue(true));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
@@ -278,7 +278,7 @@ TEST_P(ConfigurationPolicyPrefStoreIntegerTest, GetDefault) {
 
 TEST_P(ConfigurationPolicyPrefStoreIntegerTest, SetValue) {
   provider_.AddPolicy(GetParam().type(), Value::CreateIntegerValue(2));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(GetParam().pref_name(), &value));
@@ -830,7 +830,7 @@ TEST_F(ConfigurationPolicyPrefStoreSyncTest, Default) {
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
   provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(false));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   // Enabling Sync should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kSyncManaged, NULL));
@@ -838,7 +838,7 @@ TEST_F(ConfigurationPolicyPrefStoreSyncTest, Enabled) {
 
 TEST_F(ConfigurationPolicyPrefStoreSyncTest, Disabled) {
   provider_.AddPolicy(kPolicySyncDisabled, Value::CreateBooleanValue(true));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   // Sync should be flagged as managed.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK, store_->GetValue(prefs::kSyncManaged, &value));
@@ -865,7 +865,7 @@ TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest, SetDownloadDirectory) {
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kPromptForDownload, NULL));
   provider_.AddPolicy(kPolicyDownloadDirectory, Value::CreateStringValue(""));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
 
   // Setting a DownloadDirectory should disable the PromptForDownload pref.
   const Value* value = NULL;
@@ -885,7 +885,7 @@ TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
             store_->GetValue(prefs::kPromptForDownload, NULL));
   provider_.AddPolicy(kPolicyAllowFileSelectionDialogs,
                       Value::CreateBooleanValue(true));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
 
   // Allowing file-selection dialogs should not influence the PromptForDownload
   // pref.
@@ -899,7 +899,7 @@ TEST_F(ConfigurationPolicyPrefStorePromptDownloadTest,
             store_->GetValue(prefs::kPromptForDownload, NULL));
   provider_.AddPolicy(kPolicyAllowFileSelectionDialogs,
                       Value::CreateBooleanValue(false));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
 
   // Disabling file-selection dialogs should disable the PromptForDownload pref.
   const Value* value = NULL;
@@ -924,7 +924,7 @@ TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Default) {
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Enabled) {
   provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(true));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   // Enabling Autofill should not set the pref.
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kAutofillEnabled, NULL));
@@ -932,7 +932,7 @@ TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Enabled) {
 
 TEST_F(ConfigurationPolicyPrefStoreAutofillTest, Disabled) {
   provider_.AddPolicy(kPolicyAutoFillEnabled, Value::CreateBooleanValue(false));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   // Disabling Autofill should switch the pref to managed.
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
@@ -967,19 +967,19 @@ TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Refresh) {
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
   provider_.AddPolicy(kPolicyHomepageLocation,
                       Value::CreateStringValue("http://www.chromium.org"));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kHomePage, &value));
   EXPECT_TRUE(StringValue("http://www.chromium.org").Equals(value));
 
   EXPECT_CALL(observer_, OnPrefValueChanged(_)).Times(0);
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
 
   EXPECT_CALL(observer_, OnPrefValueChanged(prefs::kHomePage)).Times(1);
   provider_.RemovePolicy(kPolicyHomepageLocation);
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kHomePage, NULL));
@@ -993,7 +993,7 @@ TEST_F(ConfigurationPolicyPrefStoreRefreshTest, Initialization) {
   provider_.SetInitializationComplete(true);
   EXPECT_FALSE(store_->IsInitializationComplete());
 
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   Mock::VerifyAndClearExpectations(&observer_);
   EXPECT_TRUE(store_->IsInitializationComplete());
 }
@@ -1009,12 +1009,12 @@ TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabled) {
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
   provider_.AddPolicy(kPolicyJavascriptEnabled,
                       Value::CreateBooleanValue(true));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   EXPECT_EQ(PrefStore::READ_NO_VALUE,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
   provider_.AddPolicy(kPolicyJavascriptEnabled,
                       Value::CreateBooleanValue(false));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
@@ -1026,7 +1026,7 @@ TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabledOverridden) {
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, NULL));
   provider_.AddPolicy(kPolicyJavascriptEnabled,
                       Value::CreateBooleanValue(false));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   const Value* value = NULL;
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
@@ -1034,7 +1034,7 @@ TEST_F(ConfigurationPolicyPrefStoreOthersTest, JavascriptEnabledOverridden) {
   // DefaultJavaScriptSetting overrides JavascriptEnabled.
   provider_.AddPolicy(kPolicyDefaultJavaScriptSetting,
                       Value::CreateIntegerValue(CONTENT_SETTING_ALLOW));
-  store_->OnUpdatePolicy();
+  store_->OnUpdatePolicy(&provider_);
   EXPECT_EQ(PrefStore::READ_OK,
             store_->GetValue(prefs::kManagedDefaultJavaScriptSetting, &value));
   EXPECT_TRUE(base::FundamentalValue(CONTENT_SETTING_ALLOW).Equals(value));
diff --git a/chrome/browser/policy/configuration_policy_provider.cc b/chrome/browser/policy/configuration_policy_provider.cc
index 903916a..7dbf104 100644
--- a/chrome/browser/policy/configuration_policy_provider.cc
+++ b/chrome/browser/policy/configuration_policy_provider.cc
@@ -10,7 +10,8 @@ namespace policy {
 
 ConfigurationPolicyProvider::Observer::~Observer() {}
 
-void ConfigurationPolicyProvider::Observer::OnProviderGoingAway() {}
+void ConfigurationPolicyProvider::Observer::OnProviderGoingAway(
+    ConfigurationPolicyProvider* provider) {}
 
 // Class ConfigurationPolicyProvider.
 
@@ -22,7 +23,7 @@ ConfigurationPolicyProvider::ConfigurationPolicyProvider(
 ConfigurationPolicyProvider::~ConfigurationPolicyProvider() {
   FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                     observer_list_,
-                    OnProviderGoingAway());
+                    OnProviderGoingAway(this));
 }
 
 bool ConfigurationPolicyProvider::Provide(PolicyMap* result) {
@@ -51,7 +52,7 @@ void ConfigurationPolicyProvider::OverridePolicies(PolicyMap* policies) {
 void ConfigurationPolicyProvider::NotifyPolicyUpdated() {
   FOR_EACH_OBSERVER(ConfigurationPolicyProvider::Observer,
                     observer_list_,
-                    OnUpdatePolicy());
+                    OnUpdatePolicy(this));
 }
 
 void ConfigurationPolicyProvider::AddObserver(Observer* observer) {
@@ -81,12 +82,16 @@ void ConfigurationPolicyObserverRegistrar::Init(
   provider_->AddObserver(this);
 }
 
-void ConfigurationPolicyObserverRegistrar::OnUpdatePolicy() {
-  observer_->OnUpdatePolicy();
+void ConfigurationPolicyObserverRegistrar::OnUpdatePolicy(
+    ConfigurationPolicyProvider* provider) {
+  DCHECK_EQ(provider_, provider);
+  observer_->OnUpdatePolicy(provider_);
 }
 
-void ConfigurationPolicyObserverRegistrar::OnProviderGoingAway() {
-  observer_->OnProviderGoingAway();
+void ConfigurationPolicyObserverRegistrar::OnProviderGoingAway(
+    ConfigurationPolicyProvider* provider) {
+  DCHECK_EQ(provider_, provider);
+  observer_->OnProviderGoingAway(provider_);
   provider_->RemoveObserver(this);
   provider_ = NULL;
 }
diff --git a/chrome/browser/policy/configuration_policy_provider.h b/chrome/browser/policy/configuration_policy_provider.h
index 5a52ff0..95abfb65 100644
--- a/chrome/browser/policy/configuration_policy_provider.h
+++ b/chrome/browser/policy/configuration_policy_provider.h
@@ -28,8 +28,8 @@ class ConfigurationPolicyProvider {
   class Observer {
    public:
     virtual ~Observer();
-    virtual void OnUpdatePolicy() = 0;
-    virtual void OnProviderGoingAway();
+    virtual void OnUpdatePolicy(ConfigurationPolicyProvider* provider) = 0;
+    virtual void OnProviderGoingAway(ConfigurationPolicyProvider* provider);
   };
 
   explicit ConfigurationPolicyProvider(const PolicyDefinitionList* policy_list);
@@ -54,6 +54,13 @@ class ConfigurationPolicyProvider {
   void OverridePolicies(PolicyMap* policies);
 #endif
 
+  // Asks the provider to refresh its policies. All the updates caused by this
+  // call will be visible on the next call of OnUpdatePolicy on the observers,
+  // which are guaranteed to happen even if the refresh fails.
+  // It is possible that OnProviderGoingAway is called first though, and
+  // OnUpdatePolicy won't be called if that happens.
+  virtual void RefreshPolicies() = 0;
+
  protected:
   // Sends a policy update notification to observers.
   void NotifyPolicyUpdated();
@@ -100,8 +107,9 @@ class ConfigurationPolicyObserverRegistrar
             ConfigurationPolicyProvider::Observer* observer);
 
   // ConfigurationPolicyProvider::Observer implementation:
-  virtual void OnUpdatePolicy() OVERRIDE;
-  virtual void OnProviderGoingAway() OVERRIDE;
+  virtual void OnUpdatePolicy(ConfigurationPolicyProvider* provider) OVERRIDE;
+  virtual void OnProviderGoingAway(
+      ConfigurationPolicyProvider* provider) OVERRIDE;
 
   ConfigurationPolicyProvider* provider() { return provider_; }
 
diff --git a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
index a0b8a0b..b8173cf 100644
--- a/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_provider_mac_unittest.cc
@@ -137,7 +137,8 @@ TEST_F(ConfigurationPolicyProviderMacTest, Invalid) {
   prefs_->AddTestItem(name, invalid_data.get(), true);
 
   // Create the provider and have it read |prefs_|.
-  provider_.ForceReload();
+  provider_.RefreshPolicies();
+  loop_.RunAllPending();
   PolicyMap policy_map;
   EXPECT_TRUE(provider_.Provide(&policy_map));
   EXPECT_TRUE(policy_map.empty());
@@ -152,7 +153,8 @@ TEST_F(ConfigurationPolicyProviderMacTest, TestNonForcedValue) {
   prefs_->AddTestItem(name, test_value.get(), false);
 
   // Create the provider and have it read |prefs_|.
-  provider_.ForceReload();
+  provider_.RefreshPolicies();
+  loop_.RunAllPending();
   PolicyMap policy_map;
   EXPECT_TRUE(provider_.Provide(&policy_map));
   EXPECT_TRUE(policy_map.empty());
diff --git a/chrome/browser/policy/configuration_policy_provider_test.cc b/chrome/browser/policy/configuration_policy_provider_test.cc
index 6997e61..5dadff7 100644
--- a/chrome/browser/policy/configuration_policy_provider_test.cc
+++ b/chrome/browser/policy/configuration_policy_provider_test.cc
@@ -9,8 +9,13 @@
 #include "chrome/browser/policy/asynchronous_policy_loader.h"
 #include "chrome/browser/policy/asynchronous_policy_provider.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
+#include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+using ::testing::Mock;
+using ::testing::_;
 
 namespace policy {
 
@@ -56,6 +61,9 @@ void ConfigurationPolicyProviderTest::SetUp() {
 
   provider_.reset(
       test_harness_->CreateProvider(&test_policy_definitions::kList));
+  // Some providers do a reload on init. Make sure any notifications generated
+  // are fired now.
+  loop_.RunAllPending();
 
   PolicyMap policy_map;
   EXPECT_TRUE(provider_->Provide(&policy_map));
@@ -76,7 +84,7 @@ void ConfigurationPolicyProviderTest::CheckValue(
     base::Closure install_value) {
   // Install the value, reload policy and check the provider for the value.
   install_value.Run();
-  provider_->ForceReload();
+  provider_->RefreshPolicies();
   loop_.RunAllPending();
   PolicyMap policy_map;
   EXPECT_TRUE(provider_->Provide(&policy_map));
@@ -86,7 +94,7 @@ void ConfigurationPolicyProviderTest::CheckValue(
 }
 
 TEST_P(ConfigurationPolicyProviderTest, Empty) {
-  provider_->ForceReload();
+  provider_->RefreshPolicies();
   loop_.RunAllPending();
   PolicyMap policy_map;
   EXPECT_TRUE(provider_->Provide(&policy_map));
@@ -140,4 +148,34 @@ TEST_P(ConfigurationPolicyProviderTest, StringListValue) {
                         &expected_value));
 }
 
+TEST_P(ConfigurationPolicyProviderTest, RefreshPolicies) {
+  PolicyMap policy_map;
+  EXPECT_TRUE(provider_->Provide(&policy_map));
+  EXPECT_EQ(0U, policy_map.size());
+
+  // OnUpdatePolicy is called even when there are no changes.
+  MockConfigurationPolicyObserver observer;
+  ConfigurationPolicyObserverRegistrar registrar;
+  registrar.Init(provider_.get(), &observer);
+  EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
+  provider_->RefreshPolicies();
+  loop_.RunAllPending();
+  Mock::VerifyAndClearExpectations(&observer);
+
+  EXPECT_TRUE(provider_->Provide(&policy_map));
+  EXPECT_EQ(0U, policy_map.size());
+
+  // OnUpdatePolicy is called when there are changes.
+  test_harness_->InstallStringPolicy(test_policy_definitions::kKeyString,
+                                     "value");
+  EXPECT_CALL(observer, OnUpdatePolicy(provider_.get())).Times(1);
+  provider_->RefreshPolicies();
+  loop_.RunAllPending();
+  Mock::VerifyAndClearExpectations(&observer);
+
+  policy_map.Clear();
+  EXPECT_TRUE(provider_->Provide(&policy_map));
+  EXPECT_EQ(1U, policy_map.size());
+}
+
 }  // 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 bab9997..7f5093c 100644
--- a/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_provider_win_unittest.cc
@@ -217,7 +217,7 @@ TEST_F(ConfigurationPolicyProviderWinTest, HKLMOverHKCU) {
   hkcu_key.WriteValue(UTF8ToUTF16(test_policy_definitions::kKeyString).c_str(),
                       UTF8ToUTF16("hkcu").c_str());
 
-  provider_.ForceReload();
+  provider_.RefreshPolicies();
   loop_.RunAllPending();
 
   PolicyMap policy_map;
diff --git a/chrome/browser/policy/configuration_policy_reader.cc b/chrome/browser/policy/configuration_policy_reader.cc
index 02e93c6..bd99102 100644
--- a/chrome/browser/policy/configuration_policy_reader.cc
+++ b/chrome/browser/policy/configuration_policy_reader.cc
@@ -117,11 +117,13 @@ ConfigurationPolicyReader::ConfigurationPolicyReader(
 ConfigurationPolicyReader::~ConfigurationPolicyReader() {
 }
 
-void ConfigurationPolicyReader::OnUpdatePolicy() {
+void ConfigurationPolicyReader::OnUpdatePolicy(
+    ConfigurationPolicyProvider* provider) {
   Refresh();
 }
 
-void ConfigurationPolicyReader::OnProviderGoingAway() {
+void ConfigurationPolicyReader::OnProviderGoingAway(
+    ConfigurationPolicyProvider* provider) {
   provider_ = NULL;
 }
 
diff --git a/chrome/browser/policy/configuration_policy_reader.h b/chrome/browser/policy/configuration_policy_reader.h
index dcd36bb..da11fa8 100644
--- a/chrome/browser/policy/configuration_policy_reader.h
+++ b/chrome/browser/policy/configuration_policy_reader.h
@@ -40,8 +40,9 @@ class ConfigurationPolicyReader : public ConfigurationPolicyProvider::Observer {
   virtual ~ConfigurationPolicyReader();
 
   // ConfigurationPolicyProvider::Observer methods:
-  virtual void OnUpdatePolicy() OVERRIDE;
-  virtual void OnProviderGoingAway() OVERRIDE;
+  virtual void OnUpdatePolicy(ConfigurationPolicyProvider* provider) OVERRIDE;
+  virtual void OnProviderGoingAway(
+      ConfigurationPolicyProvider* provider) OVERRIDE;
 
   // Methods to handle Observers. |observer| must be non-NULL.
   void AddObserver(Observer* observer);
diff --git a/chrome/browser/policy/configuration_policy_reader_unittest.cc b/chrome/browser/policy/configuration_policy_reader_unittest.cc
index 8c5b275..317f225 100644
--- a/chrome/browser/policy/configuration_policy_reader_unittest.cc
+++ b/chrome/browser/policy/configuration_policy_reader_unittest.cc
@@ -62,7 +62,7 @@ TEST_F(ConfigurationPolicyReaderTest, SetListValue) {
   in_value->Append(Value::CreateStringValue("test1"));
   in_value->Append(Value::CreateStringValue("test2"));
   provider_.AddPolicy(kPolicyRestoreOnStartupURLs, in_value);
-  managed_reader_->OnUpdatePolicy();
+  managed_reader_->OnUpdatePolicy(&provider_);
 
   scoped_ptr<DictionaryValue>
       dict(CreateDictionary(key::kRestoreOnStartupURLs, in_value->DeepCopy()));
@@ -70,7 +70,7 @@ TEST_F(ConfigurationPolicyReaderTest, SetListValue) {
       managed_reader_->GetPolicyStatus(kPolicyRestoreOnStartupURLs));
   EXPECT_TRUE(dict->Equals(result.get()));
 
-  recommended_reader_->OnUpdatePolicy();
+  recommended_reader_->OnUpdatePolicy(&provider_);
   dict->SetString("level",
       PolicyStatusInfo::GetPolicyLevelString(PolicyStatusInfo::RECOMMENDED));
   result.reset(
@@ -82,14 +82,14 @@ TEST_F(ConfigurationPolicyReaderTest, SetListValue) {
 TEST_F(ConfigurationPolicyReaderTest, SetStringValue) {
   provider_.AddPolicy(kPolicyHomepageLocation,
       Value::CreateStringValue("http://chromium.org"));
-  managed_reader_->OnUpdatePolicy();
+  managed_reader_->OnUpdatePolicy(&provider_);
   scoped_ptr<DictionaryValue> dict(CreateDictionary(key::kHomepageLocation,
       Value::CreateStringValue("http://chromium.org")));
   scoped_ptr<DictionaryValue> result(
       managed_reader_->GetPolicyStatus(kPolicyHomepageLocation));
   EXPECT_TRUE(dict->Equals(result.get()));
 
-  recommended_reader_->OnUpdatePolicy();
+  recommended_reader_->OnUpdatePolicy(&provider_);
   dict->SetString("level",
       PolicyStatusInfo::GetPolicyLevelString(PolicyStatusInfo::RECOMMENDED));
   result.reset(
@@ -100,21 +100,21 @@ TEST_F(ConfigurationPolicyReaderTest, SetStringValue) {
 // Test for boolean-valued policy settings.
 TEST_F(ConfigurationPolicyReaderTest, SetBooleanValue) {
   provider_.AddPolicy(kPolicyShowHomeButton, Value::CreateBooleanValue(true));
-  managed_reader_->OnUpdatePolicy();
+  managed_reader_->OnUpdatePolicy(&provider_);
   scoped_ptr<DictionaryValue> dict(CreateDictionary(key::kShowHomeButton,
       Value::CreateBooleanValue(true)));
   scoped_ptr<DictionaryValue> result(
       managed_reader_->GetPolicyStatus(kPolicyShowHomeButton));
   EXPECT_TRUE(dict->Equals(result.get()));
 
-  recommended_reader_->OnUpdatePolicy();
+  recommended_reader_->OnUpdatePolicy(&provider_);
   dict->SetString("level",
       PolicyStatusInfo::GetPolicyLevelString(PolicyStatusInfo::RECOMMENDED));
   result.reset(recommended_reader_->GetPolicyStatus(kPolicyShowHomeButton));
   EXPECT_TRUE(dict->Equals(result.get()));
 
   provider_.AddPolicy(kPolicyShowHomeButton, Value::CreateBooleanValue(false));
-  managed_reader_->OnUpdatePolicy();
+  managed_reader_->OnUpdatePolicy(&provider_);
   dict->Set(
       PolicyStatusInfo::kValueDictPath, Value::CreateBooleanValue(false));
   dict->SetString("level",
@@ -122,7 +122,7 @@ TEST_F(ConfigurationPolicyReaderTest, SetBooleanValue) {
   result.reset(managed_reader_->GetPolicyStatus(kPolicyShowHomeButton));
   EXPECT_TRUE(dict->Equals(result.get()));
 
-  recommended_reader_->OnUpdatePolicy();
+  recommended_reader_->OnUpdatePolicy(&provider_);
   dict->SetString("level",
       PolicyStatusInfo::GetPolicyLevelString(PolicyStatusInfo::RECOMMENDED));
   result.reset(recommended_reader_->GetPolicyStatus(kPolicyShowHomeButton));
@@ -132,14 +132,14 @@ TEST_F(ConfigurationPolicyReaderTest, SetBooleanValue) {
 // Test for integer-valued policy settings.
 TEST_F(ConfigurationPolicyReaderTest, SetIntegerValue) {
   provider_.AddPolicy(kPolicyRestoreOnStartup, Value::CreateIntegerValue(3));
-  managed_reader_->OnUpdatePolicy();
+  managed_reader_->OnUpdatePolicy(&provider_);
   scoped_ptr<DictionaryValue> dict(CreateDictionary(key::kRestoreOnStartup,
       Value::CreateIntegerValue(3)));
   scoped_ptr<DictionaryValue> result(
       managed_reader_->GetPolicyStatus(kPolicyRestoreOnStartup));
   EXPECT_TRUE(dict->Equals(result.get()));
 
-  recommended_reader_->OnUpdatePolicy();
+  recommended_reader_->OnUpdatePolicy(&provider_);
   dict->SetString("level",
       PolicyStatusInfo::GetPolicyLevelString(PolicyStatusInfo::RECOMMENDED));
   result.reset(recommended_reader_->GetPolicyStatus(kPolicyRestoreOnStartup));
diff --git a/chrome/browser/policy/device_policy_cache.cc b/chrome/browser/policy/device_policy_cache.cc
index 5350912..c626080 100644
--- a/chrome/browser/policy/device_policy_cache.cc
+++ b/chrome/browser/policy/device_policy_cache.cc
@@ -191,10 +191,6 @@ void DevicePolicyCache::SetUnmanaged() {
   // This is not supported for DevicePolicyCache.
 }
 
-void DevicePolicyCache::SetFetchingDone() {
-  // Not interesting for device policy cache.
-}
-
 void DevicePolicyCache::OnRetrievePolicyCompleted(
     chromeos::SignedSettings::ReturnCode code,
     const em::PolicyFetchResponse& policy) {
diff --git a/chrome/browser/policy/device_policy_cache.h b/chrome/browser/policy/device_policy_cache.h
index 4904b66..63ed1ce 100644
--- a/chrome/browser/policy/device_policy_cache.h
+++ b/chrome/browser/policy/device_policy_cache.h
@@ -33,7 +33,6 @@ class DevicePolicyCache : public CloudPolicyCacheBase,
   virtual void Load() OVERRIDE;
   virtual void SetPolicy(const em::PolicyFetchResponse& policy) OVERRIDE;
   virtual void SetUnmanaged() OVERRIDE;
-  virtual void SetFetchingDone() OVERRIDE;
 
   // SignedSettingsHelper::Callback implementation:
   virtual void OnRetrievePolicyCompleted(
diff --git a/chrome/browser/policy/file_based_policy_loader.cc b/chrome/browser/policy/file_based_policy_loader.cc
index 343e320..87f873d8 100644
--- a/chrome/browser/policy/file_based_policy_loader.cc
+++ b/chrome/browser/policy/file_based_policy_loader.cc
@@ -72,8 +72,10 @@ void FileBasedPolicyLoader::OnFilePathError(const FilePath& path) {
 void FileBasedPolicyLoader::Reload(bool force) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-  if (!delegate())
+  if (!delegate()) {
+    PostUpdatePolicyTask(NULL);
     return;
+  }
 
   // Check the directory time in order to see whether a reload is required.
   base::TimeDelta delay;
diff --git a/chrome/browser/policy/file_based_policy_provider_unittest.cc b/chrome/browser/policy/file_based_policy_provider_unittest.cc
index ba0f004..4c56937 100644
--- a/chrome/browser/policy/file_based_policy_provider_unittest.cc
+++ b/chrome/browser/policy/file_based_policy_provider_unittest.cc
@@ -5,7 +5,9 @@
 #include "chrome/browser/policy/asynchronous_policy_loader.h"
 #include "chrome/browser/policy/asynchronous_policy_test_base.h"
 #include "chrome/browser/policy/configuration_policy_pref_store.h"
+#include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/file_based_policy_provider.h"
+#include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ -72,7 +74,11 @@ TEST_F(AsynchronousPolicyTestBase, ProviderRefresh) {
   DictionaryValue* policies = new DictionaryValue();
   policies->SetBoolean(policy::key::kSyncDisabled, true);
   EXPECT_CALL(*provider_delegate, Load()).WillOnce(Return(policies));
-  file_based_provider.ForceReload();
+  MockConfigurationPolicyObserver observer;
+  ConfigurationPolicyObserverRegistrar registrar;
+  registrar.Init(&file_based_provider, &observer);
+  EXPECT_CALL(observer, OnUpdatePolicy(&file_based_provider)).Times(1);
+  file_based_provider.RefreshPolicies();
   loop_.RunAllPending();
   PolicyMap policy_map;
   file_based_provider.Provide(&policy_map);
diff --git a/chrome/browser/policy/mock_configuration_policy_provider.cc b/chrome/browser/policy/mock_configuration_policy_provider.cc
index eeee46f..8edc105 100644
--- a/chrome/browser/policy/mock_configuration_policy_provider.cc
+++ b/chrome/browser/policy/mock_configuration_policy_provider.cc
@@ -40,4 +40,12 @@ bool MockConfigurationPolicyProvider::IsInitializationComplete() const {
   return initialization_complete_;
 }
 
+void MockConfigurationPolicyProvider::RefreshPolicies() {
+  NotifyPolicyUpdated();
+}
+
+MockConfigurationPolicyObserver::MockConfigurationPolicyObserver() {}
+
+MockConfigurationPolicyObserver::~MockConfigurationPolicyObserver() {}
+
 }  // namespace policy
diff --git a/chrome/browser/policy/mock_configuration_policy_provider.h b/chrome/browser/policy/mock_configuration_policy_provider.h
index 6f5c9f9..105a4ed 100644
--- a/chrome/browser/policy/mock_configuration_policy_provider.h
+++ b/chrome/browser/policy/mock_configuration_policy_provider.h
@@ -8,6 +8,7 @@
 
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
+#include "testing/gmock/include/gmock/gmock.h"
 
 namespace policy {
 
@@ -26,6 +27,7 @@ class MockConfigurationPolicyProvider : public ConfigurationPolicyProvider {
   // ConfigurationPolicyProvider method overrides.
   virtual bool ProvideInternal(PolicyMap* policies) OVERRIDE;
   virtual bool IsInitializationComplete() const OVERRIDE;
+  virtual void RefreshPolicies() OVERRIDE;
 
   // Make public for tests.
   using ConfigurationPolicyProvider::NotifyPolicyUpdated;
@@ -36,6 +38,16 @@ class MockConfigurationPolicyProvider : public ConfigurationPolicyProvider {
   bool initialization_complete_;
 };
 
+class MockConfigurationPolicyObserver
+    : public ConfigurationPolicyProvider::Observer {
+ public:
+  MockConfigurationPolicyObserver();
+  virtual ~MockConfigurationPolicyObserver();
+
+  MOCK_METHOD1(OnUpdatePolicy, void(ConfigurationPolicyProvider*));
+  MOCK_METHOD1(OnProviderGoingAway, void(ConfigurationPolicyProvider*));
+};
+
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_MOCK_CONFIGURATION_POLICY_PROVIDER_H_
diff --git a/chrome/browser/policy/network_configuration_updater.cc b/chrome/browser/policy/network_configuration_updater.cc
index 6615173..dd9fc8a 100644
--- a/chrome/browser/policy/network_configuration_updater.cc
+++ b/chrome/browser/policy/network_configuration_updater.cc
@@ -21,7 +21,8 @@ NetworkConfigurationUpdater::NetworkConfigurationUpdater(
 
 NetworkConfigurationUpdater::~NetworkConfigurationUpdater() {}
 
-void NetworkConfigurationUpdater::OnUpdatePolicy() {
+void NetworkConfigurationUpdater::OnUpdatePolicy(
+    ConfigurationPolicyProvider* provider) {
   Update();
 }
 
diff --git a/chrome/browser/policy/network_configuration_updater.h b/chrome/browser/policy/network_configuration_updater.h
index 2953468..9282a3c 100644
--- a/chrome/browser/policy/network_configuration_updater.h
+++ b/chrome/browser/policy/network_configuration_updater.h
@@ -28,7 +28,7 @@ class NetworkConfigurationUpdater
   virtual ~NetworkConfigurationUpdater();
 
   // ConfigurationPolicyProvider::Observer:
-  virtual void OnUpdatePolicy() OVERRIDE;
+  virtual void OnUpdatePolicy(ConfigurationPolicyProvider* provider) OVERRIDE;
 
  private:
   // Grabs network configuration from policy and applies it.
diff --git a/chrome/browser/policy/user_policy_cache.cc b/chrome/browser/policy/user_policy_cache.cc
index b9fd815..4969e4d 100644
--- a/chrome/browser/policy/user_policy_cache.cc
+++ b/chrome/browser/policy/user_policy_cache.cc
@@ -76,6 +76,7 @@ void UserPolicyCache::SetUnmanaged() {
 }
 
 void UserPolicyCache::SetFetchingDone() {
+  CloudPolicyCacheBase::SetFetchingDone();
   if (!fetch_ready_)
     DVLOG(1) << "SetFetchingDone, cache is now fetch_ready_";
   fetch_ready_ = true;
diff --git a/chrome/browser/policy/user_policy_cache_unittest.cc b/chrome/browser/policy/user_policy_cache_unittest.cc
index b6b6c5f..50095d8 100644
--- a/chrome/browser/policy/user_policy_cache_unittest.cc
+++ b/chrome/browser/policy/user_policy_cache_unittest.cc
@@ -103,16 +103,15 @@ class UserPolicyCacheTest : public testing::Test {
   // Takes ownership of |policy_response|.
   void SetPolicy(UserPolicyCache* cache,
                  em::PolicyFetchResponse* policy_response) {
-    scoped_ptr<em::PolicyFetchResponse> policy(policy_response);
-    cache->SetReady();
-    cache->AddObserver(&observer);
-
-    EXPECT_CALL(observer, OnCacheUpdate(_)).Times(1);
+    EXPECT_CALL(observer_, OnCacheUpdate(_)).Times(1);
+    cache->AddObserver(&observer_);
 
+    scoped_ptr<em::PolicyFetchResponse> policy(policy_response);
     cache->SetPolicy(*policy);
-    testing::Mock::VerifyAndClearExpectations(&observer);
+    cache->SetReady();
+    testing::Mock::VerifyAndClearExpectations(&observer_);
 
-    cache->RemoveObserver(&observer);
+    cache->RemoveObserver(&observer_);
   }
 
   void SetReady(UserPolicyCache* cache) {
@@ -132,7 +131,7 @@ class UserPolicyCacheTest : public testing::Test {
   }
 
   MessageLoop loop_;
-  MockCloudPolicyCacheBaseObserver observer;
+  MockCloudPolicyCacheBaseObserver observer_;
 
  private:
   ScopedTempDir temp_dir_;
@@ -359,19 +358,19 @@ TEST_F(UserPolicyCacheTest, FreshPolicyOverride) {
 
 TEST_F(UserPolicyCacheTest, SetReady) {
   UserPolicyCache cache(test_file(), false  /* wait_for_policy_fetch */);
-  cache.AddObserver(&observer);
+  cache.AddObserver(&observer_);
   scoped_ptr<em::PolicyFetchResponse> policy(
       CreateHomepagePolicy("http://www.example.com",
                            base::Time::NowFromSystemTime(),
                            em::PolicyOptions::MANDATORY));
-  EXPECT_CALL(observer, OnCacheUpdate(_)).Times(0);
+  EXPECT_CALL(observer_, OnCacheUpdate(_)).Times(0);
   cache.SetPolicy(*policy);
-  testing::Mock::VerifyAndClearExpectations(&observer);
+  testing::Mock::VerifyAndClearExpectations(&observer_);
 
   // Switching the cache to ready should send a notification.
-  EXPECT_CALL(observer, OnCacheUpdate(_)).Times(1);
+  EXPECT_CALL(observer_, OnCacheUpdate(_)).Times(1);
   SetReady(&cache);
-  cache.RemoveObserver(&observer);
+  cache.RemoveObserver(&observer_);
 }
 
 // Test case for the temporary support for GenericNamedValues in the