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