components/pref_registry/pref_registry_syncable.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 "components/pref_registry/pref_registry_syncable.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/prefs/default_pref_store.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/values.h"
  11 #include "ui/base/l10n/l10n_util.h"
  12
  13 namespace user_prefs {
  14
  15 namespace {
  16
  17 // A helper function for RegisterLocalized*Pref that creates a Value*
  18 // based on a localized resource.  Because we control the values in a
  19 // locale dll, this should always return a Value of the appropriate
  20 // type.
  21 base::Value* CreateLocaleDefaultValue(base::Value::Type type,
  22                                       int message_id) {
  23   const std::string resource_string = l10n_util::GetStringUTF8(message_id);
  24   DCHECK(!resource_string.empty());
  25   switch (type) {
  26     case base::Value::TYPE_BOOLEAN: {
  27       if ("true" == resource_string)
  28         return base::Value::CreateBooleanValue(true);
  29       if ("false" == resource_string)
  30         return base::Value::CreateBooleanValue(false);
  31       break;
  32     }
  33
  34     case base::Value::TYPE_INTEGER: {
  35       int val;
  36       base::StringToInt(resource_string, &val);
  37       return base::Value::CreateIntegerValue(val);
  38     }
  39
  40     case base::Value::TYPE_DOUBLE: {
  41       double val;
  42       base::StringToDouble(resource_string, &val);
  43       return base::Value::CreateDoubleValue(val);
  44     }
  45
  46     case base::Value::TYPE_STRING: {
  47       return base::Value::CreateStringValue(resource_string);
  48     }
  49
  50     default: {
  51       NOTREACHED() <<
  52           "list and dictionary types cannot have default locale values";
  53     }
  54   }
  55   NOTREACHED();
  56   return base::Value::CreateNullValue();
  57 }
  58
  59 }  // namespace
  60
  61 PrefRegistrySyncable::PrefRegistrySyncable() {
  62 }
  63
  64 PrefRegistrySyncable::~PrefRegistrySyncable() {
  65 }
  66
  67 const PrefRegistrySyncable::PrefToStatus&
  68 PrefRegistrySyncable::syncable_preferences() const {
  69   return syncable_preferences_;
  70 }
  71
  72 void PrefRegistrySyncable::SetSyncableRegistrationCallback(
  73     const SyncableRegistrationCallback& cb) {
  74   callback_ = cb;
  75 }
  76
  77 void PrefRegistrySyncable::RegisterBooleanPref(const char* path,
  78                                                bool default_value,
  79                                                PrefSyncStatus sync_status) {
  80   RegisterSyncablePreference(path,
  81                              base::Value::CreateBooleanValue(default_value),
  82                              sync_status);
  83 }
  84
  85 void PrefRegistrySyncable::RegisterIntegerPref(const char* path,
  86                                                int default_value,
  87                                                PrefSyncStatus sync_status) {
  88   RegisterSyncablePreference(path,
  89                              base::Value::CreateIntegerValue(default_value),
  90                              sync_status);
  91 }
  92
  93 void PrefRegistrySyncable::RegisterDoublePref(const char* path,
  94                                               double default_value,
  95                                               PrefSyncStatus sync_status) {
  96   RegisterSyncablePreference(path,
  97                              base::Value::CreateDoubleValue(default_value),
  98                              sync_status);
  99 }
 100
 101 void PrefRegistrySyncable::RegisterStringPref(const char* path,
 102                                               const std::string& default_value,
 103                                               PrefSyncStatus sync_status) {
 104   RegisterSyncablePreference(path,
 105                              base::Value::CreateStringValue(default_value),
 106                              sync_status);
 107 }
 108
 109 void PrefRegistrySyncable::RegisterFilePathPref(
 110     const char* path,
 111     const base::FilePath& default_value,
 112     PrefSyncStatus sync_status) {
 113   RegisterSyncablePreference(path,
 114                              base::Value::CreateStringValue(
 115                                  default_value.value()),
 116                              sync_status);
 117 }
 118
 119 void PrefRegistrySyncable::RegisterListPref(const char* path,
 120                                             PrefSyncStatus sync_status) {
 121   RegisterSyncablePreference(path, new base::ListValue(), sync_status);
 122 }
 123
 124 void PrefRegistrySyncable::RegisterListPref(const char* path,
 125                                             base::ListValue* default_value,
 126                                             PrefSyncStatus sync_status) {
 127   RegisterSyncablePreference(path, default_value, sync_status);
 128 }
 129
 130 void PrefRegistrySyncable::RegisterDictionaryPref(const char* path,
 131                                                   PrefSyncStatus sync_status) {
 132   RegisterSyncablePreference(path, new base::DictionaryValue(), sync_status);
 133 }
 134
 135 void PrefRegistrySyncable::RegisterDictionaryPref(
 136     const char* path,
 137     base::DictionaryValue* default_value,
 138     PrefSyncStatus sync_status) {
 139   RegisterSyncablePreference(path, default_value, sync_status);
 140 }
 141
 142 void PrefRegistrySyncable::RegisterLocalizedBooleanPref(
 143     const char* path,
 144     int locale_default_message_id,
 145     PrefSyncStatus sync_status) {
 146   RegisterSyncablePreference(
 147       path,
 148       CreateLocaleDefaultValue(base::Value::TYPE_BOOLEAN,
 149                                locale_default_message_id),
 150       sync_status);
 151 }
 152
 153 void PrefRegistrySyncable::RegisterLocalizedIntegerPref(
 154     const char* path,
 155     int locale_default_message_id,
 156     PrefSyncStatus sync_status) {
 157   RegisterSyncablePreference(
 158       path,
 159       CreateLocaleDefaultValue(base::Value::TYPE_INTEGER,
 160                                locale_default_message_id),
 161       sync_status);
 162 }
 163
 164 void PrefRegistrySyncable::RegisterLocalizedDoublePref(
 165     const char* path,
 166     int locale_default_message_id,
 167     PrefSyncStatus sync_status) {
 168   RegisterSyncablePreference(
 169       path,
 170       CreateLocaleDefaultValue(base::Value::TYPE_DOUBLE,
 171                                locale_default_message_id),
 172       sync_status);
 173 }
 174
 175 void PrefRegistrySyncable::RegisterLocalizedStringPref(
 176     const char* path,
 177     int locale_default_message_id,
 178     PrefSyncStatus sync_status) {
 179   RegisterSyncablePreference(
 180       path,
 181       CreateLocaleDefaultValue(base::Value::TYPE_STRING,
 182                                locale_default_message_id),
 183       sync_status);
 184 }
 185
 186 void PrefRegistrySyncable::RegisterInt64Pref(
 187     const char* path,
 188     int64 default_value,
 189     PrefSyncStatus sync_status) {
 190   RegisterSyncablePreference(
 191       path,
 192       base::Value::CreateStringValue(base::Int64ToString(default_value)),
 193       sync_status);
 194 }
 195
 196 void PrefRegistrySyncable::RegisterUint64Pref(
 197     const char* path,
 198     uint64 default_value,
 199     PrefSyncStatus sync_status) {
 200   RegisterSyncablePreference(
 201       path,
 202       base::Value::CreateStringValue(base::Uint64ToString(default_value)),
 203       sync_status);
 204 }
 205
 206 void PrefRegistrySyncable::RegisterSyncablePreference(
 207     const char* path,
 208     base::Value* default_value,
 209     PrefSyncStatus sync_status) {
 210   PrefRegistry::RegisterPreference(path, default_value);
 211
 212   if (sync_status == PrefRegistrySyncable::SYNCABLE_PREF ||
 213       sync_status == PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF) {
 214     syncable_preferences_[path] = sync_status;
 215
 216     if (!callback_.is_null())
 217       callback_.Run(path, sync_status);
 218   }
 219 }
 220
 221 scoped_refptr<PrefRegistrySyncable> PrefRegistrySyncable::ForkForIncognito() {
 222   // TODO(joi): We can directly reuse the same PrefRegistry once
 223   // PrefService no longer registers for callbacks on registration and
 224   // unregistration.
 225   scoped_refptr<PrefRegistrySyncable> registry(new PrefRegistrySyncable());
 226   registry->defaults_ = defaults_;
 227   return registry;
 228 }
 229
 230 }  // namespace user_prefs