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