Changing policy while Chrome is running should refresh preferences without relaunching

chrome/browser/pref_value_store.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.
 
 #ifndef CHROME_BROWSER_PREF_VALUE_STORE_H_
 #define CHROME_BROWSER_PREF_VALUE_STORE_H_
 #pragma once
 
+#include <string>
+#include <vector>
+
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/file_path.h"
+#include "base/gtest_prod_util.h"
+#include "base/ref_counted.h"
 #include "base/string16.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
+#include "chrome/browser/chrome_thread.h"
 #include "chrome/common/pref_store.h"
 
 class PrefStore;
 
 // The class PrefValueStore provides values for preferences. Each Preference
 // has a unique name. This name is used to retrieve the value of a Preference.
 // The value of a preference can be either managed, user-defined or recommended.
 // Managed preference values are set (managed) by a third person (like an
 // admin for example). They have the highest priority and can not be
 // altered by the user.
 // User-defined values are chosen by the user. If there is already
 // a managed value for a preference the user-defined value is ignored and
 // the managed value is used (returned).
 // Otherwise user-defined values have a higher precedence than recommended
 // values. Recommended preference values are set by a third person
 // (like an admin).
-class PrefValueStore {
+// Unless otherwise explicitly noted, all of the methods of this class must
+// be called on the UI thread.
+class PrefValueStore : public base::RefCountedThreadSafe<PrefValueStore> {
  public:
   // In decreasing order of precedence:
   //   |managed_prefs| contains all managed (policy) preference values.
   //   |extension_prefs| contains preference values set by extensions.
   //   |command_line_prefs| contains preference values set by command-line
   //        switches.
   //   |user_prefs| contains all user-set preference values.
   //   |recommended_prefs| contains all recommended (policy) preference values.
   PrefValueStore(PrefStore* managed_prefs,
                  PrefStore* extension_prefs,
@@ skipping 53 matching lines @@
   // These methods return true if a preference with the given name is actually
   // being controlled by the indicated pref store and not being overridden by
   // a higher-priority source.
   bool PrefValueFromExtensionStore(const wchar_t* name);
   bool PrefValueFromUserStore(const wchar_t* name);
 
   // Check whether a Preference value is modifiable by the user, i.e. whether
   // there is no higher-priority source controlling it.
   bool PrefValueUserModifiable(const wchar_t* name);
 
+  // Signature of callback triggered after policy refresh. Parameter is not
+  // passed as reference to prevent passing along a pointer to a set whose
+  // lifecycle is managed in another thread.
+  typedef Callback1<std::vector<std::string> >::Type* AfterRefreshCallback;
+
+  // Called as a result of a notification of policy change. Triggers a
+  // reload of managed preferences from policy. Caller must pass in
+  // new, uninitialized managed and recommended PrefStores in
+  // |managed_pref_store| and |recommended_pref_store| respectively, since
+  // PrefValueStore doesn't know about policy-specific PrefStores.
+  // |callback| is called with the set of preferences changed by the policy
+  // refresh. |callback| is called the caller's thread as a Task
+  // after RefreshPolicyPrefs has returned.
+  void RefreshPolicyPrefs(PrefStore* managed_pref_store,
+                          PrefStore* recommended_pref_store,
+                          AfterRefreshCallback callback);
+
  private:
+  friend class PrefValueStoreTest;
+  FRIEND_TEST_ALL_PREFIXES(PrefValueStoreTest,
+                           TestRefreshPolicyPrefsCompletion);
+
   // PrefStores must be listed here in order from highest to lowest priority.
   enum PrefStoreType {
     // Not associated with an actual PrefStore but used as invalid marker, e.g.
     // as return value.
     INVALID = -1,
     MANAGED = 0,
     EXTENSION,
     COMMAND_LINE,
     USER,
     RECOMMENDED,
     PREF_STORE_TYPE_MAX = RECOMMENDED
   };
 
   scoped_ptr<PrefStore> pref_stores_[PREF_STORE_TYPE_MAX + 1];
 
   bool PrefValueInStore(const wchar_t* name, PrefStoreType type);
 
   // Returns the pref store type identifying the source that controls the
   // Preference identified by |name|. If none of the sources has a value,
   // INVALID is returned.
   PrefStoreType ControllingPrefStoreForPref(const wchar_t* name);
 
+  // Called during policy refresh after ReadPrefs completes on the thread
+  // that initiated the policy refresh.
+  void RefreshPolicyPrefsCompletion(
+      PrefStore* new_managed_pref_store,
+      PrefStore* new_recommended_pref_store,
+      AfterRefreshCallback callback);
+
+  // Called during policy refresh to do the ReadPrefs on the FILE thread.
+  void RefreshPolicyPrefsOnFileThread(
+      ChromeThread::ID calling_thread_id,
+      PrefStore* new_managed_pref_store,
+      PrefStore* new_recommended_pref_store,
+      AfterRefreshCallback callback);
+
   DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
 };
 
 #endif  // CHROME_BROWSER_PREF_VALUE_STORE_H_