Create additional PrefStore for Device Management policy.

chrome/browser/prefs/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_PREFS_PREF_VALUE_STORE_H_
 #define CHROME_BROWSER_PREFS_PREF_VALUE_STORE_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 77 matching lines @@
   bool HasPrefPath(const char* name) const;
 
   // Called by the PrefNotifier when the value of the preference at |path| has
   // changed, been added, or been removed in one of the PrefStores. The
   // |new_store| is the PrefStoreType of the caller. Returns true if the
   // effective value of the preference has changed, or if the store controlling
   // the pref has changed. Virtual so it can be mocked for a unit test.
   virtual bool PrefHasChanged(const char* path,
                               PrefNotifier::PrefStoreType new_store);
 
-  // Returns true if the PrefValueStore is read-only.
-  // Because the managed and recommended PrefStores are always read-only, the
-  // PrefValueStore as a whole is read-only if the PrefStore containing the user
-  // preferences is read-only.
+  // Returns true if the PrefValueStore is read-only.  Because the managed
+  // platform, device management and recommended PrefStores are always
+  // read-only, the PrefValueStore as a whole is read-only if the PrefStore
+  // containing the user preferences is read-only.
   bool ReadOnly();
 
   // Alters the user-defined value of a preference. Even if the preference is
   // managed this method allows the user-defined value of the preference to be
   // set. But GetValue calls will not return this value as long as the
   // preference is managed. Instead GetValue will return the managed value
   // of the preference. Note that the PrefValueStore takes the ownership of
   // the value referenced by |in_value|. It is an error to call this when no
   // user PrefStore has been set. Returns true if the user-set value of the
   // preference was newly added or changed.
   bool SetUserPrefValue(const char* name, Value* in_value);
 
   // Removes a value from the user PrefStore. If a preference is managed
   // this function should have no visible effect. Returns true if there was a
   // user-set value to be removed.
   bool RemoveUserPrefValue(const char* name);
 
   // Sets a value in the DefaultPrefStore, which takes ownership of the Value.
   void SetDefaultPrefValue(const char* name, Value* in_value);
 
   // These methods return true if a preference with the given name is in the
   // indicated pref store, even if that value is currently being overridden by
   // a higher-priority source.
-  bool PrefValueInManagedStore(const char* name) const;
+  bool PrefValueInManagedPlatformStore(const char* name) const;
+  bool PrefValueInDeviceManagementStore(const char* name) const;
   bool PrefValueInExtensionStore(const char* name) const;
   bool PrefValueInUserStore(const char* name) const;
 
   // Returns true if a preference has an explicit value in any of the
   // stores in the range specified by |first_checked_store| and
   // |last_checked_store|, even if that value is currently being
   // overridden by a higher-priority store.
   bool PrefValueInStoreRange(const char* name,
                              PrefNotifier::PrefStoreType first_checked_store,
                              PrefNotifier::PrefStoreType last_checked_store);
@@ skipping 15 matching lines @@
   // should always have a value for any registered preferencem, so INVALID_STORE
   // indicates an error.
   PrefNotifier::PrefStoreType ControllingPrefStoreForPref(
       const char* name) const;
 
   // 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 from a Task on the FILE
-  // thread. The Task will take ownership of the |callback|. |callback| is
-  // called with the set of preferences changed by the policy refresh.
-  // |callback| is called on the caller's thread as a Task after
-  // RefreshPolicyPrefs has returned.
+  // Called as a result of a notification of policy change. Triggers a reload of
+  // managed platform, device management and recommended preferences from policy
+  // from a Task on the FILE thread. The Task will take ownership of the
+  // |callback|. |callback| is called with the set of preferences changed by the
+  // policy refresh. |callback| is called on the caller's thread as a Task
+  // after RefreshPolicyPrefs has returned.
   void RefreshPolicyPrefs(AfterRefreshCallback* callback);
 
   // Returns true if there are proxy preferences in user-modifiable
   // preference stores (e.g. CommandLinePrefStore, ExtensionPrefStore)
   // that conflict with proxy settings specified by proxy policy.
   bool HasPolicyConflictingUserProxySettings();
 
       protected:
   // In decreasing order of precedence:
-  //   |managed_prefs| contains all managed (policy) preference values.
+  //   |managed_platform_prefs| contains all managed platform (non-cloud policy)
+  //        preference values.
+  //   |device_management_prefs| contains all device management (cloud 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.
   //   |default_prefs| contains application-default preference values. It must
   //        be non-null if any preferences are to be registered.
   //
   // This constructor should only be used internally, or by subclasses in
   // testing. The usual way to create a PrefValueStore is by creating a
   // PrefService.
-  PrefValueStore(PrefStore* managed_prefs,
+  PrefValueStore(PrefStore* managed_platform_prefs,
+                 PrefStore* device_management_prefs,
                  PrefStore* extension_prefs,
                  PrefStore* command_line_prefs,
                  PrefStore* user_prefs,
                  PrefStore* recommended_prefs,
                  PrefStore* default_prefs);
 
  private:
   friend class PrefValueStoreTest;
   FRIEND_TEST_ALL_PREFIXES(PrefValueStoreTest,
                            TestRefreshPolicyPrefsCompletion);
@@ skipping 12 matching lines @@
 
   // Get a value from the specified store type.
   bool GetValueFromStore(const char* name,
                          PrefNotifier::PrefStoreType store,
                          Value** out_value) const;
 
   // Called during policy refresh after ReadPrefs completes on the thread
   // that initiated the policy refresh. RefreshPolicyPrefsCompletion takes
   // ownership of the |callback| object.
   void RefreshPolicyPrefsCompletion(
-      PrefStore* new_managed_pref_store,
+      PrefStore* new_managed_platform_pref_store,
+      PrefStore* new_device_management_pref_store,
       PrefStore* new_recommended_pref_store,
       AfterRefreshCallback* callback);
 
   // Called during policy refresh to do the ReadPrefs on the FILE thread.
   // RefreshPolicyPrefsOnFileThread takes ownership of the |callback| object.
   void RefreshPolicyPrefsOnFileThread(
       BrowserThread::ID calling_thread_id,
-      PrefStore* new_managed_pref_store,
+      PrefStore* new_managed_platform_pref_store,
+      PrefStore* new_device_management_pref_store,
       PrefStore* new_recommended_pref_store,
       AfterRefreshCallback* callback);
 
   DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_VALUE_STORE_H_