1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "components/prefs/pref_value_store.h"
6
7 #include <stddef.h>
8 #include <string>
9
10 #include "base/logging.h"
11 #include "base/strings/string_piece.h"
12 #include "components/prefs/pref_notifier.h"
13 #include "components/prefs/pref_observer.h"
14
PrefStoreKeeper()15 PrefValueStore::PrefStoreKeeper::PrefStoreKeeper()
16 : pref_value_store_(nullptr), type_(PrefValueStore::INVALID_STORE) {}
17
~PrefStoreKeeper()18 PrefValueStore::PrefStoreKeeper::~PrefStoreKeeper() {
19 if (pref_store_) {
20 pref_store_->RemoveObserver(this);
21 pref_store_ = nullptr;
22 }
23 pref_value_store_ = nullptr;
24 }
25
Initialize(PrefValueStore * store,PrefStore * pref_store,PrefValueStore::PrefStoreType type)26 void PrefValueStore::PrefStoreKeeper::Initialize(
27 PrefValueStore* store,
28 PrefStore* pref_store,
29 PrefValueStore::PrefStoreType type) {
30 if (pref_store_) {
31 pref_store_->RemoveObserver(this);
32 DCHECK(!pref_store_->HasObservers());
33 }
34 type_ = type;
35 pref_value_store_ = store;
36 pref_store_ = pref_store;
37 if (pref_store_)
38 pref_store_->AddObserver(this);
39 }
40
OnPrefValueChanged(const std::string & key)41 void PrefValueStore::PrefStoreKeeper::OnPrefValueChanged(
42 const std::string& key) {
43 pref_value_store_->OnPrefValueChanged(type_, key);
44 }
45
OnInitializationCompleted(bool succeeded)46 void PrefValueStore::PrefStoreKeeper::OnInitializationCompleted(
47 bool succeeded) {
48 pref_value_store_->OnInitializationCompleted(type_, succeeded);
49 }
50
PrefValueStore(PrefStore * managed_prefs,PrefStore * supervised_user_prefs,PrefStore * extension_prefs,PrefStore * standalone_browser_prefs,PrefStore * command_line_prefs,PrefStore * user_prefs,PrefStore * recommended_prefs,PrefStore * default_prefs,PrefNotifier * pref_notifier)51 PrefValueStore::PrefValueStore(PrefStore* managed_prefs,
52 PrefStore* supervised_user_prefs,
53 PrefStore* extension_prefs,
54 PrefStore* standalone_browser_prefs,
55 PrefStore* command_line_prefs,
56 PrefStore* user_prefs,
57 PrefStore* recommended_prefs,
58 PrefStore* default_prefs,
59 PrefNotifier* pref_notifier)
60 : pref_notifier_(pref_notifier), initialization_failed_(false) {
61 InitPrefStore(MANAGED_STORE, managed_prefs);
62 InitPrefStore(SUPERVISED_USER_STORE, supervised_user_prefs);
63 InitPrefStore(EXTENSION_STORE, extension_prefs);
64 InitPrefStore(STANDALONE_BROWSER_STORE, standalone_browser_prefs);
65 InitPrefStore(COMMAND_LINE_STORE, command_line_prefs);
66 InitPrefStore(USER_STORE, user_prefs);
67 InitPrefStore(RECOMMENDED_STORE, recommended_prefs);
68 InitPrefStore(DEFAULT_STORE, default_prefs);
69
70 CheckInitializationCompleted();
71 }
72
~PrefValueStore()73 PrefValueStore::~PrefValueStore() {}
74
CloneAndSpecialize(PrefStore * managed_prefs,PrefStore * supervised_user_prefs,PrefStore * extension_prefs,PrefStore * standalone_browser_prefs,PrefStore * command_line_prefs,PrefStore * user_prefs,PrefStore * recommended_prefs,PrefStore * default_prefs,PrefNotifier * pref_notifier)75 std::unique_ptr<PrefValueStore> PrefValueStore::CloneAndSpecialize(
76 PrefStore* managed_prefs,
77 PrefStore* supervised_user_prefs,
78 PrefStore* extension_prefs,
79 PrefStore* standalone_browser_prefs,
80 PrefStore* command_line_prefs,
81 PrefStore* user_prefs,
82 PrefStore* recommended_prefs,
83 PrefStore* default_prefs,
84 PrefNotifier* pref_notifier) {
85 DCHECK(pref_notifier);
86 if (!managed_prefs)
87 managed_prefs = GetPrefStore(MANAGED_STORE);
88 if (!supervised_user_prefs)
89 supervised_user_prefs = GetPrefStore(SUPERVISED_USER_STORE);
90 if (!extension_prefs)
91 extension_prefs = GetPrefStore(EXTENSION_STORE);
92 if (!standalone_browser_prefs)
93 standalone_browser_prefs = GetPrefStore(STANDALONE_BROWSER_STORE);
94 if (!command_line_prefs)
95 command_line_prefs = GetPrefStore(COMMAND_LINE_STORE);
96 if (!user_prefs)
97 user_prefs = GetPrefStore(USER_STORE);
98 if (!recommended_prefs)
99 recommended_prefs = GetPrefStore(RECOMMENDED_STORE);
100 if (!default_prefs)
101 default_prefs = GetPrefStore(DEFAULT_STORE);
102
103 return std::make_unique<PrefValueStore>(
104 managed_prefs, supervised_user_prefs, extension_prefs,
105 standalone_browser_prefs, command_line_prefs, user_prefs,
106 recommended_prefs, default_prefs, pref_notifier);
107 }
108
GetValue(base::StringPiece name,base::Value::Type type,const base::Value ** out_value) const109 bool PrefValueStore::GetValue(base::StringPiece name,
110 base::Value::Type type,
111 const base::Value** out_value) const {
112 // Check the |PrefStore|s in order of their priority from highest to lowest,
113 // looking for the first preference value with the given |name| and |type|.
114 for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
115 if (GetValueFromStoreWithType(name, type, static_cast<PrefStoreType>(i),
116 out_value))
117 return true;
118 }
119 return false;
120 }
121
GetRecommendedValue(const std::string & name,base::Value::Type type,const base::Value ** out_value) const122 bool PrefValueStore::GetRecommendedValue(const std::string& name,
123 base::Value::Type type,
124 const base::Value** out_value) const {
125 return GetValueFromStoreWithType(name, type, RECOMMENDED_STORE, out_value);
126 }
127
NotifyPrefChanged(const std::string & path,PrefValueStore::PrefStoreType new_store)128 void PrefValueStore::NotifyPrefChanged(
129 const std::string& path,
130 PrefValueStore::PrefStoreType new_store) {
131 DCHECK(new_store != INVALID_STORE);
132 // A notification is sent when the pref value in any store changes. If this
133 // store is currently being overridden by a higher-priority store, the
134 // effective value of the pref will not have changed.
135 pref_notifier_->OnPreferenceChanged(path);
136 }
137
PrefValueInManagedStore(const std::string & name) const138 bool PrefValueStore::PrefValueInManagedStore(const std::string& name) const {
139 return PrefValueInStore(name, MANAGED_STORE);
140 }
141
PrefValueInSupervisedStore(const std::string & name) const142 bool PrefValueStore::PrefValueInSupervisedStore(const std::string& name) const {
143 return PrefValueInStore(name, SUPERVISED_USER_STORE);
144 }
145
PrefValueInExtensionStore(const std::string & name) const146 bool PrefValueStore::PrefValueInExtensionStore(const std::string& name) const {
147 return PrefValueInStore(name, EXTENSION_STORE);
148 }
149
PrefValueInUserStore(const std::string & name) const150 bool PrefValueStore::PrefValueInUserStore(const std::string& name) const {
151 return PrefValueInStore(name, USER_STORE);
152 }
153
PrefValueFromExtensionStore(const std::string & name) const154 bool PrefValueStore::PrefValueFromExtensionStore(
155 const std::string& name) const {
156 return ControllingPrefStoreForPref(name) == EXTENSION_STORE;
157 }
158
PrefValueFromUserStore(const std::string & name) const159 bool PrefValueStore::PrefValueFromUserStore(const std::string& name) const {
160 return ControllingPrefStoreForPref(name) == USER_STORE;
161 }
162
PrefValueFromRecommendedStore(const std::string & name) const163 bool PrefValueStore::PrefValueFromRecommendedStore(
164 const std::string& name) const {
165 return ControllingPrefStoreForPref(name) == RECOMMENDED_STORE;
166 }
167
PrefValueFromStandaloneBrowserStore(const std::string & name) const168 bool PrefValueStore::PrefValueFromStandaloneBrowserStore(
169 const std::string& name) const {
170 return ControllingPrefStoreForPref(name) == STANDALONE_BROWSER_STORE;
171 }
172
PrefValueFromDefaultStore(const std::string & name) const173 bool PrefValueStore::PrefValueFromDefaultStore(const std::string& name) const {
174 return ControllingPrefStoreForPref(name) == DEFAULT_STORE;
175 }
176
PrefValueUserModifiable(const std::string & name) const177 bool PrefValueStore::PrefValueUserModifiable(const std::string& name) const {
178 PrefStoreType effective_store = ControllingPrefStoreForPref(name);
179 return effective_store >= USER_STORE ||
180 effective_store == INVALID_STORE;
181 }
182
PrefValueExtensionModifiable(const std::string & name) const183 bool PrefValueStore::PrefValueExtensionModifiable(
184 const std::string& name) const {
185 PrefStoreType effective_store = ControllingPrefStoreForPref(name);
186 return effective_store >= EXTENSION_STORE ||
187 effective_store == INVALID_STORE;
188 }
189
PrefValueStandaloneBrowserModifiable(const std::string & name) const190 bool PrefValueStore::PrefValueStandaloneBrowserModifiable(
191 const std::string& name) const {
192 PrefStoreType effective_store = ControllingPrefStoreForPref(name);
193 return effective_store >= STANDALONE_BROWSER_STORE ||
194 effective_store == INVALID_STORE;
195 }
196
UpdateCommandLinePrefStore(PrefStore * command_line_prefs)197 void PrefValueStore::UpdateCommandLinePrefStore(PrefStore* command_line_prefs) {
198 InitPrefStore(COMMAND_LINE_STORE, command_line_prefs);
199 }
200
IsInitializationComplete() const201 bool PrefValueStore::IsInitializationComplete() const {
202 for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
203 const PrefStore* pref_store = GetPrefStore(static_cast<PrefStoreType>(i));
204 if (pref_store && !pref_store->IsInitializationComplete())
205 return false;
206 }
207 return true;
208 }
209
PrefValueInStore(const std::string & name,PrefValueStore::PrefStoreType store) const210 bool PrefValueStore::PrefValueInStore(
211 const std::string& name,
212 PrefValueStore::PrefStoreType store) const {
213 // Declare a temp Value* and call GetValueFromStore,
214 // ignoring the output value.
215 const base::Value* tmp_value = nullptr;
216 return GetValueFromStore(name, store, &tmp_value);
217 }
218
PrefValueInStoreRange(const std::string & name,PrefValueStore::PrefStoreType first_checked_store,PrefValueStore::PrefStoreType last_checked_store) const219 bool PrefValueStore::PrefValueInStoreRange(
220 const std::string& name,
221 PrefValueStore::PrefStoreType first_checked_store,
222 PrefValueStore::PrefStoreType last_checked_store) const {
223 if (first_checked_store > last_checked_store) {
224 NOTREACHED();
225 return false;
226 }
227
228 for (size_t i = first_checked_store;
229 i <= static_cast<size_t>(last_checked_store); ++i) {
230 if (PrefValueInStore(name, static_cast<PrefStoreType>(i)))
231 return true;
232 }
233 return false;
234 }
235
ControllingPrefStoreForPref(const std::string & name) const236 PrefValueStore::PrefStoreType PrefValueStore::ControllingPrefStoreForPref(
237 const std::string& name) const {
238 for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
239 if (PrefValueInStore(name, static_cast<PrefStoreType>(i)))
240 return static_cast<PrefStoreType>(i);
241 }
242 return INVALID_STORE;
243 }
244
GetValueFromStore(base::StringPiece name,PrefValueStore::PrefStoreType store_type,const base::Value ** out_value) const245 bool PrefValueStore::GetValueFromStore(base::StringPiece name,
246 PrefValueStore::PrefStoreType store_type,
247 const base::Value** out_value) const {
248 // Only return true if we find a value and it is the correct type, so stale
249 // values with the incorrect type will be ignored.
250 const PrefStore* store = GetPrefStore(static_cast<PrefStoreType>(store_type));
251 if (store && store->GetValue(name, out_value))
252 return true;
253
254 // No valid value found for the given preference name: set the return value
255 // to false.
256 *out_value = nullptr;
257 return false;
258 }
259
GetValueFromStoreWithType(base::StringPiece name,base::Value::Type type,PrefStoreType store,const base::Value ** out_value) const260 bool PrefValueStore::GetValueFromStoreWithType(
261 base::StringPiece name,
262 base::Value::Type type,
263 PrefStoreType store,
264 const base::Value** out_value) const {
265 if (GetValueFromStore(name, store, out_value)) {
266 if ((*out_value)->type() == type)
267 return true;
268
269 LOG(WARNING) << "Expected type for " << name << " is " << type
270 << " but got " << (*out_value)->type() << " in store "
271 << store;
272 }
273
274 *out_value = nullptr;
275 return false;
276 }
277
OnPrefValueChanged(PrefValueStore::PrefStoreType type,const std::string & key)278 void PrefValueStore::OnPrefValueChanged(PrefValueStore::PrefStoreType type,
279 const std::string& key) {
280 NotifyPrefChanged(key, type);
281 }
282
OnInitializationCompleted(PrefValueStore::PrefStoreType type,bool succeeded)283 void PrefValueStore::OnInitializationCompleted(
284 PrefValueStore::PrefStoreType type, bool succeeded) {
285 if (initialization_failed_)
286 return;
287 if (!succeeded) {
288 initialization_failed_ = true;
289 pref_notifier_->OnInitializationCompleted(false);
290 return;
291 }
292 CheckInitializationCompleted();
293 }
294
InitPrefStore(PrefValueStore::PrefStoreType type,PrefStore * pref_store)295 void PrefValueStore::InitPrefStore(PrefValueStore::PrefStoreType type,
296 PrefStore* pref_store) {
297 pref_stores_[type].Initialize(this, pref_store, type);
298 }
299
CheckInitializationCompleted()300 void PrefValueStore::CheckInitializationCompleted() {
301 if (initialization_failed_)
302 return;
303 for (size_t i = 0; i <= PREF_STORE_TYPE_MAX; ++i) {
304 scoped_refptr<PrefStore> store =
305 GetPrefStore(static_cast<PrefStoreType>(i));
306 if (store.get() && !store->IsInitializationComplete())
307 return;
308 }
309 pref_notifier_->OnInitializationCompleted(true);
310 }
311