Changing policy while Chrome is running should refresh preferences without relaunching

chrome/browser/pref_service.h

 // 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.
 
 // This provides a way to access the application's current preferences.
 
 #ifndef CHROME_BROWSER_PREF_SERVICE_H_
 #define CHROME_BROWSER_PREF_SERVICE_H_
 #pragma once
 
 #include <set>
+#include <string>
+#include <vector>
 
 #include "base/file_path.h"
 #include "base/hash_tables.h"
 #include "base/non_thread_safe.h"
 #include "base/observer_list.h"
+#include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/pref_value_store.h"
+#include "chrome/common/notification_observer.h"
+#include "chrome/common/notification_registrar.h"
 #include "chrome/common/pref_store.h"
 
-class NotificationObserver;
+class NotificationDetails;
+class NotificationSource;
+class NotificationType;
 class Preference;
 class Profile;
 class ScopedPrefUpdate;
 
-class PrefService : public NonThreadSafe {
+class PrefService : public NonThreadSafe,
+                    public NotificationObserver {
  public:
 
   // A helper class to store all the information associated with a preference.
   class Preference {
    public:
 
     // The type of the preference is determined by the type of |default_value|.
     // Therefore, the type needs to be a boolean, integer, real, string,
     // dictionary (a branch), or list.  You shouldn't need to construct this on
     // your own, use the PrefService::Register*Pref methods instead.
@@ skipping 209 matching lines @@
   // deleting the returned object.
   Value* GetPrefCopy(const wchar_t* pref_name);
 
   // Load from disk.  Returns a non-zero error code on failure.
   PrefStore::PrefReadError LoadPersistentPrefs();
 
   // Load preferences from storage, attempting to diagnose and handle errors.
   // This should only be called from the constructor.
   void InitFromStorage();
 
+  // NotificationObserver methods:
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
+  // Called after a policy refresh to notify relevant preference observers.
+  // |changed_prefs_paths| is the vector of preference paths changed by the
+  // policy update. It is passed by value and not reference because
+  // this method is called asynchronously as a callback from another thread.
+  // Copying the vector guarantees that the vector's lifecycle spans the
+  // method's invocation.
+  void FireObserversForRefreshedManagedPrefs(
+      std::vector<std::string> changed_prefs_paths);
+
   // The value of a Preference can be:
   // managed, user defined, recommended or default.
   // The PrefValueStore manages enforced, user defined and recommended values
   // for Preferences. It returns the value of a Preference with the
   // highest priority, and allows to set user defined values for preferences
   // that are not managed.
-  scoped_ptr<PrefValueStore> pref_value_store_;
+  scoped_refptr<PrefValueStore> pref_value_store_;
+
+  NotificationRegistrar registrar_;
 
   // A set of all the registered Preference objects.
   PreferenceSet prefs_;
 
   // A map from pref names to a list of observers.  Observers get fired in the
   // order they are added.
   typedef ObserverList<NotificationObserver> NotificationObserverList;
   typedef base::hash_map<std::wstring, NotificationObserverList*>
       PrefObserverMap;
   PrefObserverMap pref_observers_;
 
   friend class ScopedPrefUpdate;
 
   DISALLOW_COPY_AND_ASSIGN(PrefService);
 };
 
 #endif  // CHROME_BROWSER_PREF_SERVICE_H_