Sanitize PrefStore interface.

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>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/pref_store.h"
 
 class FilePath;
 class PrefNotifier;
 class PrefStore;
 class Profile;
 
+// TODO(danno, mnissler): Remove after policy refresh cleanup.
+namespace policy {
+class ConfigurationPolicyPrefStore;
+}
+
 // The PrefValueStore manages various sources of values for Preferences
 // (e.g., configuration policies, extensions, and user settings). It returns
 // the value of a Preference from the source with the highest priority, and
 // allows setting user-defined values for preferences that are not managed.
 //
 // 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 NotificationObserver {
  public:
@@ skipping 33 matching lines @@
                  Profile* profile);
   virtual ~PrefValueStore();
 
   // Gets the value for the given preference name that has a valid value type;
   // that is, the same type the preference was registered with, or NULL for
   // default values of Dictionaries and Lists. Returns true if a valid value
   // was found in any of the available PrefStores. Most callers should use
   // Preference::GetValue() instead of calling this method directly.
   bool GetValue(const std::string& name, Value** out_value) const;
 
-  // Same as GetValue but only searches the user store.
-  bool GetUserValue(const std::string& name, Value** out_value) const;
-
   // Adds a preference to the mapping of names to types.
   void RegisterPreferenceType(const std::string& name, Value::ValueType type);
 
   // Gets the registered value type for the given preference name. Returns
   // Value::TYPE_NULL if the preference has never been registered.
   Value::ValueType GetRegisteredType(const std::string& name) const;
 
-  // Read preference values into the three PrefStores so that they are available
-  // through the GetValue method. Return the first error that occurs (but
-  // continue reading the remaining PrefStores).
-  PrefStore::PrefReadError ReadPrefs();
-
-  // Persists prefs (to disk or elsewhere). Returns true if writing values was
-  // successful. In practice, only the user prefs are expected to be written
-  // out.
-  // TODO(mnissler, danno): Handle writes through PrefService and remove.
-  bool WritePrefs();
-
-  // Calls the method ScheduleWritePrefs on the PrefStores. In practice, only
-  // the user prefs are expected to be written out.
-  // TODO(mnissler, danno): Handle writes through PrefService and remove.
-  void ScheduleWritePrefs();
-
   // Returns true if the PrefValueStore contains the given preference (i.e.,
   // it's been registered), and a value with the correct type has been actively
   // set in some pref store. The application default specified when the pref was
   // registered does not count as an "actively set" value, but another pref
   // store setting a value that happens to be equal to the default does.
   bool HasPrefPath(const char* name) const;
 
-  // 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() const;
-
-  // 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. However, GetValue calls will not return this value as long as the
-  // preference is overriden by a store of higher precedence. 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. Triggers
-  // notifications if the user-visible value changes.
-  // TODO(mnissler, danno): Handle writes in PrefService and notifications in
-  // the pref store implementation, so we can remove this call.
-  void SetUserPrefValue(const char* name, Value* in_value);
-
-  // Like SetUserPrefValue, but silently puts the value without triggering
-  // notifications.
-  // TODO(mnissler, danno): Handle writes in PrefService and notifications in
-  // the pref store implementation, so we can remove this call.
-  void SetUserPrefValueSilently(const char* name, Value* in_value);
-
-  // Removes a value from the user PrefStore. If a preference is overriden by a
-  // store of higher precedence, this function will have no immediately visible
-  // effect. Triggers notifications if the user-visible value changes.
-  // TODO(mnissler, danno): Handle writes in PrefService and notifications in
-  // the pref store implementation, so we can remove this call.
-  void RemoveUserPrefValue(const char* name);
-
   // 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 PrefValueInManagedPlatformStore(const char* name) const;
   bool PrefValueInDeviceManagementStore(const char* name) const;
   bool PrefValueInExtensionStore(const char* name) const;
   bool PrefValueInUserStore(const char* name) const;
 
   // 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 char* name) const;
   bool PrefValueFromUserStore(const char* name) const;
   bool PrefValueFromDefaultStore(const char* name) const;
 
   // Check whether a Preference value is modifiable by the user, i.e. whether
   // there is no higher-priority source controlling it.
   bool PrefValueUserModifiable(const char* name) const;
 
-  // 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() const;
-
  private:
   // PrefStores must be listed here in order from highest to lowest priority.
   //   MANAGED_PLATFORM contains all managed preference values that are
   //       provided by a platform-specific policy mechanism (e.g. Windows
   //       Group Policy).
   //   DEVICE_MANAGEMENT contains all managed preference values supplied
   //       by the device management server (cloud policy).
   //   EXTENSION contains preference values set by extensions.
   //   COMMAND_LINE contains preference values set by command-line switches.
   //   USER contains all user-set preference values.
@@ skipping 10 matching lines @@
     USER_STORE,
     RECOMMENDED_STORE,
     DEFAULT_STORE,
     PREF_STORE_TYPE_MAX = DEFAULT_STORE
   };
 
   // Keeps a PrefStore reference on behalf of the PrefValueStore and monitors
   // the PrefStore for changes, forwarding notifications to PrefValueStore. This
   // indirection is here for the sake of disambiguating notifications from the
   // individual PrefStores.
-  class PrefStoreKeeper : public PrefStore::ObserverInterface {
+  class PrefStoreKeeper : public PrefStore::Observer {
    public:
     PrefStoreKeeper();
     virtual ~PrefStoreKeeper();
 
     // Takes ownership of |pref_store|.
     void Initialize(PrefValueStore* store,
                     PrefStore* pref_store,
                     PrefStoreType type);
 
     PrefStore* store() { return pref_store_.get(); }
     const PrefStore* store() const { return pref_store_.get(); }
 
    private:
-    // PrefStore::ObserverInterface implementation.
+    // PrefStore::Observer implementation.
     virtual void OnPrefValueChanged(const std::string& key);
     virtual void OnInitializationCompleted();
 
     // PrefValueStore this keeper is part of.
     PrefValueStore* pref_value_store_;
 
     // The PrefStore managed by this keeper.
     scoped_ptr<PrefStore> pref_store_;
 
     // Type of the pref store.
     PrefStoreType type_;
 
     DISALLOW_COPY_AND_ASSIGN(PrefStoreKeeper);
   };
 
   typedef std::map<std::string, Value::ValueType> PrefTypeMap;
 
-  friend class PrefValueStoreTest;
-  FRIEND_TEST_ALL_PREFIXES(PrefValueStoreTest, TestPolicyRefresh);
-  FRIEND_TEST_ALL_PREFIXES(PrefValueStoreTest,
+  friend class PrefValueStorePolicyRefreshTest;
+  FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest, TestPolicyRefresh);
+  FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest,
                            TestRefreshPolicyPrefsCompletion);
-  FRIEND_TEST_ALL_PREFIXES(PrefValueStoreTest,
+  FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest,
                            TestConcurrentPolicyRefresh);
 
   // Returns true if the actual type is a valid type for the expected type when
   // found in the given store.
   static bool IsValidType(Value::ValueType expected,
                           Value::ValueType actual,
                           PrefStoreType store);
 
   // Returns true if the preference with the given name has a value in the
   // given PrefStoreType, of the same value type as the preference was
@@ skipping 28 matching lines @@
 
   // 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.
   void RefreshPolicyPrefs();
 
   // 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_platform_pref_store,
-      PrefStore* new_device_management_pref_store,
-      PrefStore* new_recommended_pref_store);
+      policy::ConfigurationPolicyPrefStore* new_managed_platform_pref_store,
+      policy::ConfigurationPolicyPrefStore* new_device_management_pref_store,
+      policy::ConfigurationPolicyPrefStore* new_recommended_pref_store);
 
   // 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_platform_pref_store,
-      PrefStore* new_device_management_pref_store,
-      PrefStore* new_recommended_pref_store);
+      policy::ConfigurationPolicyPrefStore* new_managed_platform_pref_store,
+      policy::ConfigurationPolicyPrefStore* new_device_management_pref_store,
+      policy::ConfigurationPolicyPrefStore* new_recommended_pref_store);
 
   // NotificationObserver methods:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Called from the PrefStoreKeeper implementation when a pref value for |key|
   // changed in the pref store for |type|.
   void OnPrefValueChanged(PrefStoreType type, const std::string& key);
 
@@ skipping 33 matching lines @@
   // upon policy refresh.
   Profile* profile_;
 
   // TODO(mnissler): Remove this after cleaning up policy refresh handling.
   NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_VALUE_STORE_H_