pref_registry_syncable.cc revision cedac228d2dd51db4b79ea1e72c7f249408ee061 
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
13namespace user_prefs {
14
15namespace {
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.
21base::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
61PrefRegistrySyncable::PrefRegistrySyncable() {
62}
63
64PrefRegistrySyncable::~PrefRegistrySyncable() {
65}
66
67const PrefRegistrySyncable::PrefToStatus&
68PrefRegistrySyncable::syncable_preferences() const {
69  return syncable_preferences_;
70}
71
72void PrefRegistrySyncable::SetSyncableRegistrationCallback(
73    const SyncableRegistrationCallback& cb) {
74  callback_ = cb;
75}
76
77void 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
85void 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
93void 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
101void 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
109void 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
119void PrefRegistrySyncable::RegisterListPref(const char* path,
120                                            PrefSyncStatus sync_status) {
121  RegisterSyncablePreference(path, new base::ListValue(), sync_status);
122}
123
124void PrefRegistrySyncable::RegisterListPref(const char* path,
125                                            base::ListValue* default_value,
126                                            PrefSyncStatus sync_status) {
127  RegisterSyncablePreference(path, default_value, sync_status);
128}
129
130void PrefRegistrySyncable::RegisterDictionaryPref(const char* path,
131                                                  PrefSyncStatus sync_status) {
132  RegisterSyncablePreference(path, new base::DictionaryValue(), sync_status);
133}
134
135void PrefRegistrySyncable::RegisterDictionaryPref(
136    const char* path,
137    base::DictionaryValue* default_value,
138    PrefSyncStatus sync_status) {
139  RegisterSyncablePreference(path, default_value, sync_status);
140}
141
142void 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
153void 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
164void 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
175void 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
186void 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
196void 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
206void 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
221scoped_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