Changing policy while Chrome is running should refresh preferences without relaunching

chrome/browser/pref_service.cc

 // Copyright (c) 2010 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/pref_service.h"
 
 #include <algorithm>
 #include <string>
 
 #include "app/l10n_util.h"
@@ skipping 101 matching lines @@
           pref_filename,
           ChromeThread::GetMessageLoopProxyForThread(ChromeThread::FILE)),
           /* user prefs */
       NULL /* no advised prefs */);
   return new PrefService(value_store);
 }
 
 PrefService::PrefService(PrefValueStore* pref_value_store)
     : pref_value_store_(pref_value_store) {
   InitFromStorage();
+  registrar_.Add(this,
+                 NotificationType(NotificationType::POLICY_CHANGED),
+                 NotificationService::AllSources());
 }
 
 PrefService::~PrefService() {
   DCHECK(CalledOnValidThread());
 
   // Verify that there are no pref observers when we shut down.
   for (PrefObserverMap::iterator it = pref_observers_.begin();
        it != pref_observers_.end(); ++it) {
     NotificationObserverList::Iterator obs_iterator(*(it->second));
     if (obs_iterator.GetNext()) {
@@ skipping 687 matching lines @@
 }
 
 bool PrefService::Preference::IsExtensionControlled() const {
   return pref_value_store_->PrefValueFromExtensionStore(name_.c_str());
 }
 
 bool PrefService::Preference::IsUserControlled() const {
   return pref_value_store_->PrefValueFromUserStore(name_.c_str());
 }
 
+void PrefService::FireObserversForRefreshedManagedPrefs(
+    std::vector<std::string> changed_prefs_paths) {
+  DCHECK(CalledOnValidThread());
+  std::vector<std::string>::const_iterator current;
+  for (current = changed_prefs_paths.begin();
+       current != changed_prefs_paths.end();
+       ++current) {
+    FireObservers(UTF8ToWide(current->data()).data());
+  }
+}
+
 bool PrefService::Preference::IsUserModifiable() const {
   return pref_value_store_->PrefValueUserModifiable(name_.c_str());
 }
+
+void PrefService::Observe(NotificationType type,
+                          const NotificationSource& source,
+                          const NotificationDetails& details) {
+  if (type == NotificationType::POLICY_CHANGED) {
+      PrefValueStore::AfterRefreshCallback callback =
+          NewCallback(this,
+                      &PrefService::FireObserversForRefreshedManagedPrefs);
+      // The notification of the policy refresh can come from any thread,
+      // but the manipulation of the PrefValueStore must happen on the UI
+      // thread, thus the policy refresh must be explicitly started on it.
+      ChromeThread::PostTask(
+          ChromeThread::UI, FROM_HERE,
+          NewRunnableMethod(
+              pref_value_store_.get(),
+              &PrefValueStore::RefreshPolicyPrefs,
+              ConfigurationPolicyPrefStore::CreateManagedPolicyPrefStore(),
+              ConfigurationPolicyPrefStore::CreateRecommendedPolicyPrefStore(),
+              callback));
+  }
+}