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 231
