Introduce incognito preference settings.

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;
@@ skipping 31 matching lines @@
   //
   // The |profile| parameter is used to construct a replacement device
   // management pref store. This is done after policy refresh when we swap out
   // the policy pref stores for new ones, so the |profile| pointer needs to be
   // kept around for then. It is safe to pass a NULL pointer for local state
   // preferences.
   //
   // TODO(mnissler, danno): Refactor the pref store interface and refresh logic
   // so refreshes can be handled by the pref store itself without swapping
   // stores. This way we can get rid of the profile pointer here.
-  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,
+  PrefValueStore(scoped_refptr<PrefStore> managed_platform_prefs,
+                 scoped_refptr<PrefStore> device_management_prefs,
+                 scoped_refptr<PrefStore> extension_prefs,
+                 scoped_refptr<PrefStore> command_line_prefs,
+                 scoped_refptr<PrefStore> user_prefs,
+                 scoped_refptr<PrefStore> recommended_prefs,
+                 scoped_refptr<PrefStore> default_prefs,
                  PrefNotifier* pref_notifier,
                  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;
+  // Derives a new PrefValueStore that overrides the specified attributes.
+  PrefValueStore* Derive(scoped_refptr<PrefStore> extension_prefs,
+                         scoped_refptr<PrefStore> user_prefs,
+                         PrefNotifier* pref_notifier);
 
-  // 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;
-
-  // 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;
+  // Gets the value for the given preference name that has the specified value
+  // type. 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::ValueType type,
+                Value** out_value) const;
 
   // 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
@@ skipping 37 matching lines @@
   // 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::Observer {
    public:
     PrefStoreKeeper();
     virtual ~PrefStoreKeeper();
 
     // Takes ownership of |pref_store|.
     void Initialize(PrefValueStore* store,
-                    PrefStore* pref_store,
+                    scoped_refptr<PrefStore> pref_store,
                     PrefStoreType type);
 
-    PrefStore* store() { return pref_store_.get(); }
-    const PrefStore* store() const { return pref_store_.get(); }
+    scoped_refptr<PrefStore> store() { return pref_store_; }
+    const scoped_refptr<PrefStore> store() const { return pref_store_; }
 
    private:
     // 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_;
+    scoped_refptr<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 PrefValueStorePolicyRefreshTest;
   FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest, TestPolicyRefresh);
   FRIEND_TEST_ALL_PREFIXES(PrefValueStorePolicyRefreshTest,
                            TestRefreshPolicyPrefsCompletion);
   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
   // registered with.
   bool PrefValueInStore(const char* name, PrefStoreType store) 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,
@@ skipping 20 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(
-      policy::ConfigurationPolicyPrefStore* new_managed_platform_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_device_management_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_recommended_pref_store);
+      scoped_refptr<policy::ConfigurationPolicyPrefStore>
+          new_managed_platform_pref_store,
+      scoped_refptr<policy::ConfigurationPolicyPrefStore>
+          new_device_management_pref_store,
+      scoped_refptr<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,
-      policy::ConfigurationPolicyPrefStore* new_managed_platform_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_device_management_pref_store,
-      policy::ConfigurationPolicyPrefStore* new_recommended_pref_store);
+      scoped_refptr<policy::ConfigurationPolicyPrefStore>
+          new_managed_platform_pref_store,
+      scoped_refptr<policy::ConfigurationPolicyPrefStore>
+          new_device_management_pref_store,
+      scoped_refptr<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);
 
   // Handle the event that the store for |type| has completed initialization.
   void OnInitializationCompleted(PrefStoreType type);
 
   // Initializes a pref store keeper. Sets up a PrefStoreKeeper that will take
   // ownership of the passed |pref_store|.
-  void InitPrefStore(PrefStoreType type, PrefStore* pref_store);
+  void InitPrefStore(PrefStoreType type, scoped_refptr<PrefStore> pref_store);
 
   // Checks whether initialization is completed and tells the notifier if that
   // is the case.
   void CheckInitializationCompleted();
 
   // Get the PrefStore pointer for the given type. May return NULL if there is
   // no PrefStore for that type.
-  PrefStore* GetPrefStore(PrefStoreType type) {
+  scoped_refptr<PrefStore> GetPrefStore(PrefStoreType type) {
     return pref_stores_[type].store();
   }
-  const PrefStore* GetPrefStore(PrefStoreType type) const {
+  const scoped_refptr<PrefStore> GetPrefStore(PrefStoreType type) const {
     return pref_stores_[type].store();
   }
 
   // Keeps the PrefStore references in order of precedence.
   PrefStoreKeeper pref_stores_[PREF_STORE_TYPE_MAX + 1];
 
   // Used for generating PREF_CHANGED and PREF_INITIALIZATION_COMPLETED
   // notifications. This is a weak reference, since the notifier is owned by the
   // corresponding PrefService.
   PrefNotifier* pref_notifier_;
 
-  // A mapping of preference names to their registered types.
-  PrefTypeMap pref_types_;
-
   // The associated profile, in case this value store is associated with a
   // profile pref service. Used for recreating the device management pref store
   // 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_