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 "chrome/browser/sync/sync_prefs.h"
6
7#include "base/command_line.h"
8#include "base/logging.h"
9#include "base/prefs/pref_member.h"
10#include "base/prefs/pref_service.h"
11#include "base/strings/string_number_conversions.h"
12#include "base/values.h"
13#include "build/build_config.h"
14#include "chrome/browser/chrome_notification_types.h"
15#include "chrome/browser/profiles/profile_io_data.h"
16#include "chrome/browser/sync/profile_sync_service.h"
17#include "chrome/common/chrome_switches.h"
18#include "chrome/common/pref_names.h"
19#include "components/user_prefs/pref_registry_syncable.h"
20#include "content/public/browser/browser_thread.h"
21#include "content/public/browser/notification_details.h"
22#include "content/public/browser/notification_source.h"
23
24namespace browser_sync {
25
26SyncPrefObserver::~SyncPrefObserver() {}
27
28SyncPrefs::SyncPrefs(PrefService* pref_service)
29    : pref_service_(pref_service) {
30  RegisterPrefGroups();
31  // TODO(tim): Create a Mock instead of maintaining the if(!pref_service_) case
32  // throughout this file.  This is a problem now due to lack of injection at
33  // ProfileSyncService. Bug 130176.
34  if (pref_service_) {
35    // Watch the preference that indicates sync is managed so we can take
36    // appropriate action.
37    pref_sync_managed_.Init(prefs::kSyncManaged, pref_service_,
38                            base::Bind(&SyncPrefs::OnSyncManagedPrefChanged,
39                                       base::Unretained(this)));
40  }
41}
42
43SyncPrefs::~SyncPrefs() {
44  DCHECK(CalledOnValidThread());
45}
46
47// static
48void SyncPrefs::RegisterProfilePrefs(
49    user_prefs::PrefRegistrySyncable* registry) {
50  registry->RegisterBooleanPref(
51      prefs::kSyncHasSetupCompleted,
52      false,
53      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
54  registry->RegisterBooleanPref(
55      prefs::kSyncSuppressStart,
56      false,
57      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
58  registry->RegisterInt64Pref(
59      prefs::kSyncLastSyncedTime,
60      0,
61      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
62
63  // All datatypes are on by default, but this gets set explicitly
64  // when you configure sync (when turning it on), in
65  // ProfileSyncService::OnUserChoseDatatypes.
66  registry->RegisterBooleanPref(
67      prefs::kSyncKeepEverythingSynced,
68      true,
69      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
70
71  syncer::ModelTypeSet user_types = syncer::UserTypes();
72
73  // Include proxy types as well, as they can be individually selected,
74  // although they don't have sync representations.
75  user_types.PutAll(syncer::ProxyTypes());
76
77  // Treat bookmarks specially.
78  RegisterDataTypePreferredPref(registry, syncer::BOOKMARKS, true);
79  user_types.Remove(syncer::BOOKMARKS);
80
81  // All types are set to off by default, which forces a configuration to
82  // explicitly enable them. GetPreferredTypes() will ensure that any new
83  // implicit types are enabled when their pref group is, or via
84  // KeepEverythingSynced.
85  for (syncer::ModelTypeSet::Iterator it = user_types.First();
86       it.Good(); it.Inc()) {
87    RegisterDataTypePreferredPref(registry, it.Get(), false);
88  }
89
90  registry->RegisterBooleanPref(
91      prefs::kSyncManaged,
92      false,
93      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
94  registry->RegisterStringPref(
95      prefs::kSyncEncryptionBootstrapToken,
96      std::string(),
97      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
98  registry->RegisterStringPref(
99      prefs::kSyncKeystoreEncryptionBootstrapToken,
100      std::string(),
101      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
102#if defined(OS_CHROMEOS)
103  registry->RegisterStringPref(
104      prefs::kSyncSpareBootstrapToken,
105      "",
106      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
107#endif
108
109  registry->RegisterStringPref(
110      prefs::kSyncSessionsGUID,
111      std::string(),
112      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
113
114  // We will start prompting people about new data types after the launch of
115  // SESSIONS - all previously launched data types are treated as if they are
116  // already acknowledged.
117  syncer::ModelTypeSet model_set;
118  model_set.Put(syncer::BOOKMARKS);
119  model_set.Put(syncer::PREFERENCES);
120  model_set.Put(syncer::PASSWORDS);
121  model_set.Put(syncer::AUTOFILL_PROFILE);
122  model_set.Put(syncer::AUTOFILL);
123  model_set.Put(syncer::THEMES);
124  model_set.Put(syncer::EXTENSIONS);
125  model_set.Put(syncer::NIGORI);
126  model_set.Put(syncer::SEARCH_ENGINES);
127  model_set.Put(syncer::APPS);
128  model_set.Put(syncer::TYPED_URLS);
129  model_set.Put(syncer::SESSIONS);
130  registry->RegisterListPref(prefs::kSyncAcknowledgedSyncTypes,
131                             syncer::ModelTypeSetToValue(model_set),
132                             user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
133}
134
135void SyncPrefs::AddSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
136  DCHECK(CalledOnValidThread());
137  sync_pref_observers_.AddObserver(sync_pref_observer);
138}
139
140void SyncPrefs::RemoveSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
141  DCHECK(CalledOnValidThread());
142  sync_pref_observers_.RemoveObserver(sync_pref_observer);
143}
144
145void SyncPrefs::ClearPreferences() {
146  DCHECK(CalledOnValidThread());
147  CHECK(pref_service_);
148  pref_service_->ClearPref(prefs::kSyncLastSyncedTime);
149  pref_service_->ClearPref(prefs::kSyncHasSetupCompleted);
150  pref_service_->ClearPref(prefs::kSyncEncryptionBootstrapToken);
151  pref_service_->ClearPref(prefs::kSyncKeystoreEncryptionBootstrapToken);
152
153  // TODO(nick): The current behavior does not clear
154  // e.g. prefs::kSyncBookmarks.  Is that really what we want?
155}
156
157bool SyncPrefs::HasSyncSetupCompleted() const {
158  DCHECK(CalledOnValidThread());
159  return
160      pref_service_ &&
161      pref_service_->GetBoolean(prefs::kSyncHasSetupCompleted);
162}
163
164void SyncPrefs::SetSyncSetupCompleted() {
165  DCHECK(CalledOnValidThread());
166  CHECK(pref_service_);
167  pref_service_->SetBoolean(prefs::kSyncHasSetupCompleted, true);
168  SetStartSuppressed(false);
169}
170
171bool SyncPrefs::IsStartSuppressed() const {
172  DCHECK(CalledOnValidThread());
173  return
174      pref_service_ &&
175      pref_service_->GetBoolean(prefs::kSyncSuppressStart);
176}
177
178void SyncPrefs::SetStartSuppressed(bool is_suppressed) {
179  DCHECK(CalledOnValidThread());
180  CHECK(pref_service_);
181  pref_service_->SetBoolean(prefs::kSyncSuppressStart, is_suppressed);
182}
183
184std::string SyncPrefs::GetGoogleServicesUsername() const {
185  DCHECK(CalledOnValidThread());
186  return pref_service_
187             ? pref_service_->GetString(prefs::kGoogleServicesUsername)
188             : std::string();
189}
190
191base::Time SyncPrefs::GetLastSyncedTime() const {
192  DCHECK(CalledOnValidThread());
193  return
194      base::Time::FromInternalValue(
195          pref_service_ ?
196          pref_service_->GetInt64(prefs::kSyncLastSyncedTime) : 0);
197}
198
199void SyncPrefs::SetLastSyncedTime(base::Time time) {
200  DCHECK(CalledOnValidThread());
201  CHECK(pref_service_);
202  pref_service_->SetInt64(prefs::kSyncLastSyncedTime, time.ToInternalValue());
203}
204
205bool SyncPrefs::HasKeepEverythingSynced() const {
206  DCHECK(CalledOnValidThread());
207  return
208      pref_service_ &&
209      pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced);
210}
211
212void SyncPrefs::SetKeepEverythingSynced(bool keep_everything_synced) {
213  DCHECK(CalledOnValidThread());
214  CHECK(pref_service_);
215  pref_service_->SetBoolean(prefs::kSyncKeepEverythingSynced,
216                            keep_everything_synced);
217}
218
219syncer::ModelTypeSet SyncPrefs::GetPreferredDataTypes(
220    syncer::ModelTypeSet registered_types) const {
221  DCHECK(CalledOnValidThread());
222  if (!pref_service_) {
223    return syncer::ModelTypeSet();
224  }
225
226  // First remove any datatypes that are inconsistent with the current policies
227  // on the client (so that "keep everything synced" doesn't include them).
228  if (pref_service_->HasPrefPath(prefs::kSavingBrowserHistoryDisabled) &&
229      pref_service_->GetBoolean(prefs::kSavingBrowserHistoryDisabled)) {
230    registered_types.Remove(syncer::TYPED_URLS);
231  }
232
233  if (pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced)) {
234    return registered_types;
235  }
236
237  syncer::ModelTypeSet preferred_types;
238  for (syncer::ModelTypeSet::Iterator it = registered_types.First();
239       it.Good(); it.Inc()) {
240    if (GetDataTypePreferred(it.Get())) {
241      preferred_types.Put(it.Get());
242    }
243  }
244  return ResolvePrefGroups(registered_types, preferred_types);
245}
246
247void SyncPrefs::SetPreferredDataTypes(
248    syncer::ModelTypeSet registered_types,
249    syncer::ModelTypeSet preferred_types) {
250  DCHECK(CalledOnValidThread());
251  CHECK(pref_service_);
252  DCHECK(registered_types.HasAll(preferred_types));
253  preferred_types = ResolvePrefGroups(registered_types, preferred_types);
254  for (syncer::ModelTypeSet::Iterator i = registered_types.First();
255       i.Good(); i.Inc()) {
256    SetDataTypePreferred(i.Get(), preferred_types.Has(i.Get()));
257  }
258}
259
260bool SyncPrefs::IsManaged() const {
261  DCHECK(CalledOnValidThread());
262  return pref_service_ && pref_service_->GetBoolean(prefs::kSyncManaged);
263}
264
265std::string SyncPrefs::GetEncryptionBootstrapToken() const {
266  DCHECK(CalledOnValidThread());
267  return pref_service_
268             ? pref_service_->GetString(prefs::kSyncEncryptionBootstrapToken)
269             : std::string();
270}
271
272void SyncPrefs::SetEncryptionBootstrapToken(const std::string& token) {
273  DCHECK(CalledOnValidThread());
274  pref_service_->SetString(prefs::kSyncEncryptionBootstrapToken, token);
275}
276
277std::string SyncPrefs::GetKeystoreEncryptionBootstrapToken() const {
278  DCHECK(CalledOnValidThread());
279  return pref_service_ ? pref_service_->GetString(
280                             prefs::kSyncKeystoreEncryptionBootstrapToken)
281                       : std::string();
282}
283
284void SyncPrefs::SetKeystoreEncryptionBootstrapToken(const std::string& token) {
285  DCHECK(CalledOnValidThread());
286  pref_service_->SetString(prefs::kSyncKeystoreEncryptionBootstrapToken, token);
287}
288
289std::string SyncPrefs::GetSyncSessionsGUID() const {
290  DCHECK(CalledOnValidThread());
291  return pref_service_ ? pref_service_->GetString(prefs::kSyncSessionsGUID)
292                       : std::string();
293}
294
295void SyncPrefs::SetSyncSessionsGUID(const std::string& guid) {
296  DCHECK(CalledOnValidThread());
297  pref_service_->SetString(prefs::kSyncSessionsGUID, guid);
298}
299
300// static
301const char* SyncPrefs::GetPrefNameForDataType(syncer::ModelType data_type) {
302  switch (data_type) {
303    case syncer::BOOKMARKS:
304      return prefs::kSyncBookmarks;
305    case syncer::PASSWORDS:
306      return prefs::kSyncPasswords;
307    case syncer::PREFERENCES:
308      return prefs::kSyncPreferences;
309    case syncer::AUTOFILL:
310      return prefs::kSyncAutofill;
311    case syncer::AUTOFILL_PROFILE:
312      return prefs::kSyncAutofillProfile;
313    case syncer::THEMES:
314      return prefs::kSyncThemes;
315    case syncer::TYPED_URLS:
316      return prefs::kSyncTypedUrls;
317    case syncer::EXTENSION_SETTINGS:
318      return prefs::kSyncExtensionSettings;
319    case syncer::EXTENSIONS:
320      return prefs::kSyncExtensions;
321    case syncer::APP_SETTINGS:
322      return prefs::kSyncAppSettings;
323    case syncer::APPS:
324      return prefs::kSyncApps;
325    case syncer::SEARCH_ENGINES:
326      return prefs::kSyncSearchEngines;
327    case syncer::SESSIONS:
328      return prefs::kSyncSessions;
329    case syncer::APP_NOTIFICATIONS:
330      return prefs::kSyncAppNotifications;
331    case syncer::HISTORY_DELETE_DIRECTIVES:
332      return prefs::kSyncHistoryDeleteDirectives;
333    case syncer::SYNCED_NOTIFICATIONS:
334      return prefs::kSyncSyncedNotifications;
335    case syncer::DICTIONARY:
336      return prefs::kSyncDictionary;
337    case syncer::FAVICON_IMAGES:
338      return prefs::kSyncFaviconImages;
339    case syncer::FAVICON_TRACKING:
340      return prefs::kSyncFaviconTracking;
341    case syncer::MANAGED_USER_SETTINGS:
342      return prefs::kSyncManagedUserSettings;
343    case syncer::PROXY_TABS:
344      return prefs::kSyncTabs;
345    case syncer::PRIORITY_PREFERENCES:
346      return prefs::kSyncPriorityPreferences;
347    case syncer::MANAGED_USERS:
348      return prefs::kSyncManagedUsers;
349    default:
350      break;
351  }
352  NOTREACHED();
353  return NULL;
354}
355
356#if defined(OS_CHROMEOS)
357std::string SyncPrefs::GetSpareBootstrapToken() const {
358  DCHECK(CalledOnValidThread());
359  return pref_service_ ?
360      pref_service_->GetString(prefs::kSyncSpareBootstrapToken) : "";
361}
362
363void SyncPrefs::SetSpareBootstrapToken(const std::string& token) {
364  DCHECK(CalledOnValidThread());
365  pref_service_->SetString(prefs::kSyncSpareBootstrapToken, token);
366}
367#endif
368
369void SyncPrefs::AcknowledgeSyncedTypes(syncer::ModelTypeSet types) {
370  DCHECK(CalledOnValidThread());
371  CHECK(pref_service_);
372  // Add the types to the current set of acknowledged
373  // types, and then store the resulting set in prefs.
374  const syncer::ModelTypeSet acknowledged_types =
375      Union(types,
376            syncer::ModelTypeSetFromValue(
377                *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes)));
378
379  scoped_ptr<ListValue> value(
380      syncer::ModelTypeSetToValue(acknowledged_types));
381  pref_service_->Set(prefs::kSyncAcknowledgedSyncTypes, *value);
382}
383
384void SyncPrefs::OnSyncManagedPrefChanged() {
385  DCHECK(CalledOnValidThread());
386  FOR_EACH_OBSERVER(SyncPrefObserver, sync_pref_observers_,
387                    OnSyncManagedPrefChange(*pref_sync_managed_));
388}
389
390void SyncPrefs::SetManagedForTest(bool is_managed) {
391  DCHECK(CalledOnValidThread());
392  CHECK(pref_service_);
393  pref_service_->SetBoolean(prefs::kSyncManaged, is_managed);
394}
395
396syncer::ModelTypeSet SyncPrefs::GetAcknowledgeSyncedTypesForTest() const {
397  DCHECK(CalledOnValidThread());
398  if (!pref_service_) {
399    return syncer::ModelTypeSet();
400  }
401  return syncer::ModelTypeSetFromValue(
402      *pref_service_->GetList(prefs::kSyncAcknowledgedSyncTypes));
403}
404
405void SyncPrefs::RegisterPrefGroups() {
406  pref_groups_[syncer::APPS].Put(syncer::APP_NOTIFICATIONS);
407  pref_groups_[syncer::APPS].Put(syncer::APP_SETTINGS);
408
409  pref_groups_[syncer::AUTOFILL].Put(syncer::AUTOFILL_PROFILE);
410
411  pref_groups_[syncer::EXTENSIONS].Put(syncer::EXTENSION_SETTINGS);
412
413  pref_groups_[syncer::PREFERENCES].Put(syncer::DICTIONARY);
414  pref_groups_[syncer::PREFERENCES].Put(syncer::PRIORITY_PREFERENCES);
415  pref_groups_[syncer::PREFERENCES].Put(syncer::SEARCH_ENGINES);
416
417  pref_groups_[syncer::TYPED_URLS].Put(syncer::HISTORY_DELETE_DIRECTIVES);
418  if (!CommandLine::ForCurrentProcess()->HasSwitch(
419          switches::kHistoryDisableFullHistorySync)) {
420    pref_groups_[syncer::TYPED_URLS].Put(syncer::SESSIONS);
421    pref_groups_[syncer::TYPED_URLS].Put(syncer::FAVICON_IMAGES);
422    pref_groups_[syncer::TYPED_URLS].Put(syncer::FAVICON_TRACKING);
423  }
424
425  pref_groups_[syncer::PROXY_TABS].Put(syncer::SESSIONS);
426  pref_groups_[syncer::PROXY_TABS].Put(syncer::FAVICON_IMAGES);
427  pref_groups_[syncer::PROXY_TABS].Put(syncer::FAVICON_TRACKING);
428
429  pref_groups_[syncer::MANAGED_USER_SETTINGS].Put(syncer::SESSIONS);
430
431  // TODO(zea): put favicons in the bookmarks group as well once it handles
432  // those favicons.
433}
434
435// static
436void SyncPrefs::RegisterDataTypePreferredPref(
437    user_prefs::PrefRegistrySyncable* registry,
438    syncer::ModelType type,
439    bool is_preferred) {
440  const char* pref_name = GetPrefNameForDataType(type);
441  if (!pref_name) {
442    NOTREACHED();
443    return;
444  }
445  registry->RegisterBooleanPref(
446      pref_name,
447      is_preferred,
448      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
449}
450
451bool SyncPrefs::GetDataTypePreferred(syncer::ModelType type) const {
452  DCHECK(CalledOnValidThread());
453  if (!pref_service_) {
454    return false;
455  }
456  const char* pref_name = GetPrefNameForDataType(type);
457  if (!pref_name) {
458    NOTREACHED();
459    return false;
460  }
461  if (type == syncer::PROXY_TABS &&
462      pref_service_->GetUserPrefValue(pref_name) == NULL &&
463      pref_service_->IsUserModifiablePreference(pref_name)) {
464    // If there is no tab sync preference yet (i.e. newly enabled type),
465    // default to the session sync preference value.
466    pref_name = GetPrefNameForDataType(syncer::SESSIONS);
467  }
468
469  return pref_service_->GetBoolean(pref_name);
470}
471
472void SyncPrefs::SetDataTypePreferred(
473    syncer::ModelType type, bool is_preferred) {
474  DCHECK(CalledOnValidThread());
475  CHECK(pref_service_);
476  const char* pref_name = GetPrefNameForDataType(type);
477  if (!pref_name) {
478    NOTREACHED();
479    return;
480  }
481  pref_service_->SetBoolean(pref_name, is_preferred);
482}
483
484syncer::ModelTypeSet SyncPrefs::ResolvePrefGroups(
485    syncer::ModelTypeSet registered_types,
486    syncer::ModelTypeSet types) const {
487  DCHECK(registered_types.HasAll(types));
488  syncer::ModelTypeSet types_with_groups = types;
489  for (PrefGroupsMap::const_iterator i = pref_groups_.begin();
490      i != pref_groups_.end(); ++i) {
491    if (types.Has(i->first))
492      types_with_groups.PutAll(i->second);
493  }
494  types_with_groups.RetainAll(registered_types);
495  return types_with_groups;
496}
497
498}  // namespace browser_sync
499