Home | History | Annotate | Download | only in prefs 
      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 (user_pref_store_->IsInitializationComplete()) {
     71     read_error_callback_.Run(user_pref_store_->GetReadError());
     72   } else if (!async) {
     73     read_error_callback_.Run(user_pref_store_->ReadPrefs());
     74   } else {
     75     // Guarantee that initialization happens after this function returned.
     76     base::MessageLoop::current()->PostTask(
     77         FROM_HERE,
     78         base::Bind(&PersistentPrefStore::ReadPrefsAsync,
     79                    user_pref_store_.get(),
     80                    new ReadErrorHandler(read_error_callback_)));
     81   }
     82 }
     83 
     84 void PrefService::CommitPendingWrite() {
     85   DCHECK(CalledOnValidThread());
     86   user_pref_store_->CommitPendingWrite();
     87 }
     88 
     89 bool PrefService::GetBoolean(const char* path) const {
     90   DCHECK(CalledOnValidThread());
     91 
     92   bool result = false;
     93 
     94   const base::Value* value = GetPreferenceValue(path);
     95   if (!value) {
     96     NOTREACHED() << "Trying to read an unregistered pref: " << path;
     97     return result;
     98   }
     99   bool rv = value->GetAsBoolean(&result);
    100   DCHECK(rv);
    101   return result;
    102 }
    103 
    104 int PrefService::GetInteger(const char* path) const {
    105   DCHECK(CalledOnValidThread());
    106 
    107   int result = 0;
    108 
    109   const base::Value* value = GetPreferenceValue(path);
    110   if (!value) {
    111     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    112     return result;
    113   }
    114   bool rv = value->GetAsInteger(&result);
    115   DCHECK(rv);
    116   return result;
    117 }
    118 
    119 double PrefService::GetDouble(const char* path) const {
    120   DCHECK(CalledOnValidThread());
    121 
    122   double result = 0.0;
    123 
    124   const base::Value* value = GetPreferenceValue(path);
    125   if (!value) {
    126     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    127     return result;
    128   }
    129   bool rv = value->GetAsDouble(&result);
    130   DCHECK(rv);
    131   return result;
    132 }
    133 
    134 std::string PrefService::GetString(const char* path) const {
    135   DCHECK(CalledOnValidThread());
    136 
    137   std::string result;
    138 
    139   const base::Value* value = GetPreferenceValue(path);
    140   if (!value) {
    141     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    142     return result;
    143   }
    144   bool rv = value->GetAsString(&result);
    145   DCHECK(rv);
    146   return result;
    147 }
    148 
    149 base::FilePath PrefService::GetFilePath(const char* path) const {
    150   DCHECK(CalledOnValidThread());
    151 
    152   base::FilePath result;
    153 
    154   const base::Value* value = GetPreferenceValue(path);
    155   if (!value) {
    156     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    157     return base::FilePath(result);
    158   }
    159   bool rv = base::GetValueAsFilePath(*value, &result);
    160   DCHECK(rv);
    161   return result;
    162 }
    163 
    164 bool PrefService::HasPrefPath(const char* path) const {
    165   const Preference* pref = FindPreference(path);
    166   return pref && !pref->IsDefaultValue();
    167 }
    168 
    169 scoped_ptr<base::DictionaryValue> PrefService::GetPreferenceValues() const {
    170   DCHECK(CalledOnValidThread());
    171   scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
    172   PrefRegistry::const_iterator i = pref_registry_->begin();
    173   for (; i != pref_registry_->end(); ++i) {
    174     const base::Value* value = GetPreferenceValue(i->first);
    175     DCHECK(value);
    176     out->Set(i->first, value->DeepCopy());
    177   }
    178   return out.Pass();
    179 }
    180 
    181 scoped_ptr<base::DictionaryValue>
    182 PrefService::GetPreferenceValuesWithoutPathExpansion() const {
    183   DCHECK(CalledOnValidThread());
    184   scoped_ptr<base::DictionaryValue> out(new base::DictionaryValue);
    185   PrefRegistry::const_iterator i = pref_registry_->begin();
    186   for (; i != pref_registry_->end(); ++i) {
    187     const base::Value* value = GetPreferenceValue(i->first);
    188     DCHECK(value);
    189     out->SetWithoutPathExpansion(i->first, value->DeepCopy());
    190   }
    191   return out.Pass();
    192 }
    193 
    194 const PrefService::Preference* PrefService::FindPreference(
    195     const char* pref_name) const {
    196   DCHECK(CalledOnValidThread());
    197   PreferenceMap::iterator it = prefs_map_.find(pref_name);
    198   if (it != prefs_map_.end())
    199     return &(it->second);
    200   const base::Value* default_value = NULL;
    201   if (!pref_registry_->defaults()->GetValue(pref_name, &default_value))
    202     return NULL;
    203   it = prefs_map_.insert(
    204       std::make_pair(pref_name, Preference(
    205           this, pref_name, default_value->GetType()))).first;
    206   return &(it->second);
    207 }
    208 
    209 bool PrefService::ReadOnly() const {
    210   return user_pref_store_->ReadOnly();
    211 }
    212 
    213 PrefService::PrefInitializationStatus PrefService::GetInitializationStatus()
    214     const {
    215   if (!user_pref_store_->IsInitializationComplete())
    216     return INITIALIZATION_STATUS_WAITING;
    217 
    218   switch (user_pref_store_->GetReadError()) {
    219     case PersistentPrefStore::PREF_READ_ERROR_NONE:
    220       return INITIALIZATION_STATUS_SUCCESS;
    221     case PersistentPrefStore::PREF_READ_ERROR_NO_FILE:
    222       return INITIALIZATION_STATUS_CREATED_NEW_PREF_STORE;
    223     default:
    224       return INITIALIZATION_STATUS_ERROR;
    225   }
    226 }
    227 
    228 bool PrefService::IsManagedPreference(const char* pref_name) const {
    229   const Preference* pref = FindPreference(pref_name);
    230   return pref && pref->IsManaged();
    231 }
    232 
    233 bool PrefService::IsUserModifiablePreference(const char* pref_name) const {
    234   const Preference* pref = FindPreference(pref_name);
    235   return pref && pref->IsUserModifiable();
    236 }
    237 
    238 const base::DictionaryValue* PrefService::GetDictionary(
    239     const char* path) const {
    240   DCHECK(CalledOnValidThread());
    241 
    242   const base::Value* value = GetPreferenceValue(path);
    243   if (!value) {
    244     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    245     return NULL;
    246   }
    247   if (value->GetType() != base::Value::TYPE_DICTIONARY) {
    248     NOTREACHED();
    249     return NULL;
    250   }
    251   return static_cast<const base::DictionaryValue*>(value);
    252 }
    253 
    254 const base::Value* PrefService::GetUserPrefValue(const char* path) const {
    255   DCHECK(CalledOnValidThread());
    256 
    257   const Preference* pref = FindPreference(path);
    258   if (!pref) {
    259     NOTREACHED() << "Trying to get an unregistered pref: " << path;
    260     return NULL;
    261   }
    262 
    263   // Look for an existing preference in the user store. If it doesn't
    264   // exist, return NULL.
    265   base::Value* value = NULL;
    266   if (!user_pref_store_->GetMutableValue(path, &value))
    267     return NULL;
    268 
    269   if (!value->IsType(pref->GetType())) {
    270     NOTREACHED() << "Pref value type doesn't match registered type.";
    271     return NULL;
    272   }
    273 
    274   return value;
    275 }
    276 
    277 void PrefService::SetDefaultPrefValue(const char* path,
    278                                       base::Value* value) {
    279   DCHECK(CalledOnValidThread());
    280   pref_registry_->SetDefaultPrefValue(path, value);
    281 }
    282 
    283 const base::Value* PrefService::GetDefaultPrefValue(const char* path) const {
    284   DCHECK(CalledOnValidThread());
    285   // Lookup the preference in the default store.
    286   const base::Value* value = NULL;
    287   if (!pref_registry_->defaults()->GetValue(path, &value)) {
    288     NOTREACHED() << "Default value missing for pref: " << path;
    289     return NULL;
    290   }
    291   return value;
    292 }
    293 
    294 const base::ListValue* PrefService::GetList(const char* path) const {
    295   DCHECK(CalledOnValidThread());
    296 
    297   const base::Value* value = GetPreferenceValue(path);
    298   if (!value) {
    299     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    300     return NULL;
    301   }
    302   if (value->GetType() != base::Value::TYPE_LIST) {
    303     NOTREACHED();
    304     return NULL;
    305   }
    306   return static_cast<const base::ListValue*>(value);
    307 }
    308 
    309 void PrefService::AddPrefObserver(const char* path, PrefObserver* obs) {
    310   pref_notifier_->AddPrefObserver(path, obs);
    311 }
    312 
    313 void PrefService::RemovePrefObserver(const char* path, PrefObserver* obs) {
    314   pref_notifier_->RemovePrefObserver(path, obs);
    315 }
    316 
    317 void PrefService::AddPrefInitObserver(base::Callback<void(bool)> obs) {
    318   pref_notifier_->AddInitObserver(obs);
    319 }
    320 
    321 PrefRegistry* PrefService::DeprecatedGetPrefRegistry() {
    322   return pref_registry_.get();
    323 }
    324 
    325 void PrefService::ClearPref(const char* path) {
    326   DCHECK(CalledOnValidThread());
    327 
    328   const Preference* pref = FindPreference(path);
    329   if (!pref) {
    330     NOTREACHED() << "Trying to clear an unregistered pref: " << path;
    331     return;
    332   }
    333   user_pref_store_->RemoveValue(path);
    334 }
    335 
    336 void PrefService::Set(const char* path, const base::Value& value) {
    337   SetUserPrefValue(path, value.DeepCopy());
    338 }
    339 
    340 void PrefService::SetBoolean(const char* path, bool value) {
    341   SetUserPrefValue(path, new base::FundamentalValue(value));
    342 }
    343 
    344 void PrefService::SetInteger(const char* path, int value) {
    345   SetUserPrefValue(path, new base::FundamentalValue(value));
    346 }
    347 
    348 void PrefService::SetDouble(const char* path, double value) {
    349   SetUserPrefValue(path, new base::FundamentalValue(value));
    350 }
    351 
    352 void PrefService::SetString(const char* path, const std::string& value) {
    353   SetUserPrefValue(path, new base::StringValue(value));
    354 }
    355 
    356 void PrefService::SetFilePath(const char* path, const base::FilePath& value) {
    357   SetUserPrefValue(path, base::CreateFilePathValue(value));
    358 }
    359 
    360 void PrefService::SetInt64(const char* path, int64 value) {
    361   SetUserPrefValue(path, new base::StringValue(base::Int64ToString(value)));
    362 }
    363 
    364 int64 PrefService::GetInt64(const char* path) const {
    365   DCHECK(CalledOnValidThread());
    366 
    367   const base::Value* value = GetPreferenceValue(path);
    368   if (!value) {
    369     NOTREACHED() << "Trying to read an unregistered pref: " << path;
    370     return 0;
    371   }
    372   std::string result("0");
    373   bool rv = value->GetAsString(&result);
    374   DCHECK(rv);
    375 
    376   int64 val;
    377   base::StringToInt64(result, &val);
    378   return val;
    379 }
    380 
    381 void PrefService::SetUint64(const char* path, uint64 value) {
    382   SetUserPrefValue(path, new base::StringValue(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   DCHECK(CalledOnValidThread());
    436   user_pref_store_->ReportValueChanged(key);
    437 }
    438 
    439 void PrefService::SetUserPrefValue(const char* path, base::Value* new_value) {
    440   scoped_ptr<base::Value> owned_value(new_value);
    441   DCHECK(CalledOnValidThread());
    442 
    443   const Preference* pref = FindPreference(path);
    444   if (!pref) {
    445     NOTREACHED() << "Trying to write an unregistered pref: " << path;
    446     return;
    447   }
    448   if (pref->GetType() != new_value->GetType()) {
    449     NOTREACHED() << "Trying to set pref " << path
    450                  << " of type " << pref->GetType()
    451                  << " to value of type " << new_value->GetType();
    452     return;
    453   }
    454 
    455   user_pref_store_->SetValue(path, owned_value.release());
    456 }
    457 
    458 void PrefService::UpdateCommandLinePrefStore(PrefStore* command_line_store) {
    459   pref_value_store_->UpdateCommandLinePrefStore(command_line_store);
    460 }
    461 
    462 ///////////////////////////////////////////////////////////////////////////////
    463 // PrefService::Preference
    464 
    465 PrefService::Preference::Preference(const PrefService* service,
    466                                     const char* name,
    467                                     base::Value::Type type)
    468       : name_(name),
    469         type_(type),
    470         pref_service_(service) {
    471   DCHECK(name);
    472   DCHECK(service);
    473 }
    474 
    475 const std::string PrefService::Preference::name() const {
    476   return name_;
    477 }
    478 
    479 base::Value::Type PrefService::Preference::GetType() const {
    480   return type_;
    481 }
    482 
    483 const base::Value* PrefService::Preference::GetValue() const {
    484   const base::Value* result= pref_service_->GetPreferenceValue(name_);
    485   DCHECK(result) << "Must register pref before getting its value";
    486   return result;
    487 }
    488 
    489 const base::Value* PrefService::Preference::GetRecommendedValue() const {
    490   DCHECK(pref_service_->FindPreference(name_.c_str())) <<
    491       "Must register pref before getting its value";
    492 
    493   const base::Value* found_value = NULL;
    494   if (pref_value_store()->GetRecommendedValue(name_, type_, &found_value)) {
    495     DCHECK(found_value->IsType(type_));
    496     return found_value;
    497   }
    498 
    499   // The pref has no recommended value.
    500   return NULL;
    501 }
    502 
    503 bool PrefService::Preference::IsManaged() const {
    504   return pref_value_store()->PrefValueInManagedStore(name_.c_str());
    505 }
    506 
    507 bool PrefService::Preference::IsRecommended() const {
    508   return pref_value_store()->PrefValueFromRecommendedStore(name_.c_str());
    509 }
    510 
    511 bool PrefService::Preference::HasExtensionSetting() const {
    512   return pref_value_store()->PrefValueInExtensionStore(name_.c_str());
    513 }
    514 
    515 bool PrefService::Preference::HasUserSetting() const {
    516   return pref_value_store()->PrefValueInUserStore(name_.c_str());
    517 }
    518 
    519 bool PrefService::Preference::IsExtensionControlled() const {
    520   return pref_value_store()->PrefValueFromExtensionStore(name_.c_str());
    521 }
    522 
    523 bool PrefService::Preference::IsUserControlled() const {
    524   return pref_value_store()->PrefValueFromUserStore(name_.c_str());
    525 }
    526 
    527 bool PrefService::Preference::IsDefaultValue() const {
    528   return pref_value_store()->PrefValueFromDefaultStore(name_.c_str());
    529 }
    530 
    531 bool PrefService::Preference::IsUserModifiable() const {
    532   return pref_value_store()->PrefValueUserModifiable(name_.c_str());
    533 }
    534 
    535 bool PrefService::Preference::IsExtensionModifiable() const {
    536   return pref_value_store()->PrefValueExtensionModifiable(name_.c_str());
    537 }
    538 
    539 const base::Value* PrefService::GetPreferenceValue(
    540     const std::string& path) const {
    541   DCHECK(CalledOnValidThread());
    542   const base::Value* default_value = NULL;
    543   if (pref_registry_->defaults()->GetValue(path, &default_value)) {
    544     const base::Value* found_value = NULL;
    545     base::Value::Type default_type = default_value->GetType();
    546     if (pref_value_store_->GetValue(path, default_type, &found_value)) {
    547       DCHECK(found_value->IsType(default_type));
    548       return found_value;
    549     } else {
    550       // Every registered preference has at least a default value.
    551       NOTREACHED() << "no valid value found for registered pref " << path;
    552     }
    553   }
    554 
    555   return NULL;
    556 }
    557