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