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