base/prefs/pref_service.cc

   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   InitFromStorage(async);
  57 }
  58
  59 PrefService::~PrefService() {
  60   DCHECK(CalledOnValidThread());
  61
  62   // Reset pointers so accesses after destruction reliably crash.
  63   pref_value_store_.reset();
  64   pref_registry_ = NULL;
  65   user_pref_store_ = NULL;
  66   pref_notifier_.reset();
  67 }
  68
  69 void PrefService::InitFromStorage(bool async) {
  70   if (!async) {
  71     read_error_callback_.Run(user_pref_store_->ReadPrefs());
  72   } else {
  73     // Guarantee that initialization happens after this function returned.
  74     base::MessageLoop::current()->PostTask(
  75         FROM_HERE,
  76         base::Bind(&PersistentPrefStore::ReadPrefsAsync,
  77                    user_pref_store_.get(),
  78                    new ReadErrorHandler(read_error_callback_)));
  79   }
  80 }
  81
  82 void PrefService::CommitPendingWrite() {
  83   DCHECK(CalledOnValidThread());
  84   user_pref_store_->CommitPendingWrite();
  85 }
  86
  87 bool PrefService::GetBoolean(const char* path) const {
  88   DCHECK(CalledOnValidThread());
  89
  90   bool result = false;
  91
  92   const base::Value* value = GetPreferenceValue(path);
  93   if (!value) {
  94     NOTREACHED() << "Trying to read an unregistered pref: " << path;
  95     return result;
  96   }
  97   bool rv = value->GetAsBoolean(&result);
  98   DCHECK(rv);
  99   return result;
 100 }
 101
 102 int PrefService::GetInteger(const char* path) const {
 103   DCHECK(CalledOnValidThread());
 104
 105   int result = 0;
 106
 107   const base::Value* value = GetPreferenceValue(path);
 108   if (!value) {
 109     NOTREACHED() << "Trying to read an unregistered pref: " << path;
 110     return result;
 111   }
 112   bool rv = value->GetAsInteger(&result);
 113   DCHECK(rv);
 114   return result;
 115 }
 116
 117 double PrefService::GetDouble(const char* path) const {
 118   DCHECK(CalledOnValidThread());
 119
 120   double result = 0.0;
 121
 122   const base::Value* value = GetPreferenceValue(path);
 123   if (!value) {
 124     NOTREACHED() << "Trying to read an unregistered pref: " << path;
 125     return result;
 126   }
 127   bool rv = value->GetAsDouble(&result);
 128   DCHECK(rv);
 129   return result;
 130 }
 131
 132 std::string PrefService::GetString(const char* path) const {
 133   DCHECK(CalledOnValidThread());
 134
 135   std::string result;
 136
 137   const base::Value* value = GetPreferenceValue(path);
 138   if (!value) {
 139     NOTREACHED() << "Trying to read an unregistered pref: " << path;
 140     return result;
 141   }
 142   bool rv = value->GetAsString(&result);
 143   DCHECK(rv);
 144   return result;
 145 }
 146
 147 base::FilePath PrefService::GetFilePath(const char* path) const {
 148   DCHECK(CalledOnValidThread());
 149
 150   base::FilePath result;
 151
 152   const base::Value* value = GetPreferenceValue(path);
 153   if (!value) {
 154     NOTREACHED() << "Trying to read an unregistered pref: " << path;
 155     return base::FilePath(result);
 156   }
 157   bool rv = base::GetValueAsFilePath(*value, &result);
 158   DCHECK(rv);
 159   return result;
 160 }
 161
 162 bool PrefService::HasPrefPath(const char* path) const {
 163   const Preference* pref = FindPreference(path);
 164   return pref && !pref->IsDefaultValue();
 165 }
 166
 167 scoped_ptr<base::DictionaryValue> PrefService::GetPreferenceValues() const {
 168   DCHECK(CalledOnValidThread());
 169   scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
 170   PrefRegistry::const_iterator i = pref_registry_->begin();
 171   for (; i != pref_registry_->end(); ++i) {
 172     const base::Value* value = GetPreferenceValue(i->first);
 173     DCHECK(value);
 174     out->Set(i->first, value->DeepCopy());
 175   }
 176   return out.Pass();
 177 }
 178
 179 scoped_ptr<base::DictionaryValue>
 180 PrefService::GetPreferenceValuesWithoutPathExpansion() const {
 181   DCHECK(CalledOnValidThread());
 182   scoped_ptr<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->SetWithoutPathExpansion(i->first, value->DeepCopy());
 188   }
 189   return out.Pass();
 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::ClearPref(const char* path) {
 324   DCHECK(CalledOnValidThread());
 325
 326   const Preference* pref = FindPreference(path);
 327   if (!pref) {
 328     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
 329     return;
 330   }
 331   user_pref_store_->RemoveValue(path);
 332 }
 333
 334 void PrefService::Set(const char* path, const base::Value& value) {
 335   SetUserPrefValue(path, value.DeepCopy());
 336 }
 337
 338 void PrefService::SetBoolean(const char* path, bool value) {
 339   SetUserPrefValue(path, base::Value::CreateBooleanValue(value));
 340 }
 341
 342 void PrefService::SetInteger(const char* path, int value) {
 343   SetUserPrefValue(path, base::Value::CreateIntegerValue(value));
 344 }
 345
 346 void PrefService::SetDouble(const char* path, double value) {
 347   SetUserPrefValue(path, base::Value::CreateDoubleValue(value));
 348 }
 349
 350 void PrefService::SetString(const char* path, const std::string& value) {
 351   SetUserPrefValue(path, base::Value::CreateStringValue(value));
 352 }
 353
 354 void PrefService::SetFilePath(const char* path, const base::FilePath& value) {
 355   SetUserPrefValue(path, base::CreateFilePathValue(value));
 356 }
 357
 358 void PrefService::SetInt64(const char* path, int64 value) {
 359   SetUserPrefValue(path,
 360                    base::Value::CreateStringValue(base::Int64ToString(value)));
 361 }
 362
 363 int64 PrefService::GetInt64(const char* path) const {
 364   DCHECK(CalledOnValidThread());
 365
 366   const base::Value* value = GetPreferenceValue(path);
 367   if (!value) {
 368     NOTREACHED() << "Trying to read an unregistered pref: " << path;
 369     return 0;
 370   }
 371   std::string result("0");
 372   bool rv = value->GetAsString(&result);
 373   DCHECK(rv);
 374
 375   int64 val;
 376   base::StringToInt64(result, &val);
 377   return val;
 378 }
 379
 380 void PrefService::SetUint64(const char* path, uint64 value) {
 381   SetUserPrefValue(path,
 382                    base::Value::CreateStringValue(base::Uint64ToString(value)));
 383 }
 384
 385 uint64 PrefService::GetUint64(const char* path) const {
 386   DCHECK(CalledOnValidThread());
 387
 388   const base::Value* value = GetPreferenceValue(path);
 389   if (!value) {
 390     NOTREACHED() << "Trying to read an unregistered pref: " << path;
 391     return 0;
 392   }
 393   std::string result("0");
 394   bool rv = value->GetAsString(&result);
 395   DCHECK(rv);
 396
 397   uint64 val;
 398   base::StringToUint64(result, &val);
 399   return val;
 400 }
 401
 402 base::Value* PrefService::GetMutableUserPref(const char* path,
 403                                              base::Value::Type type) {
 404   CHECK(type == base::Value::TYPE_DICTIONARY || type == base::Value::TYPE_LIST);
 405   DCHECK(CalledOnValidThread());
 406
 407   const Preference* pref = FindPreference(path);
 408   if (!pref) {
 409     NOTREACHED() << "Trying to get an unregistered pref: " << path;
 410     return NULL;
 411   }
 412   if (pref->GetType() != type) {
 413     NOTREACHED() << "Wrong type for GetMutableValue: " << path;
 414     return NULL;
 415   }
 416
 417   // Look for an existing preference in the user store. If it doesn't
 418   // exist or isn't the correct type, create a new user preference.
 419   base::Value* value = NULL;
 420   if (!user_pref_store_->GetMutableValue(path, &value) ||
 421       !value->IsType(type)) {
 422     if (type == base::Value::TYPE_DICTIONARY) {
 423       value = new base::DictionaryValue;
 424     } else if (type == base::Value::TYPE_LIST) {
 425       value = new base::ListValue;
 426     } else {
 427       NOTREACHED();
 428     }
 429     user_pref_store_->SetValueSilently(path, value);
 430   }
 431   return value;
 432 }
 433
 434 void PrefService::ReportUserPrefChanged(const std::string& key) {
 435   user_pref_store_->ReportValueChanged(key);
 436 }
 437
 438 void PrefService::SetUserPrefValue(const char* path, base::Value* new_value) {
 439   scoped_ptr<base::Value> owned_value(new_value);
 440   DCHECK(CalledOnValidThread());
 441
 442   const Preference* pref = FindPreference(path);
 443   if (!pref) {
 444     NOTREACHED() << "Trying to write an unregistered pref: " << path;
 445     return;
 446   }
 447   if (pref->GetType() != new_value->GetType()) {
 448     NOTREACHED() << "Trying to set pref " << path
 449                  << " of type " << pref->GetType()
 450                  << " to value of type " << new_value->GetType();
 451     return;
 452   }
 453
 454   user_pref_store_->SetValue(path, owned_value.release());
 455 }
 456
 457 void PrefService::UpdateCommandLinePrefStore(PrefStore* command_line_store) {
 458   pref_value_store_->UpdateCommandLinePrefStore(command_line_store);
 459 }
 460
 461 ///////////////////////////////////////////////////////////////////////////////
 462 // PrefService::Preference
 463
 464 PrefService::Preference::Preference(const PrefService* service,
 465                                     const char* name,
 466                                     base::Value::Type type)
 467       : name_(name),
 468         type_(type),
 469         pref_service_(service) {
 470   DCHECK(name);
 471   DCHECK(service);
 472 }
 473
 474 const std::string PrefService::Preference::name() const {
 475   return name_;
 476 }
 477
 478 base::Value::Type PrefService::Preference::GetType() const {
 479   return type_;
 480 }
 481
 482 const base::Value* PrefService::Preference::GetValue() const {
 483   const base::Value* result= pref_service_->GetPreferenceValue(name_);
 484   DCHECK(result) << "Must register pref before getting its value";
 485   return result;
 486 }
 487
 488 const base::Value* PrefService::Preference::GetRecommendedValue() const {
 489   DCHECK(pref_service_->FindPreference(name_.c_str())) <<
 490       "Must register pref before getting its value";
 491
 492   const base::Value* found_value = NULL;
 493   if (pref_value_store()->GetRecommendedValue(name_, type_, &found_value)) {
 494     DCHECK(found_value->IsType(type_));
 495     return found_value;
 496   }
 497
 498   // The pref has no recommended value.
 499   return NULL;
 500 }
 501
 502 bool PrefService::Preference::IsManaged() const {
 503   return pref_value_store()->PrefValueInManagedStore(name_.c_str());
 504 }
 505
 506 bool PrefService::Preference::IsRecommended() const {
 507   return pref_value_store()->PrefValueFromRecommendedStore(name_.c_str());
 508 }
 509
 510 bool PrefService::Preference::HasExtensionSetting() const {
 511   return pref_value_store()->PrefValueInExtensionStore(name_.c_str());
 512 }
 513
 514 bool PrefService::Preference::HasUserSetting() const {
 515   return pref_value_store()->PrefValueInUserStore(name_.c_str());
 516 }
 517
 518 bool PrefService::Preference::IsExtensionControlled() const {
 519   return pref_value_store()->PrefValueFromExtensionStore(name_.c_str());
 520 }
 521
 522 bool PrefService::Preference::IsUserControlled() const {
 523   return pref_value_store()->PrefValueFromUserStore(name_.c_str());
 524 }
 525
 526 bool PrefService::Preference::IsDefaultValue() const {
 527   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
 528 }
 529
 530 bool PrefService::Preference::IsUserModifiable() const {
 531   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
 532 }
 533
 534 bool PrefService::Preference::IsExtensionModifiable() const {
 535   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
 536 }
 537
 538 const base::Value* PrefService::GetPreferenceValue(
 539     const std::string& path) const {
 540   DCHECK(CalledOnValidThread());
 541   const base::Value* default_value = NULL;
 542   if (pref_registry_->defaults()->GetValue(path, &default_value)) {
 543     const base::Value* found_value = NULL;
 544     base::Value::Type default_type = default_value->GetType();
 545     if (pref_value_store_->GetValue(path, default_type, &found_value)) {
 546       DCHECK(found_value->IsType(default_type));
 547       return found_value;
 548     } else {
 549       // Every registered preference has at least a default value.
 550       NOTREACHED() << "no valid value found for registered pref " << path;
 551     }
 552   }
 553
 554   return NULL;
 555 }