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_service.h" 6 7 #include <algorithm> 8 9 #include "base/bind.h" 10 #include "base/files/file_path.h" 11 #include "base/logging.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/metrics/histogram.h" 14 #include "base/prefs/default_pref_store.h" 15 #include "base/prefs/pref_notifier_impl.h" 16 #include "base/prefs/pref_registry.h" 17 #include "base/prefs/pref_value_store.h" 18 #include "base/stl_util.h" 19 #include "base/strings/string_number_conversions.h" 20 #include "base/strings/string_util.h" 21 #include "base/value_conversions.h" 22 #include "build/build_config.h" 23 24 namespace { 25 26 class ReadErrorHandler : public PersistentPrefStore::ReadErrorDelegate { 27 public: 28 ReadErrorHandler(base::Callback<void(PersistentPrefStore::PrefReadError)> cb) 29 : callback_(cb) {} 30 31 virtual void OnError(PersistentPrefStore::PrefReadError error) OVERRIDE { 32 callback_.Run(error); 33 } 34 35 private: 36 base::Callback<void(PersistentPrefStore::PrefReadError)> callback_; 37 }; 38 39 } // namespace 40 41 PrefService::PrefService( 42 PrefNotifierImpl* pref_notifier, 43 PrefValueStore* pref_value_store, 44 PersistentPrefStore* user_prefs, 45 PrefRegistry* pref_registry, 46 base::Callback<void(PersistentPrefStore::PrefReadError)> 47 read_error_callback, 48 bool async) 49 : pref_notifier_(pref_notifier), 50 pref_value_store_(pref_value_store), 51 pref_registry_(pref_registry), 52 user_pref_store_(user_prefs), 53 read_error_callback_(read_error_callback) { 54 pref_notifier_->SetPrefService(this); 55 56 pref_registry_->SetRegistrationCallback( 57 base::Bind(&PrefService::AddRegisteredPreference, 58 base::Unretained(this))); 59 AddInitialPreferences(); 60 61 InitFromStorage(async); 62 } 63 64 PrefService::~PrefService() { 65 DCHECK(CalledOnValidThread()); 66 67 // Remove our callback, setting a NULL one. 68 pref_registry_->SetRegistrationCallback(PrefRegistry::RegistrationCallback()); 69 70 // Reset pointers so accesses after destruction reliably crash. 71 pref_value_store_.reset(); 72 pref_registry_ = NULL; 73 user_pref_store_ = NULL; 74 pref_notifier_.reset(); 75 } 76 77 void PrefService::InitFromStorage(bool async) { 78 if (!async) { 79 read_error_callback_.Run(user_pref_store_->ReadPrefs()); 80 } else { 81 // Guarantee that initialization happens after this function returned. 82 base::MessageLoop::current()->PostTask( 83 FROM_HERE, 84 base::Bind(&PersistentPrefStore::ReadPrefsAsync, 85 user_pref_store_.get(), 86 new ReadErrorHandler(read_error_callback_))); 87 } 88 } 89 90 bool PrefService::ReloadPersistentPrefs() { 91 return user_pref_store_->ReadPrefs() == 92 PersistentPrefStore::PREF_READ_ERROR_NONE; 93 } 94 95 void PrefService::CommitPendingWrite() { 96 DCHECK(CalledOnValidThread()); 97 user_pref_store_->CommitPendingWrite(); 98 } 99 100 bool PrefService::GetBoolean(const char* path) const { 101 DCHECK(CalledOnValidThread()); 102 103 bool result = false; 104 105 const base::Value* value = GetPreferenceValue(path); 106 if (!value) { 107 NOTREACHED() << "Trying to read an unregistered pref: " << path; 108 return result; 109 } 110 bool rv = value->GetAsBoolean(&result); 111 DCHECK(rv); 112 return result; 113 } 114 115 int PrefService::GetInteger(const char* path) const { 116 DCHECK(CalledOnValidThread()); 117 118 int result = 0; 119 120 const base::Value* value = GetPreferenceValue(path); 121 if (!value) { 122 NOTREACHED() << "Trying to read an unregistered pref: " << path; 123 return result; 124 } 125 bool rv = value->GetAsInteger(&result); 126 DCHECK(rv); 127 return result; 128 } 129 130 double PrefService::GetDouble(const char* path) const { 131 DCHECK(CalledOnValidThread()); 132 133 double result = 0.0; 134 135 const base::Value* value = GetPreferenceValue(path); 136 if (!value) { 137 NOTREACHED() << "Trying to read an unregistered pref: " << path; 138 return result; 139 } 140 bool rv = value->GetAsDouble(&result); 141 DCHECK(rv); 142 return result; 143 } 144 145 std::string PrefService::GetString(const char* path) const { 146 DCHECK(CalledOnValidThread()); 147 148 std::string result; 149 150 const base::Value* value = GetPreferenceValue(path); 151 if (!value) { 152 NOTREACHED() << "Trying to read an unregistered pref: " << path; 153 return result; 154 } 155 bool rv = value->GetAsString(&result); 156 DCHECK(rv); 157 return result; 158 } 159 160 base::FilePath PrefService::GetFilePath(const char* path) const { 161 DCHECK(CalledOnValidThread()); 162 163 base::FilePath result; 164 165 const base::Value* value = GetPreferenceValue(path); 166 if (!value) { 167 NOTREACHED() << "Trying to read an unregistered pref: " << path; 168 return base::FilePath(result); 169 } 170 bool rv = base::GetValueAsFilePath(*value, &result); 171 DCHECK(rv); 172 return result; 173 } 174 175 bool PrefService::HasPrefPath(const char* path) const { 176 const Preference* pref = FindPreference(path); 177 return pref && !pref->IsDefaultValue(); 178 } 179 180 base::DictionaryValue* PrefService::GetPreferenceValues() const { 181 DCHECK(CalledOnValidThread()); 182 base::DictionaryValue* out = new base::DictionaryValue; 183 PrefRegistry::const_iterator i = pref_registry_->begin(); 184 for (; i != pref_registry_->end(); ++i) { 185 const base::Value* value = GetPreferenceValue(i->first); 186 DCHECK(value); 187 out->Set(i->first, value->DeepCopy()); 188 } 189 return out; 190 } 191 192 const PrefService::Preference* PrefService::FindPreference( 193 const char* pref_name) const { 194 DCHECK(CalledOnValidThread()); 195 PreferenceMap::iterator it = prefs_map_.find(pref_name); 196 if (it != prefs_map_.end()) 197 return &(it->second); 198 const base::Value* default_value = NULL; 199 if (!pref_registry_->defaults()->GetValue(pref_name, &default_value)) 200 return NULL; 201 it = prefs_map_.insert( 202 std::make_pair(pref_name, Preference( 203 this, pref_name, default_value->GetType()))).first; 204 return &(it->second); 205 } 206 207 bool PrefService::ReadOnly() const { 208 return user_pref_store_->ReadOnly(); 209 } 210 211 PrefService::PrefInitializationStatus PrefService::GetInitializationStatus() 212 const { 213 if (!user_pref_store_->IsInitializationComplete()) 214 return INITIALIZATION_STATUS_WAITING; 215 216 switch (user_pref_store_->GetReadError()) { 217 case PersistentPrefStore::PREF_READ_ERROR_NONE: 218 return INITIALIZATION_STATUS_SUCCESS; 219 case PersistentPrefStore::PREF_READ_ERROR_NO_FILE: 220 return INITIALIZATION_STATUS_CREATED_NEW_PREF_STORE; 221 default: 222 return INITIALIZATION_STATUS_ERROR; 223 } 224 } 225 226 bool PrefService::IsManagedPreference(const char* pref_name) const { 227 const Preference* pref = FindPreference(pref_name); 228 return pref && pref->IsManaged(); 229 } 230 231 bool PrefService::IsUserModifiablePreference(const char* pref_name) const { 232 const Preference* pref = FindPreference(pref_name); 233 return pref && pref->IsUserModifiable(); 234 } 235 236 const base::DictionaryValue* PrefService::GetDictionary( 237 const char* path) const { 238 DCHECK(CalledOnValidThread()); 239 240 const base::Value* value = GetPreferenceValue(path); 241 if (!value) { 242 NOTREACHED() << "Trying to read an unregistered pref: " << path; 243 return NULL; 244 } 245 if (value->GetType() != base::Value::TYPE_DICTIONARY) { 246 NOTREACHED(); 247 return NULL; 248 } 249 return static_cast<const base::DictionaryValue*>(value); 250 } 251 252 const base::Value* PrefService::GetUserPrefValue(const char* path) const { 253 DCHECK(CalledOnValidThread()); 254 255 const Preference* pref = FindPreference(path); 256 if (!pref) { 257 NOTREACHED() << "Trying to get an unregistered pref: " << path; 258 return NULL; 259 } 260 261 // Look for an existing preference in the user store. If it doesn't 262 // exist, return NULL. 263 base::Value* value = NULL; 264 if (!user_pref_store_->GetMutableValue(path, &value)) 265 return NULL; 266 267 if (!value->IsType(pref->GetType())) { 268 NOTREACHED() << "Pref value type doesn't match registered type."; 269 return NULL; 270 } 271 272 return value; 273 } 274 275 void PrefService::SetDefaultPrefValue(const char* path, 276 base::Value* value) { 277 DCHECK(CalledOnValidThread()); 278 pref_registry_->SetDefaultPrefValue(path, value); 279 } 280 281 const base::Value* PrefService::GetDefaultPrefValue(const char* path) const { 282 DCHECK(CalledOnValidThread()); 283 // Lookup the preference in the default store. 284 const base::Value* value = NULL; 285 if (!pref_registry_->defaults()->GetValue(path, &value)) { 286 NOTREACHED() << "Default value missing for pref: " << path; 287 return NULL; 288 } 289 return value; 290 } 291 292 const base::ListValue* PrefService::GetList(const char* path) const { 293 DCHECK(CalledOnValidThread()); 294 295 const base::Value* value = GetPreferenceValue(path); 296 if (!value) { 297 NOTREACHED() << "Trying to read an unregistered pref: " << path; 298 return NULL; 299 } 300 if (value->GetType() != base::Value::TYPE_LIST) { 301 NOTREACHED(); 302 return NULL; 303 } 304 return static_cast<const base::ListValue*>(value); 305 } 306 307 void PrefService::AddPrefObserver(const char* path, PrefObserver* obs) { 308 pref_notifier_->AddPrefObserver(path, obs); 309 } 310 311 void PrefService::RemovePrefObserver(const char* path, PrefObserver* obs) { 312 pref_notifier_->RemovePrefObserver(path, obs); 313 } 314 315 void PrefService::AddPrefInitObserver(base::Callback<void(bool)> obs) { 316 pref_notifier_->AddInitObserver(obs); 317 } 318 319 PrefRegistry* PrefService::DeprecatedGetPrefRegistry() { 320 return pref_registry_.get(); 321 } 322 323 void PrefService::AddInitialPreferences() { 324 for (PrefRegistry::const_iterator it = pref_registry_->begin(); 325 it != pref_registry_->end(); 326 ++it) { 327 AddRegisteredPreference(it->first.c_str(), it->second); 328 } 329 } 330 331 // TODO(joi): Once MarkNeedsEmptyValue is gone, we can probably 332 // completely get rid of this method. There will be one difference in 333 // semantics; currently all registered preferences are stored right 334 // away in the prefs_map_, if we remove this they would be stored only 335 // opportunistically. 336 void PrefService::AddRegisteredPreference(const char* path, 337 base::Value* default_value) { 338 DCHECK(CalledOnValidThread()); 339 340 // For ListValue and DictionaryValue with non empty default, empty value 341 // for |path| needs to be persisted in |user_pref_store_|. So that 342 // non empty default is not used when user sets an empty ListValue or 343 // DictionaryValue. 344 bool needs_empty_value = false; 345 base::Value::Type orig_type = default_value->GetType(); 346 if (orig_type == base::Value::TYPE_LIST) { 347 const base::ListValue* list = NULL; 348 if (default_value->GetAsList(&list) && !list->empty()) 349 needs_empty_value = true; 350 } else if (orig_type == base::Value::TYPE_DICTIONARY) { 351 const base::DictionaryValue* dict = NULL; 352 if (default_value->GetAsDictionary(&dict) && !dict->empty()) 353 needs_empty_value = true; 354 } 355 if (needs_empty_value) 356 user_pref_store_->MarkNeedsEmptyValue(path); 357 } 358 359 void PrefService::ClearPref(const char* path) { 360 DCHECK(CalledOnValidThread()); 361 362 const Preference* pref = FindPreference(path); 363 if (!pref) { 364 NOTREACHED() << "Trying to clear an unregistered pref: " << path; 365 return; 366 } 367 user_pref_store_->RemoveValue(path); 368 } 369 370 void PrefService::Set(const char* path, const base::Value& value) { 371 SetUserPrefValue(path, value.DeepCopy()); 372 } 373 374 void PrefService::SetBoolean(const char* path, bool value) { 375 SetUserPrefValue(path, base::Value::CreateBooleanValue(value)); 376 } 377 378 void PrefService::SetInteger(const char* path, int value) { 379 SetUserPrefValue(path, base::Value::CreateIntegerValue(value)); 380 } 381 382 void PrefService::SetDouble(const char* path, double value) { 383 SetUserPrefValue(path, base::Value::CreateDoubleValue(value)); 384 } 385 386 void PrefService::SetString(const char* path, const std::string& value) { 387 SetUserPrefValue(path, base::Value::CreateStringValue(value)); 388 } 389 390 void PrefService::SetFilePath(const char* path, const base::FilePath& value) { 391 SetUserPrefValue(path, base::CreateFilePathValue(value)); 392 } 393 394 void PrefService::SetInt64(const char* path, int64 value) { 395 SetUserPrefValue(path, 396 base::Value::CreateStringValue(base::Int64ToString(value))); 397 } 398 399 int64 PrefService::GetInt64(const char* path) const { 400 DCHECK(CalledOnValidThread()); 401 402 const base::Value* value = GetPreferenceValue(path); 403 if (!value) { 404 NOTREACHED() << "Trying to read an unregistered pref: " << path; 405 return 0; 406 } 407 std::string result("0"); 408 bool rv = value->GetAsString(&result); 409 DCHECK(rv); 410 411 int64 val; 412 base::StringToInt64(result, &val); 413 return val; 414 } 415 416 void PrefService::SetUint64(const char* path, uint64 value) { 417 SetUserPrefValue(path, 418 base::Value::CreateStringValue(base::Uint64ToString(value))); 419 } 420 421 uint64 PrefService::GetUint64(const char* path) const { 422 DCHECK(CalledOnValidThread()); 423 424 const base::Value* value = GetPreferenceValue(path); 425 if (!value) { 426 NOTREACHED() << "Trying to read an unregistered pref: " << path; 427 return 0; 428 } 429 std::string result("0"); 430 bool rv = value->GetAsString(&result); 431 DCHECK(rv); 432 433 uint64 val; 434 base::StringToUint64(result, &val); 435 return val; 436 } 437 438 base::Value* PrefService::GetMutableUserPref(const char* path, 439 base::Value::Type type) { 440 CHECK(type == base::Value::TYPE_DICTIONARY || type == base::Value::TYPE_LIST); 441 DCHECK(CalledOnValidThread()); 442 443 const Preference* pref = FindPreference(path); 444 if (!pref) { 445 NOTREACHED() << "Trying to get an unregistered pref: " << path; 446 return NULL; 447 } 448 if (pref->GetType() != type) { 449 NOTREACHED() << "Wrong type for GetMutableValue: " << path; 450 return NULL; 451 } 452 453 // Look for an existing preference in the user store. If it doesn't 454 // exist or isn't the correct type, create a new user preference. 455 base::Value* value = NULL; 456 if (!user_pref_store_->GetMutableValue(path, &value) || 457 !value->IsType(type)) { 458 if (type == base::Value::TYPE_DICTIONARY) { 459 value = new base::DictionaryValue; 460 } else if (type == base::Value::TYPE_LIST) { 461 value = new base::ListValue; 462 } else { 463 NOTREACHED(); 464 } 465 user_pref_store_->SetValueSilently(path, value); 466 } 467 return value; 468 } 469 470 void PrefService::ReportUserPrefChanged(const std::string& key) { 471 user_pref_store_->ReportValueChanged(key); 472 } 473 474 void PrefService::SetUserPrefValue(const char* path, base::Value* new_value) { 475 scoped_ptr<base::Value> owned_value(new_value); 476 DCHECK(CalledOnValidThread()); 477 478 const Preference* pref = FindPreference(path); 479 if (!pref) { 480 NOTREACHED() << "Trying to write an unregistered pref: " << path; 481 return; 482 } 483 if (pref->GetType() != new_value->GetType()) { 484 NOTREACHED() << "Trying to set pref " << path 485 << " of type " << pref->GetType() 486 << " to value of type " << new_value->GetType(); 487 return; 488 } 489 490 user_pref_store_->SetValue(path, owned_value.release()); 491 } 492 493 void PrefService::UpdateCommandLinePrefStore(PrefStore* command_line_store) { 494 pref_value_store_->UpdateCommandLinePrefStore(command_line_store); 495 } 496 497 /////////////////////////////////////////////////////////////////////////////// 498 // PrefService::Preference 499 500 PrefService::Preference::Preference(const PrefService* service, 501 const char* name, 502 base::Value::Type type) 503 : name_(name), 504 type_(type), 505 pref_service_(service) { 506 DCHECK(name); 507 DCHECK(service); 508 } 509 510 const std::string PrefService::Preference::name() const { 511 return name_; 512 } 513 514 base::Value::Type PrefService::Preference::GetType() const { 515 return type_; 516 } 517 518 const base::Value* PrefService::Preference::GetValue() const { 519 const base::Value* result= pref_service_->GetPreferenceValue(name_); 520 DCHECK(result) << "Must register pref before getting its value"; 521 return result; 522 } 523 524 const base::Value* PrefService::Preference::GetRecommendedValue() const { 525 DCHECK(pref_service_->FindPreference(name_.c_str())) << 526 "Must register pref before getting its value"; 527 528 const base::Value* found_value = NULL; 529 if (pref_value_store()->GetRecommendedValue(name_, type_, &found_value)) { 530 DCHECK(found_value->IsType(type_)); 531 return found_value; 532 } 533 534 // The pref has no recommended value. 535 return NULL; 536 } 537 538 bool PrefService::Preference::IsManaged() const { 539 return pref_value_store()->PrefValueInManagedStore(name_.c_str()); 540 } 541 542 bool PrefService::Preference::IsRecommended() const { 543 return pref_value_store()->PrefValueFromRecommendedStore(name_.c_str()); 544 } 545 546 bool PrefService::Preference::HasExtensionSetting() const { 547 return pref_value_store()->PrefValueInExtensionStore(name_.c_str()); 548 } 549 550 bool PrefService::Preference::HasUserSetting() const { 551 return pref_value_store()->PrefValueInUserStore(name_.c_str()); 552 } 553 554 bool PrefService::Preference::IsExtensionControlled() const { 555 return pref_value_store()->PrefValueFromExtensionStore(name_.c_str()); 556 } 557 558 bool PrefService::Preference::IsUserControlled() const { 559 return pref_value_store()->PrefValueFromUserStore(name_.c_str()); 560 } 561 562 bool PrefService::Preference::IsDefaultValue() const { 563 return pref_value_store()->PrefValueFromDefaultStore(name_.c_str()); 564 } 565 566 bool PrefService::Preference::IsUserModifiable() const { 567 return pref_value_store()->PrefValueUserModifiable(name_.c_str()); 568 } 569 570 bool PrefService::Preference::IsExtensionModifiable() const { 571 return pref_value_store()->PrefValueExtensionModifiable(name_.c_str()); 572 } 573 574 const base::Value* PrefService::GetPreferenceValue( 575 const std::string& path) const { 576 DCHECK(CalledOnValidThread()); 577 const base::Value* default_value = NULL; 578 if (pref_registry_->defaults()->GetValue(path, &default_value)) { 579 const base::Value* found_value = NULL; 580 base::Value::Type default_type = default_value->GetType(); 581 if (pref_value_store_->GetValue(path, default_type, &found_value)) { 582 DCHECK(found_value->IsType(default_type)); 583 return found_value; 584 } else { 585 // Every registered preference has at least a default value. 586 NOTREACHED() << "no valid value found for registered pref " << path; 587 } 588 } 589 590 return NULL; 591 } 592