261 lines
11 KiB
C++
261 lines
11 KiB
C++
// Copyright (c) 2012 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 BASE_PREFS_PREF_VALUE_STORE_H_
|
|
#define BASE_PREFS_PREF_VALUE_STORE_H_
|
|
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "base/basictypes.h"
|
|
#include "base/callback.h"
|
|
#include "base/gtest_prod_util.h"
|
|
#include "base/memory/ref_counted.h"
|
|
#include "base/prefs/base_prefs_export.h"
|
|
#include "base/prefs/pref_store.h"
|
|
#include "base/values.h"
|
|
|
|
class PrefNotifier;
|
|
class PrefStore;
|
|
|
|
// 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 BASE_PREFS_EXPORT PrefValueStore {
|
|
public:
|
|
typedef base::Callback<void(const std::string&)> PrefChangedCallback;
|
|
|
|
// In decreasing order of precedence:
|
|
// |managed_prefs| contains all preferences from mandatory policies.
|
|
// |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 preferences from recommended policies.
|
|
// |default_prefs| contains application-default preference values. It must
|
|
// be non-null if any preferences are to be registered.
|
|
//
|
|
// |pref_notifier| facilitates broadcasting preference change notifications
|
|
// to the world.
|
|
PrefValueStore(PrefStore* managed_prefs,
|
|
PrefStore* extension_prefs,
|
|
PrefStore* command_line_prefs,
|
|
PrefStore* user_prefs,
|
|
PrefStore* recommended_prefs,
|
|
PrefStore* default_prefs,
|
|
PrefNotifier* pref_notifier);
|
|
virtual ~PrefValueStore();
|
|
|
|
// Creates a clone of this PrefValueStore with PrefStores overwritten
|
|
// by the parameters passed, if unequal NULL.
|
|
PrefValueStore* CloneAndSpecialize(PrefStore* managed_prefs,
|
|
PrefStore* extension_prefs,
|
|
PrefStore* command_line_prefs,
|
|
PrefStore* user_prefs,
|
|
PrefStore* recommended_prefs,
|
|
PrefStore* default_prefs,
|
|
PrefNotifier* pref_notifier);
|
|
|
|
// A PrefValueStore can have exactly one callback that is directly
|
|
// notified of preferences changing in the store. This does not
|
|
// filter through the PrefNotifier mechanism, which may not forward
|
|
// certain changes (e.g. unregistered prefs).
|
|
void set_callback(const PrefChangedCallback& callback);
|
|
|
|
// Gets the value for the given preference name that has the specified value
|
|
// type. Values stored in a PrefStore that have the matching |name| but
|
|
// a non-matching |type| are silently skipped. 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,
|
|
base::Value::Type type,
|
|
const base::Value** out_value) const;
|
|
|
|
// Gets the recommended value for the given preference name that has the
|
|
// specified value type. A value stored in the recommended PrefStore that has
|
|
// the matching |name| but a non-matching |type| is silently ignored. Returns
|
|
// true if a valid value was found. Most callers should use
|
|
// Preference::GetRecommendedValue() instead of calling this method directly.
|
|
bool GetRecommendedValue(const std::string& name,
|
|
base::Value::Type type,
|
|
const base::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 PrefValueInManagedStore(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 PrefValueFromRecommendedStore(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;
|
|
|
|
// Check whether a Preference value is modifiable by an extension, i.e.
|
|
// whether there is no higher-priority source controlling it.
|
|
bool PrefValueExtensionModifiable(const char* name) const;
|
|
|
|
// Update the command line PrefStore with |command_line_prefs|.
|
|
void UpdateCommandLinePrefStore(PrefStore* command_line_prefs);
|
|
|
|
private:
|
|
// PrefStores must be listed here in order from highest to lowest priority.
|
|
// MANAGED contains all managed preference values that are provided by
|
|
// mandatory policies (e.g. Windows Group Policy or 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.
|
|
// RECOMMENDED contains all preferences that are provided by recommended
|
|
// policies.
|
|
// DEFAULT contains all application default preference values.
|
|
enum PrefStoreType {
|
|
// INVALID_STORE is not associated with an actual PrefStore but used as
|
|
// an invalid marker, e.g. as a return value.
|
|
INVALID_STORE = -1,
|
|
MANAGED_STORE = 0,
|
|
EXTENSION_STORE,
|
|
COMMAND_LINE_STORE,
|
|
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::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::Observer implementation.
|
|
virtual void OnPrefValueChanged(const std::string& key) OVERRIDE;
|
|
virtual void OnInitializationCompleted(bool succeeded) OVERRIDE;
|
|
|
|
// PrefValueStore this keeper is part of.
|
|
PrefValueStore* pref_value_store_;
|
|
|
|
// The PrefStore managed by this keeper.
|
|
scoped_refptr<PrefStore> pref_store_;
|
|
|
|
// Type of the pref store.
|
|
PrefStoreType type_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(PrefStoreKeeper);
|
|
};
|
|
|
|
typedef std::map<std::string, base::Value::Type> 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 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,
|
|
PrefStoreType first_checked_store,
|
|
PrefStoreType last_checked_store) const;
|
|
|
|
// Returns the pref store type identifying the source that controls the
|
|
// Preference identified by |name|. If none of the sources has a value,
|
|
// INVALID_STORE is returned. In practice, the default PrefStore
|
|
// should always have a value for any registered preferencem, so INVALID_STORE
|
|
// indicates an error.
|
|
PrefStoreType ControllingPrefStoreForPref(const char* name) const;
|
|
|
|
// Get a value from the specified |store|.
|
|
bool GetValueFromStore(const char* name,
|
|
PrefStoreType store,
|
|
const base::Value** out_value) const;
|
|
|
|
// Get a value from the specified |store| if its |type| matches.
|
|
bool GetValueFromStoreWithType(const char* name,
|
|
base::Value::Type type,
|
|
PrefStoreType store,
|
|
const base::Value** out_value) const;
|
|
|
|
// Called upon changes in individual pref stores in order to determine whether
|
|
// the user-visible pref value has changed. Triggers the change notification
|
|
// if the effective value of the preference has changed, or if the store
|
|
// controlling the pref has changed.
|
|
void NotifyPrefChanged(const char* path, PrefStoreType new_store);
|
|
|
|
// 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, bool succeeded);
|
|
|
|
// 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);
|
|
|
|
// 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) {
|
|
return pref_stores_[type].store();
|
|
}
|
|
const 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];
|
|
|
|
PrefChangedCallback pref_changed_callback_;
|
|
|
|
// Used for generating 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_;
|
|
|
|
// True if not all of the PrefStores were initialized successfully.
|
|
bool initialization_failed_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(PrefValueStore);
|
|
};
|
|
|
|
#endif // BASE_PREFS_PREF_VALUE_STORE_H_
|