sync_service_utils.cc 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126
  1. // Copyright 2015 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. #include "components/sync/driver/sync_service_utils.h"
  5. #include "base/feature_list.h"
  6. #include "base/metrics/histogram_functions.h"
  7. #include "base/metrics/histogram_macros.h"
  8. #include "components/sync/base/features.h"
  9. #include "components/sync/base/passphrase_enums.h"
  10. #include "components/sync/driver/sync_service.h"
  11. #include "components/sync/driver/sync_user_settings.h"
  12. #include "google_apis/gaia/google_service_auth_error.h"
  13. namespace syncer {
  14. UploadState GetUploadToGoogleState(const SyncService* sync_service,
  15. ModelType type) {
  16. // Note: Before configuration is done, GetPreferredDataTypes returns
  17. // "everything" (i.e. the default setting). If a data type is missing there,
  18. // it must be because the user explicitly disabled it.
  19. if (!sync_service || sync_service->IsLocalSyncEnabled() ||
  20. !sync_service->CanSyncFeatureStart() ||
  21. !sync_service->GetPreferredDataTypes().Has(type)) {
  22. return UploadState::NOT_ACTIVE;
  23. }
  24. // If the given ModelType is encrypted with a custom passphrase, we also
  25. // consider uploading inactive, since Google can't read the data.
  26. // Note that encryption is tricky: Some data types (e.g. PASSWORDS) are always
  27. // encrypted, but not necessarily with a custom passphrase. On the other hand,
  28. // some data types are never encrypted (e.g. DEVICE_INFO), even if the
  29. // "encrypt everything" setting is enabled.
  30. if (sync_service->GetUserSettings()->GetEncryptedDataTypes().Has(type) &&
  31. sync_service->GetUserSettings()->IsUsingExplicitPassphrase()) {
  32. return UploadState::NOT_ACTIVE;
  33. }
  34. // Persistent auth errors always map to NOT_ACTIVE. For transient errors, we
  35. // give the benefit of the doubt and may still say we're INITIALIZING.
  36. if (sync_service->GetAuthError().IsPersistentError()) {
  37. return UploadState::NOT_ACTIVE;
  38. }
  39. switch (sync_service->GetTransportState()) {
  40. case SyncService::TransportState::DISABLED:
  41. case SyncService::TransportState::PAUSED:
  42. return UploadState::NOT_ACTIVE;
  43. case SyncService::TransportState::START_DEFERRED:
  44. case SyncService::TransportState::INITIALIZING:
  45. case SyncService::TransportState::PENDING_DESIRED_CONFIGURATION:
  46. case SyncService::TransportState::CONFIGURING:
  47. return UploadState::INITIALIZING;
  48. case SyncService::TransportState::ACTIVE:
  49. // If sync is active, but the data type in question still isn't, then
  50. // something must have gone wrong with that data type.
  51. if (!sync_service->GetActiveDataTypes().Has(type)) {
  52. return UploadState::NOT_ACTIVE;
  53. }
  54. if (sync_service->GetAuthError().IsTransientError()) {
  55. return UploadState::INITIALIZING;
  56. }
  57. // TODO(crbug.com/831579): We only know if the refresh token is actually
  58. // valid (no auth error) after we've tried talking to the Sync server.
  59. if (!sync_service->HasCompletedSyncCycle()) {
  60. return UploadState::INITIALIZING;
  61. }
  62. return UploadState::ACTIVE;
  63. }
  64. NOTREACHED();
  65. return UploadState::NOT_ACTIVE;
  66. }
  67. void RecordKeyRetrievalTrigger(TrustedVaultUserActionTriggerForUMA trigger) {
  68. base::UmaHistogramEnumeration("Sync.TrustedVaultKeyRetrievalTrigger",
  69. trigger);
  70. }
  71. void RecordRecoverabilityDegradedFixTrigger(
  72. TrustedVaultUserActionTriggerForUMA trigger) {
  73. base::UmaHistogramEnumeration(
  74. "Sync.TrustedVaultRecoverabilityDegradedFixTrigger", trigger);
  75. }
  76. bool ShouldOfferTrustedVaultOptIn(const SyncService* service) {
  77. if (!service) {
  78. return false;
  79. }
  80. if (service->GetTransportState() != SyncService::TransportState::ACTIVE) {
  81. // Transport state must be active so SyncUserSettings::GetPassphraseType()
  82. // changes once the opt-in completes, and the UI is notified.
  83. return false;
  84. }
  85. const ModelTypeSet encrypted_types =
  86. service->GetUserSettings()->GetEncryptedDataTypes();
  87. if (Intersection(service->GetActiveDataTypes(), encrypted_types).Empty()) {
  88. // No point in offering the user a new encryption method if they are not
  89. // syncing any encrypted types.
  90. return false;
  91. }
  92. switch (service->GetUserSettings()->GetPassphraseType()) {
  93. case PassphraseType::kImplicitPassphrase:
  94. case PassphraseType::kFrozenImplicitPassphrase:
  95. case PassphraseType::kCustomPassphrase:
  96. case PassphraseType::kTrustedVaultPassphrase:
  97. // Either trusted vault is already set or a transition from this
  98. // passphrase type to trusted vault is disallowed.
  99. return false;
  100. case PassphraseType::kKeystorePassphrase:
  101. if (service->GetUserSettings()->IsPassphraseRequired()) {
  102. // This should be extremely rare.
  103. return false;
  104. }
  105. return base::FeatureList::IsEnabled(
  106. kSyncTrustedVaultPassphraseRecovery) &&
  107. base::FeatureList::IsEnabled(kSyncTrustedVaultPassphrasePromo);
  108. }
  109. }
  110. } // namespace syncer