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 new base::FundamentalValue(true);
  29       if ("false" == resource_string)
  30         return new base::FundamentalValue(false);
  31       break;
  32     }
  33
  34     case base::Value::TYPE_INTEGER: {
  35       int val;
  36       base::StringToInt(resource_string, &val);
  37       return new base::FundamentalValue(val);
  38     }
  39
  40     case base::Value::TYPE_DOUBLE: {
  41       double val;
  42       base::StringToDouble(resource_string, &val);
  43       return new base::FundamentalValue(val);
  44     }
  45
  46     case base::Value::TYPE_STRING: {
  47       return new base::StringValue(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(
  81       path, new base::FundamentalValue(default_value), sync_status);
  82 }
  83
  84 void PrefRegistrySyncable::RegisterIntegerPref(const char* path,
  85                                                int default_value,
  86                                                PrefSyncStatus sync_status) {
  87   RegisterSyncablePreference(
  88       path, new base::FundamentalValue(default_value), sync_status);
  89 }
  90
  91 void PrefRegistrySyncable::RegisterDoublePref(const char* path,
  92                                               double default_value,
  93                                               PrefSyncStatus sync_status) {
  94   RegisterSyncablePreference(
  95       path, new base::FundamentalValue(default_value), sync_status);
  96 }
  97
  98 void PrefRegistrySyncable::RegisterStringPref(const char* path,
  99                                               const std::string& default_value,
 100                                               PrefSyncStatus sync_status) {
 101   RegisterSyncablePreference(
 102       path, new base::StringValue(default_value), sync_status);
 103 }
 104
 105 void PrefRegistrySyncable::RegisterFilePathPref(
 106     const char* path,
 107     const base::FilePath& default_value,
 108     PrefSyncStatus sync_status) {
 109   RegisterSyncablePreference(
 110       path, new base::StringValue(default_value.value()), sync_status);
 111 }
 112
 113 void PrefRegistrySyncable::RegisterListPref(const char* path,
 114                                             PrefSyncStatus sync_status) {
 115   RegisterSyncablePreference(path, new base::ListValue(), sync_status);
 116 }
 117
 118 void PrefRegistrySyncable::RegisterListPref(const char* path,
 119                                             base::ListValue* default_value,
 120                                             PrefSyncStatus sync_status) {
 121   RegisterSyncablePreference(path, default_value, sync_status);
 122 }
 123
 124 void PrefRegistrySyncable::RegisterDictionaryPref(const char* path,
 125                                                   PrefSyncStatus sync_status) {
 126   RegisterSyncablePreference(path, new base::DictionaryValue(), sync_status);
 127 }
 128
 129 void PrefRegistrySyncable::RegisterDictionaryPref(
 130     const char* path,
 131     base::DictionaryValue* default_value,
 132     PrefSyncStatus sync_status) {
 133   RegisterSyncablePreference(path, default_value, sync_status);
 134 }
 135
 136 void PrefRegistrySyncable::RegisterLocalizedBooleanPref(
 137     const char* path,
 138     int locale_default_message_id,
 139     PrefSyncStatus sync_status) {
 140   RegisterSyncablePreference(
 141       path,
 142       CreateLocaleDefaultValue(base::Value::TYPE_BOOLEAN,
 143                                locale_default_message_id),
 144       sync_status);
 145 }
 146
 147 void PrefRegistrySyncable::RegisterLocalizedIntegerPref(
 148     const char* path,
 149     int locale_default_message_id,
 150     PrefSyncStatus sync_status) {
 151   RegisterSyncablePreference(
 152       path,
 153       CreateLocaleDefaultValue(base::Value::TYPE_INTEGER,
 154                                locale_default_message_id),
 155       sync_status);
 156 }
 157
 158 void PrefRegistrySyncable::RegisterLocalizedDoublePref(
 159     const char* path,
 160     int locale_default_message_id,
 161     PrefSyncStatus sync_status) {
 162   RegisterSyncablePreference(
 163       path,
 164       CreateLocaleDefaultValue(base::Value::TYPE_DOUBLE,
 165                                locale_default_message_id),
 166       sync_status);
 167 }
 168
 169 void PrefRegistrySyncable::RegisterLocalizedStringPref(
 170     const char* path,
 171     int locale_default_message_id,
 172     PrefSyncStatus sync_status) {
 173   RegisterSyncablePreference(
 174       path,
 175       CreateLocaleDefaultValue(base::Value::TYPE_STRING,
 176                                locale_default_message_id),
 177       sync_status);
 178 }
 179
 180 void PrefRegistrySyncable::RegisterInt64Pref(
 181     const char* path,
 182     int64 default_value,
 183     PrefSyncStatus sync_status) {
 184   RegisterSyncablePreference(
 185       path,
 186       new base::StringValue(base::Int64ToString(default_value)),
 187       sync_status);
 188 }
 189
 190 void PrefRegistrySyncable::RegisterUint64Pref(
 191     const char* path,
 192     uint64 default_value,
 193     PrefSyncStatus sync_status) {
 194   RegisterSyncablePreference(
 195       path,
 196       new base::StringValue(base::Uint64ToString(default_value)),
 197       sync_status);
 198 }
 199
 200 void PrefRegistrySyncable::RegisterSyncablePreference(
 201     const char* path,
 202     base::Value* default_value,
 203     PrefSyncStatus sync_status) {
 204   PrefRegistry::RegisterPreference(path, default_value);
 205
 206   if (sync_status == PrefRegistrySyncable::SYNCABLE_PREF ||
 207       sync_status == PrefRegistrySyncable::SYNCABLE_PRIORITY_PREF) {
 208     syncable_preferences_[path] = sync_status;
 209
 210     if (!callback_.is_null())
 211       callback_.Run(path, sync_status);
 212   }
 213 }
 214
 215 scoped_refptr<PrefRegistrySyncable> PrefRegistrySyncable::ForkForIncognito() {
 216   // TODO(joi): We can directly reuse the same PrefRegistry once
 217   // PrefService no longer registers for callbacks on registration and
 218   // unregistration.
 219   scoped_refptr<PrefRegistrySyncable> registry(new PrefRegistrySyncable());
 220   registry->defaults_ = defaults_;
 221   return registry;
 222 }
 223
 224 }  // namespace user_prefs