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/base/sync_prefs.h"
6
7 #include <utility>
8 #include <vector>
9
10 #include "base/base64.h"
11 #include "base/bind.h"
12 #include "base/check_op.h"
13 #include "base/files/file_path.h"
14 #include "base/notreached.h"
15 #include "base/path_service.h"
16 #include "base/rand_util.h"
17 #include "base/strings/string_number_conversions.h"
18 #include "base/values.h"
19 #include "components/prefs/pref_registry_simple.h"
20 #include "components/prefs/pref_service.h"
21 #include "components/sync/base/pref_names.h"
22 #include "components/sync/base/user_selectable_type.h"
23
24 namespace syncer {
25
26 namespace {
27
28 // Obsolete prefs related to the removed ClearServerData flow.
29 const char kSyncPassphraseEncryptionTransitionInProgress[] =
30 "sync.passphrase_encryption_transition_in_progress";
31 const char kSyncNigoriStateForPassphraseTransition[] =
32 "sync.nigori_state_for_passphrase_transition";
33
34 // Obsolete pref that used to store a bool on whether Sync has an auth error.
35 const char kSyncHasAuthError[] = "sync.has_auth_error";
36
37 // Obsolete pref that used to store the timestamp of first sync.
38 const char kSyncFirstSyncTime[] = "sync.first_sync_time";
39
40 // Obsolete pref that used to store long poll intervals received by the server.
41 const char kSyncLongPollIntervalSeconds[] = "sync.long_poll_interval";
42
43 // Obsolete pref that used to store if sync should be prevented from
44 // automatically starting up. This is now replaced by its inverse
45 // kSyncRequested.
46 const char kSyncSuppressStart[] = "sync.suppress_start";
47
48 // Obsolete prefs for data types. Can be deleted after 2020-01-30.
49 const char kSyncAppList[] = "sync.app_list";
50 const char kSyncAppNotifications[] = "sync.app_notifications";
51 const char kSyncAppSettings[] = "sync.app_settings";
52 const char kSyncArcPackage[] = "sync.arc_package";
53 const char kSyncArticles[] = "sync.articles";
54 const char kSyncAutofillProfile[] = "sync.autofill_profile";
55 const char kSyncAutofillWallet[] = "sync.autofill_wallet";
56 const char kSyncAutofillWalletMetadata[] = "sync.autofill_wallet_metadata";
57 const char kSyncDeviceInfo[] = "sync.device_info";
58 const char kSyncDictionary[] = "sync.dictionary";
59 const char kSyncExtensionSettings[] = "sync.extension_settings";
60 const char kSyncFaviconImages[] = "sync.favicon_images";
61 const char kSyncFaviconTracking[] = "sync.favicon_tracking";
62 const char kSyncHistoryDeleteDirectives[] = "sync.history_delete_directives";
63 const char kSyncMountainShares[] = "sync.mountain_shares";
64 const char kSyncPriorityPreferences[] = "sync.priority_preferences";
65 const char kSyncSearchEngines[] = "sync.search_engines";
66 const char kSyncSessions[] = "sync.sessions";
67 const char kSyncSupervisedUsers[] = "sync.managed_users";
68 const char kSyncSupervisedUserSettings[] = "sync.managed_user_settings";
69 const char kSyncSupervisedUserSharedSettings[] =
70 "sync.managed_user_shared_settings";
71 const char kSyncSupervisedUserWhitelists[] = "sync.managed_user_whitelists";
72 const char kSyncSyncedNotificationAppInfo[] =
73 "sync.synced_notification_app_info";
74 const char kSyncSyncedNotifications[] = "sync.synced_notifications";
75 const char kSyncUserEvents[] = "sync.user_events";
76 const char kSyncWifiCredentials[] = "sync.wifi_credentials";
77
78 // Obsolete pref. Can be deleted after 2020-09-09.
79 const char kSyncUserConsents[] = "sync.user_consents";
80
GetObsoleteUserTypePrefs()81 std::vector<std::string> GetObsoleteUserTypePrefs() {
82 return {kSyncAutofillProfile,
83 kSyncAutofillWallet,
84 kSyncAutofillWalletMetadata,
85 kSyncSearchEngines,
86 kSyncSessions,
87 kSyncAppSettings,
88 kSyncExtensionSettings,
89 kSyncAppNotifications,
90 kSyncHistoryDeleteDirectives,
91 kSyncSyncedNotifications,
92 kSyncSyncedNotificationAppInfo,
93 kSyncDictionary,
94 kSyncFaviconImages,
95 kSyncFaviconTracking,
96 kSyncDeviceInfo,
97 kSyncPriorityPreferences,
98 kSyncSupervisedUserSettings,
99 kSyncSupervisedUsers,
100 kSyncSupervisedUserSharedSettings,
101 kSyncArticles,
102 kSyncAppList,
103 kSyncWifiCredentials,
104 kSyncSupervisedUserWhitelists,
105 kSyncArcPackage,
106 kSyncUserEvents,
107 kSyncMountainShares,
108 kSyncUserConsents};
109 }
110
RegisterObsoleteUserTypePrefs(PrefRegistrySimple * registry)111 void RegisterObsoleteUserTypePrefs(PrefRegistrySimple* registry) {
112 for (const std::string& obsolete_pref : GetObsoleteUserTypePrefs()) {
113 registry->RegisterBooleanPref(obsolete_pref, false);
114 }
115 }
116
117 } // namespace
118
~CryptoSyncPrefs()119 CryptoSyncPrefs::~CryptoSyncPrefs() {}
120
~SyncPrefObserver()121 SyncPrefObserver::~SyncPrefObserver() {}
122
SyncPrefs(PrefService * pref_service)123 SyncPrefs::SyncPrefs(PrefService* pref_service) : pref_service_(pref_service) {
124 DCHECK(pref_service);
125 // Watch the preference that indicates sync is managed so we can take
126 // appropriate action.
127 pref_sync_managed_.Init(
128 prefs::kSyncManaged, pref_service_,
129 base::BindRepeating(&SyncPrefs::OnSyncManagedPrefChanged,
130 base::Unretained(this)));
131 pref_first_setup_complete_.Init(
132 prefs::kSyncFirstSetupComplete, pref_service_,
133 base::BindRepeating(&SyncPrefs::OnFirstSetupCompletePrefChange,
134 base::Unretained(this)));
135 pref_sync_requested_.Init(
136 prefs::kSyncRequested, pref_service_,
137 base::BindRepeating(&SyncPrefs::OnSyncRequestedPrefChange,
138 base::Unretained(this)));
139
140 // Cache the value of the kEnableLocalSyncBackend pref to avoid it flipping
141 // during the lifetime of the service.
142 local_sync_enabled_ =
143 pref_service_->GetBoolean(prefs::kEnableLocalSyncBackend);
144 }
145
~SyncPrefs()146 SyncPrefs::~SyncPrefs() {
147 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
148 }
149
150 // static
RegisterProfilePrefs(PrefRegistrySimple * registry)151 void SyncPrefs::RegisterProfilePrefs(PrefRegistrySimple* registry) {
152 // Actual user-controlled preferences.
153 registry->RegisterBooleanPref(prefs::kSyncFirstSetupComplete, false);
154 registry->RegisterBooleanPref(prefs::kSyncRequested, false);
155 registry->RegisterBooleanPref(prefs::kSyncKeepEverythingSynced, true);
156 for (UserSelectableType type : UserSelectableTypeSet::All()) {
157 RegisterTypeSelectedPref(registry, type);
158 }
159 #if defined(OS_CHROMEOS)
160 registry->RegisterBooleanPref(prefs::kOsSyncPrefsMigrated, false);
161 registry->RegisterBooleanPref(prefs::kOsSyncFeatureEnabled, false);
162 registry->RegisterBooleanPref(prefs::kSyncAllOsTypes, true);
163 registry->RegisterBooleanPref(prefs::kSyncOsApps, false);
164 registry->RegisterBooleanPref(prefs::kSyncOsPreferences, false);
165 // The pref for Wi-Fi configurations is registered in the loop above.
166 #endif
167
168 // The encryption bootstrap token represents a user-entered passphrase.
169 registry->RegisterStringPref(prefs::kSyncEncryptionBootstrapToken,
170 std::string());
171
172 // Internal or bookkeeping prefs.
173 registry->RegisterStringPref(prefs::kSyncGaiaId, std::string());
174 registry->RegisterStringPref(prefs::kSyncCacheGuid, std::string());
175 registry->RegisterStringPref(prefs::kSyncBirthday, std::string());
176 registry->RegisterStringPref(prefs::kSyncBagOfChips, std::string());
177 registry->RegisterInt64Pref(prefs::kSyncLastSyncedTime, 0);
178 registry->RegisterInt64Pref(prefs::kSyncLastPollTime, 0);
179 registry->RegisterInt64Pref(prefs::kSyncPollIntervalSeconds, 0);
180 registry->RegisterBooleanPref(prefs::kSyncManaged, false);
181 registry->RegisterStringPref(prefs::kSyncKeystoreEncryptionBootstrapToken,
182 std::string());
183 registry->RegisterBooleanPref(prefs::kSyncPassphrasePrompted, false);
184 registry->RegisterDictionaryPref(prefs::kSyncInvalidationVersions);
185 registry->RegisterStringPref(prefs::kSyncLastRunVersion, std::string());
186 registry->RegisterBooleanPref(prefs::kEnableLocalSyncBackend, false);
187 registry->RegisterFilePathPref(prefs::kLocalSyncBackendDir, base::FilePath());
188 #if defined(OS_ANDROID)
189 registry->RegisterBooleanPref(prefs::kSyncDecoupledFromAndroidMasterSync,
190 false);
191 #endif // defined(OS_ANDROID)
192
193 // Obsolete prefs that will be removed after a grace period.
194 RegisterObsoleteUserTypePrefs(registry);
195 registry->RegisterBooleanPref(kSyncPassphraseEncryptionTransitionInProgress,
196 false);
197 registry->RegisterStringPref(kSyncNigoriStateForPassphraseTransition,
198 std::string());
199 registry->RegisterBooleanPref(kSyncHasAuthError, false);
200 registry->RegisterInt64Pref(kSyncFirstSyncTime, 0);
201 registry->RegisterInt64Pref(kSyncLongPollIntervalSeconds, 0);
202 registry->RegisterBooleanPref(kSyncSuppressStart, false);
203 }
204
AddSyncPrefObserver(SyncPrefObserver * sync_pref_observer)205 void SyncPrefs::AddSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
206 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
207 sync_pref_observers_.AddObserver(sync_pref_observer);
208 }
209
RemoveSyncPrefObserver(SyncPrefObserver * sync_pref_observer)210 void SyncPrefs::RemoveSyncPrefObserver(SyncPrefObserver* sync_pref_observer) {
211 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
212 sync_pref_observers_.RemoveObserver(sync_pref_observer);
213 }
214
ClearLocalSyncTransportData()215 void SyncPrefs::ClearLocalSyncTransportData() {
216 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
217
218 pref_service_->ClearPref(prefs::kSyncLastSyncedTime);
219 pref_service_->ClearPref(prefs::kSyncLastPollTime);
220 pref_service_->ClearPref(prefs::kSyncPollIntervalSeconds);
221 pref_service_->ClearPref(prefs::kSyncKeystoreEncryptionBootstrapToken);
222 pref_service_->ClearPref(prefs::kSyncPassphrasePrompted);
223 pref_service_->ClearPref(prefs::kSyncInvalidationVersions);
224 pref_service_->ClearPref(prefs::kSyncLastRunVersion);
225 pref_service_->ClearPref(prefs::kSyncGaiaId);
226 pref_service_->ClearPref(prefs::kSyncCacheGuid);
227 pref_service_->ClearPref(prefs::kSyncBirthday);
228 pref_service_->ClearPref(prefs::kSyncBagOfChips);
229
230 // No need to clear kManaged, kEnableLocalSyncBackend or kLocalSyncBackendDir,
231 // since they're never actually set as user preferences.
232 }
233
IsFirstSetupComplete() const234 bool SyncPrefs::IsFirstSetupComplete() const {
235 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
236 return pref_service_->GetBoolean(prefs::kSyncFirstSetupComplete);
237 }
238
SetFirstSetupComplete()239 void SyncPrefs::SetFirstSetupComplete() {
240 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
241 pref_service_->SetBoolean(prefs::kSyncFirstSetupComplete, true);
242 }
243
ClearFirstSetupComplete()244 void SyncPrefs::ClearFirstSetupComplete() {
245 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
246 pref_service_->ClearPref(prefs::kSyncFirstSetupComplete);
247 }
248
IsSyncRequested() const249 bool SyncPrefs::IsSyncRequested() const {
250 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
251 return pref_service_->GetBoolean(prefs::kSyncRequested);
252 }
253
SetSyncRequested(bool is_requested)254 void SyncPrefs::SetSyncRequested(bool is_requested) {
255 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
256 pref_service_->SetBoolean(prefs::kSyncRequested, is_requested);
257 }
258
SetSyncRequestedIfNotSetExplicitly()259 void SyncPrefs::SetSyncRequestedIfNotSetExplicitly() {
260 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
261 // GetUserPrefValue() returns nullptr if there is no user-set value for this
262 // pref (there might still be a non-default value, e.g. from a policy, but we
263 // explicitly don't care about that here).
264 if (!pref_service_->GetUserPrefValue(prefs::kSyncRequested)) {
265 pref_service_->SetBoolean(prefs::kSyncRequested, true);
266 }
267 }
268
GetLastSyncedTime() const269 base::Time SyncPrefs::GetLastSyncedTime() const {
270 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
271 return base::Time::FromInternalValue(
272 pref_service_->GetInt64(prefs::kSyncLastSyncedTime));
273 }
274
SetLastSyncedTime(base::Time time)275 void SyncPrefs::SetLastSyncedTime(base::Time time) {
276 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
277 pref_service_->SetInt64(prefs::kSyncLastSyncedTime, time.ToInternalValue());
278 }
279
GetLastPollTime() const280 base::Time SyncPrefs::GetLastPollTime() const {
281 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
282 return base::Time::FromInternalValue(
283 pref_service_->GetInt64(prefs::kSyncLastPollTime));
284 }
285
SetLastPollTime(base::Time time)286 void SyncPrefs::SetLastPollTime(base::Time time) {
287 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
288 pref_service_->SetInt64(prefs::kSyncLastPollTime, time.ToInternalValue());
289 }
290
GetPollInterval() const291 base::TimeDelta SyncPrefs::GetPollInterval() const {
292 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
293 return base::TimeDelta::FromSeconds(
294 pref_service_->GetInt64(prefs::kSyncPollIntervalSeconds));
295 }
296
SetPollInterval(base::TimeDelta interval)297 void SyncPrefs::SetPollInterval(base::TimeDelta interval) {
298 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
299 pref_service_->SetInt64(prefs::kSyncPollIntervalSeconds,
300 interval.InSeconds());
301 }
302
HasKeepEverythingSynced() const303 bool SyncPrefs::HasKeepEverythingSynced() const {
304 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
305 return pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced);
306 }
307
GetSelectedTypes() const308 UserSelectableTypeSet SyncPrefs::GetSelectedTypes() const {
309 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
310
311 UserSelectableTypeSet selected_types;
312
313 const bool sync_all_types =
314 pref_service_->GetBoolean(prefs::kSyncKeepEverythingSynced);
315
316 for (UserSelectableType type : UserSelectableTypeSet::All()) {
317 const char* pref_name = GetPrefNameForType(type);
318 DCHECK(pref_name);
319 // If the preference is managed, |sync_all_types| is ignored for this
320 // preference.
321 if (pref_service_->GetBoolean(pref_name) ||
322 (sync_all_types && !pref_service_->IsManagedPreference(pref_name))) {
323 selected_types.Put(type);
324 }
325 }
326
327 return selected_types;
328 }
329
SetSelectedTypes(bool keep_everything_synced,UserSelectableTypeSet registered_types,UserSelectableTypeSet selected_types)330 void SyncPrefs::SetSelectedTypes(bool keep_everything_synced,
331 UserSelectableTypeSet registered_types,
332 UserSelectableTypeSet selected_types) {
333 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
334
335 pref_service_->SetBoolean(prefs::kSyncKeepEverythingSynced,
336 keep_everything_synced);
337
338 for (UserSelectableType type : registered_types) {
339 const char* pref_name = GetPrefNameForType(type);
340 pref_service_->SetBoolean(pref_name, selected_types.Has(type));
341 }
342
343 for (SyncPrefObserver& observer : sync_pref_observers_) {
344 observer.OnPreferredDataTypesPrefChange();
345 }
346 }
347
348 #if defined(OS_CHROMEOS)
IsSyncAllOsTypesEnabled() const349 bool SyncPrefs::IsSyncAllOsTypesEnabled() const {
350 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
351 return pref_service_->GetBoolean(prefs::kSyncAllOsTypes);
352 }
353
GetSelectedOsTypes() const354 UserSelectableOsTypeSet SyncPrefs::GetSelectedOsTypes() const {
355 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
356 if (IsSyncAllOsTypesEnabled()) {
357 return UserSelectableOsTypeSet::All();
358 }
359 UserSelectableOsTypeSet selected_types;
360 for (UserSelectableOsType type : UserSelectableOsTypeSet::All()) {
361 const char* pref_name = GetPrefNameForOsType(type);
362 DCHECK(pref_name);
363 if (pref_service_->GetBoolean(pref_name)) {
364 selected_types.Put(type);
365 }
366 }
367 return selected_types;
368 }
369
SetSelectedOsTypes(bool sync_all_os_types,UserSelectableOsTypeSet registered_types,UserSelectableOsTypeSet selected_types)370 void SyncPrefs::SetSelectedOsTypes(bool sync_all_os_types,
371 UserSelectableOsTypeSet registered_types,
372 UserSelectableOsTypeSet selected_types) {
373 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
374 pref_service_->SetBoolean(prefs::kSyncAllOsTypes, sync_all_os_types);
375 for (UserSelectableOsType type : registered_types) {
376 const char* pref_name = GetPrefNameForOsType(type);
377 DCHECK(pref_name);
378 pref_service_->SetBoolean(pref_name, selected_types.Has(type));
379 }
380 for (SyncPrefObserver& observer : sync_pref_observers_) {
381 observer.OnPreferredDataTypesPrefChange();
382 }
383 }
384
IsOsSyncFeatureEnabled() const385 bool SyncPrefs::IsOsSyncFeatureEnabled() const {
386 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
387 return pref_service_->GetBoolean(prefs::kOsSyncFeatureEnabled);
388 }
389
SetOsSyncFeatureEnabled(bool enabled)390 void SyncPrefs::SetOsSyncFeatureEnabled(bool enabled) {
391 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
392 pref_service_->SetBoolean(prefs::kOsSyncFeatureEnabled, enabled);
393 }
394
395 // static
GetPrefNameForOsType(UserSelectableOsType type)396 const char* SyncPrefs::GetPrefNameForOsType(UserSelectableOsType type) {
397 switch (type) {
398 case UserSelectableOsType::kOsApps:
399 return prefs::kSyncOsApps;
400 case UserSelectableOsType::kOsPreferences:
401 return prefs::kSyncOsPreferences;
402 case UserSelectableOsType::kOsWifiConfigurations:
403 return prefs::kSyncWifiConfigurations;
404 }
405 NOTREACHED();
406 return nullptr;
407 }
408 #endif // defined(OS_CHROMEOS)
409
IsManaged() const410 bool SyncPrefs::IsManaged() const {
411 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
412 return pref_service_->GetBoolean(prefs::kSyncManaged);
413 }
414
GetEncryptionBootstrapToken() const415 std::string SyncPrefs::GetEncryptionBootstrapToken() const {
416 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
417 return pref_service_->GetString(prefs::kSyncEncryptionBootstrapToken);
418 }
419
SetEncryptionBootstrapToken(const std::string & token)420 void SyncPrefs::SetEncryptionBootstrapToken(const std::string& token) {
421 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
422 pref_service_->SetString(prefs::kSyncEncryptionBootstrapToken, token);
423 }
424
ClearEncryptionBootstrapToken()425 void SyncPrefs::ClearEncryptionBootstrapToken() {
426 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
427 pref_service_->ClearPref(prefs::kSyncEncryptionBootstrapToken);
428 }
429
GetKeystoreEncryptionBootstrapToken() const430 std::string SyncPrefs::GetKeystoreEncryptionBootstrapToken() const {
431 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
432 return pref_service_->GetString(prefs::kSyncKeystoreEncryptionBootstrapToken);
433 }
434
SetKeystoreEncryptionBootstrapToken(const std::string & token)435 void SyncPrefs::SetKeystoreEncryptionBootstrapToken(const std::string& token) {
436 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
437 pref_service_->SetString(prefs::kSyncKeystoreEncryptionBootstrapToken, token);
438 }
439
440 // static
GetPrefNameForType(UserSelectableType type)441 const char* SyncPrefs::GetPrefNameForType(UserSelectableType type) {
442 switch (type) {
443 case UserSelectableType::kBookmarks:
444 return prefs::kSyncBookmarks;
445 case UserSelectableType::kPreferences:
446 return prefs::kSyncPreferences;
447 case UserSelectableType::kPasswords:
448 return prefs::kSyncPasswords;
449 case UserSelectableType::kAutofill:
450 return prefs::kSyncAutofill;
451 case UserSelectableType::kThemes:
452 return prefs::kSyncThemes;
453 case UserSelectableType::kHistory:
454 // kSyncTypedUrls used here for historic reasons and pref backward
455 // compatibility.
456 return prefs::kSyncTypedUrls;
457 case UserSelectableType::kExtensions:
458 return prefs::kSyncExtensions;
459 case UserSelectableType::kApps:
460 return prefs::kSyncApps;
461 case UserSelectableType::kReadingList:
462 return prefs::kSyncReadingList;
463 case UserSelectableType::kTabs:
464 return prefs::kSyncTabs;
465 case UserSelectableType::kWifiConfigurations:
466 return prefs::kSyncWifiConfigurations;
467 }
468 NOTREACHED();
469 return nullptr;
470 }
471
OnSyncManagedPrefChanged()472 void SyncPrefs::OnSyncManagedPrefChanged() {
473 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
474 for (SyncPrefObserver& observer : sync_pref_observers_)
475 observer.OnSyncManagedPrefChange(*pref_sync_managed_);
476 }
477
OnFirstSetupCompletePrefChange()478 void SyncPrefs::OnFirstSetupCompletePrefChange() {
479 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
480 for (SyncPrefObserver& observer : sync_pref_observers_)
481 observer.OnFirstSetupCompletePrefChange(*pref_first_setup_complete_);
482 }
483
OnSyncRequestedPrefChange()484 void SyncPrefs::OnSyncRequestedPrefChange() {
485 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
486 for (SyncPrefObserver& observer : sync_pref_observers_)
487 observer.OnSyncRequestedPrefChange(*pref_sync_requested_);
488 }
489
SetManagedForTest(bool is_managed)490 void SyncPrefs::SetManagedForTest(bool is_managed) {
491 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
492 pref_service_->SetBoolean(prefs::kSyncManaged, is_managed);
493 }
494
495 // static
RegisterTypeSelectedPref(PrefRegistrySimple * registry,UserSelectableType type)496 void SyncPrefs::RegisterTypeSelectedPref(PrefRegistrySimple* registry,
497 UserSelectableType type) {
498 const char* pref_name = GetPrefNameForType(type);
499 DCHECK(pref_name);
500 registry->RegisterBooleanPref(pref_name, false);
501 }
502
SetGaiaId(const std::string & gaia_id)503 void SyncPrefs::SetGaiaId(const std::string& gaia_id) {
504 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
505 pref_service_->SetString(prefs::kSyncGaiaId, gaia_id);
506 }
507
GetGaiaId() const508 std::string SyncPrefs::GetGaiaId() const {
509 return pref_service_->GetString(prefs::kSyncGaiaId);
510 }
511
SetCacheGuid(const std::string & cache_guid)512 void SyncPrefs::SetCacheGuid(const std::string& cache_guid) {
513 pref_service_->SetString(prefs::kSyncCacheGuid, cache_guid);
514 }
515
GetCacheGuid() const516 std::string SyncPrefs::GetCacheGuid() const {
517 return pref_service_->GetString(prefs::kSyncCacheGuid);
518 }
519
SetBirthday(const std::string & birthday)520 void SyncPrefs::SetBirthday(const std::string& birthday) {
521 pref_service_->SetString(prefs::kSyncBirthday, birthday);
522 }
523
GetBirthday() const524 std::string SyncPrefs::GetBirthday() const {
525 return pref_service_->GetString(prefs::kSyncBirthday);
526 }
527
SetBagOfChips(const std::string & bag_of_chips)528 void SyncPrefs::SetBagOfChips(const std::string& bag_of_chips) {
529 // |bag_of_chips| contains a serialized proto which is not utf-8, hence we use
530 // base64 encoding in prefs.
531 std::string encoded;
532 base::Base64Encode(bag_of_chips, &encoded);
533 pref_service_->SetString(prefs::kSyncBagOfChips, encoded);
534 }
535
GetBagOfChips() const536 std::string SyncPrefs::GetBagOfChips() const {
537 // |kSyncBagOfChips| gets stored in base64 because it represents a serialized
538 // proto which is not utf-8 encoding.
539 const std::string encoded = pref_service_->GetString(prefs::kSyncBagOfChips);
540 std::string decoded;
541 base::Base64Decode(encoded, &decoded);
542 return decoded;
543 }
544
IsPassphrasePrompted() const545 bool SyncPrefs::IsPassphrasePrompted() const {
546 return pref_service_->GetBoolean(prefs::kSyncPassphrasePrompted);
547 }
548
SetPassphrasePrompted(bool value)549 void SyncPrefs::SetPassphrasePrompted(bool value) {
550 pref_service_->SetBoolean(prefs::kSyncPassphrasePrompted, value);
551 }
552
553 #if defined(OS_ANDROID)
SetDecoupledFromAndroidMasterSync()554 void SyncPrefs::SetDecoupledFromAndroidMasterSync() {
555 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
556 pref_service_->SetBoolean(prefs::kSyncDecoupledFromAndroidMasterSync, true);
557 }
558
GetDecoupledFromAndroidMasterSync()559 bool SyncPrefs::GetDecoupledFromAndroidMasterSync() {
560 DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
561 return pref_service_->GetBoolean(prefs::kSyncDecoupledFromAndroidMasterSync);
562 }
563 #endif // defined(OS_ANDROID)
564
GetInvalidationVersions() const565 std::map<ModelType, int64_t> SyncPrefs::GetInvalidationVersions() const {
566 std::map<ModelType, int64_t> invalidation_versions;
567 const base::DictionaryValue* invalidation_dictionary =
568 pref_service_->GetDictionary(prefs::kSyncInvalidationVersions);
569 for (ModelType type : ProtocolTypes()) {
570 std::string key = ModelTypeToString(type);
571 std::string version_str;
572 if (!invalidation_dictionary->GetString(key, &version_str))
573 continue;
574 int64_t version = 0;
575 if (!base::StringToInt64(version_str, &version))
576 continue;
577 invalidation_versions[type] = version;
578 }
579 return invalidation_versions;
580 }
581
UpdateInvalidationVersions(const std::map<ModelType,int64_t> & invalidation_versions)582 void SyncPrefs::UpdateInvalidationVersions(
583 const std::map<ModelType, int64_t>& invalidation_versions) {
584 std::unique_ptr<base::DictionaryValue> invalidation_dictionary(
585 new base::DictionaryValue());
586 for (const auto& map_iter : invalidation_versions) {
587 std::string version_str = base::NumberToString(map_iter.second);
588 invalidation_dictionary->SetString(ModelTypeToString(map_iter.first),
589 version_str);
590 }
591 pref_service_->Set(prefs::kSyncInvalidationVersions,
592 *invalidation_dictionary);
593 }
594
GetLastRunVersion() const595 std::string SyncPrefs::GetLastRunVersion() const {
596 return pref_service_->GetString(prefs::kSyncLastRunVersion);
597 }
598
SetLastRunVersion(const std::string & current_version)599 void SyncPrefs::SetLastRunVersion(const std::string& current_version) {
600 pref_service_->SetString(prefs::kSyncLastRunVersion, current_version);
601 }
602
IsLocalSyncEnabled() const603 bool SyncPrefs::IsLocalSyncEnabled() const {
604 return local_sync_enabled_;
605 }
606
MigrateSessionsToProxyTabsPrefs(PrefService * pref_service)607 void MigrateSessionsToProxyTabsPrefs(PrefService* pref_service) {
608 if (pref_service->GetUserPrefValue(prefs::kSyncTabs) == nullptr &&
609 pref_service->GetUserPrefValue(kSyncSessions) != nullptr &&
610 pref_service->IsUserModifiablePreference(prefs::kSyncTabs)) {
611 // If there is no tab sync preference yet (i.e. newly enabled type),
612 // default to the session sync preference value.
613 bool sessions_pref_value = pref_service->GetBoolean(kSyncSessions);
614 pref_service->SetBoolean(prefs::kSyncTabs, sessions_pref_value);
615 }
616 }
617
ClearObsoleteUserTypePrefs(PrefService * pref_service)618 void ClearObsoleteUserTypePrefs(PrefService* pref_service) {
619 for (const std::string& obsolete_pref : GetObsoleteUserTypePrefs()) {
620 pref_service->ClearPref(obsolete_pref);
621 }
622 }
623
ClearObsoleteClearServerDataPrefs(PrefService * pref_service)624 void ClearObsoleteClearServerDataPrefs(PrefService* pref_service) {
625 pref_service->ClearPref(kSyncPassphraseEncryptionTransitionInProgress);
626 pref_service->ClearPref(kSyncNigoriStateForPassphraseTransition);
627 }
628
ClearObsoleteAuthErrorPrefs(PrefService * pref_service)629 void ClearObsoleteAuthErrorPrefs(PrefService* pref_service) {
630 pref_service->ClearPref(kSyncHasAuthError);
631 }
632
ClearObsoleteFirstSyncTime(PrefService * pref_service)633 void ClearObsoleteFirstSyncTime(PrefService* pref_service) {
634 pref_service->ClearPref(kSyncFirstSyncTime);
635 }
636
ClearObsoleteSyncLongPollIntervalSeconds(PrefService * pref_service)637 void ClearObsoleteSyncLongPollIntervalSeconds(PrefService* pref_service) {
638 pref_service->ClearPref(kSyncLongPollIntervalSeconds);
639 }
640
641
MigrateSyncSuppressedPref(PrefService * pref_service)642 void MigrateSyncSuppressedPref(PrefService* pref_service) {
643 // If the new kSyncRequested already has a value, there's nothing to be
644 // done: Either the migration already happened, or we wrote to the new pref
645 // directly.
646 if (pref_service->GetUserPrefValue(prefs::kSyncRequested)) {
647 return;
648 }
649
650 // If the old kSyncSuppressed has an explicit value, migrate it over.
651 if (pref_service->GetUserPrefValue(kSyncSuppressStart)) {
652 pref_service->SetBoolean(prefs::kSyncRequested,
653 !pref_service->GetBoolean(kSyncSuppressStart));
654 pref_service->ClearPref(kSyncSuppressStart);
655 DCHECK(pref_service->GetUserPrefValue(prefs::kSyncRequested));
656 return;
657 }
658
659 // Neither old nor new pref have an explicit value. There should be nothing to
660 // migrate, but it turns out some users are in a state that depends on the
661 // implicit default value of the old pref (which was that Sync is NOT
662 // suppressed, i.e. Sync is requested), see crbug.com/973770. To migrate these
663 // users to the new pref correctly, use kSyncFirstSetupComplete as a signal
664 // that Sync should be considered requested.
665 if (pref_service->GetBoolean(prefs::kSyncFirstSetupComplete)) {
666 // CHECK rather than DCHECK to make sure we never accidentally enable Sync
667 // for users which had it previously disabled.
668 CHECK(!pref_service->GetBoolean(kSyncSuppressStart));
669 pref_service->SetBoolean(prefs::kSyncRequested, true);
670 DCHECK(pref_service->GetUserPrefValue(prefs::kSyncRequested));
671 return;
672 }
673 // Otherwise, nothing to be done: Sync was likely never enabled in this
674 // profile.
675 }
676
677 } // namespace syncer
678