Added ConfigurationPolicyProvider::RefreshPolicies.

chrome/browser/policy/cloud_policy_provider_impl.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/policy/cloud_policy_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) {}
 
 CloudPolicyProviderImpl::~CloudPolicyProviderImpl() {
   for (ListType::iterator i = caches_.begin(); i != caches_.end(); ++i)
     (*i)->RemoveObserver(this);
 }
 
 bool CloudPolicyProviderImpl::ProvideInternal(PolicyMap* result) {
   result->CopyFrom(combined_);
   return true;
 }
 
 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();
 }
 
 void CloudPolicyProviderImpl::AppendCache(CloudPolicyCacheBase* cache) {
   initialization_complete_ &= cache->IsReady();
   cache->AddObserver(this);
   caches_.push_back(cache);
   RecombineCachesAndTriggerUpdate();
 }
 
@@ skipping 50 matching lines @@
   for (ListType::iterator i = caches_.begin(); i != caches_.end(); ++i) {
     if (!(*i)->IsReady())
       continue;
     PolicyMap tmp_map;
     CombineTwoPolicyMaps(newly_combined, *(*i)->policy(level_), &tmp_map);
     newly_combined.Swap(&tmp_map);
   }
 
   // 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