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