Add method IsPassphraseRequiredForDecryption to ProfileSyncService

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync/profile_sync_service.h"
 
 #include <stddef.h>
 #include <map>
 #include <ostream>
 #include <set>
@@ skipping 598 matching lines @@
     SetPassphrase(cached_passphrase_.value,
                   cached_passphrase_.is_explicit,
                   cached_passphrase_.is_creation);
     cached_passphrase_ = CachedPassphrase();
     return;
   }
 
   // We will skip the passphrase prompt and suppress the warning if the
   // passphrase is needed for decryption but the user is not syncing an
   // encrypted data type on this machine. Otherwise we prompt.
-  if (!IsEncryptedDatatypeEnabled() &&
-      (reason == sync_api::REASON_DECRYPTION ||
-       reason == sync_api::REASON_SET_PASSPHRASE_FAILED)) {
+  if (!IsEncryptedDatatypeEnabled() && IsPassphraseRequiredForDecryption()) {
     OnPassphraseAccepted();
     return;
   }
 
-  if (WizardIsVisible() &&
-      (reason == sync_api::REASON_DECRYPTION ||
-       reason == sync_api::REASON_SET_PASSPHRASE_FAILED)) {
+  if (WizardIsVisible() && IsPassphraseRequiredForDecryption()) {
     wizard_.Step(SyncSetupWizard::ENTER_PASSPHRASE);
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnPassphraseAccepted() {
   // Make sure the data types that depend on the passphrase are started at
   // this time.
   syncable::ModelTypeSet types;
@@ skipping 43 matching lines @@
                              base::TimeTicks::Now() - auth_error_time_);
     auth_error_time_ = base::TimeTicks();  // Reset auth_error_time_ to null.
   }
 
   wizard_.Step(SyncSetupWizard::GAIA_LOGIN);
 
   NotifyObservers();
 }
 
 void ProfileSyncService::ShowErrorUI(gfx::NativeWindow parent_window) {
-  if (ObservedPassphraseRequired()) {
+  if (IsPassphraseRequired()) {
     if (IsUsingSecondaryPassphrase())
       PromptForExistingPassphrase(parent_window);
     else
       SigninForPassphraseMigration(parent_window);
     return;
   }
   const GoogleServiceAuthError& error = GetAuthError();
   if (error.state() == GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS ||
       error.state() == GoogleServiceAuthError::CAPTCHA_REQUIRED ||
       error.state() == GoogleServiceAuthError::ACCOUNT_DELETED ||
@@ skipping 235 matching lines @@
   for (DataTypeController::TypeMap::const_iterator it =
        data_type_controllers_.begin();
        it != data_type_controllers_.end(); ++it) {
     registered_types->insert((*it).first);
   }
 }
 
 bool ProfileSyncService::IsUsingSecondaryPassphrase() const {
   return backend_.get() && (backend_->IsUsingExplicitPassphrase() ||
       (tried_implicit_gaia_remove_when_bug_62103_fixed_ &&
-       ObservedPassphraseRequired()));
+       IsPassphraseRequired()));
 }
 
 bool ProfileSyncService::IsCryptographerReady(
     const sync_api::BaseTransaction* trans) const {
   return backend_.get() && backend_->IsCryptographerReady(trans);
 }
 
 SyncBackendHost* ProfileSyncService::GetBackendForTest() {
   // We don't check |backend_initialized_|; we assume the test class
   // knows what it's doing.
@@ skipping 20 matching lines @@
   syncable::ModelTypeSet types;
   GetPreferredDataTypes(&types);
   // We set this special case here since it's the only datatype whose encryption
   // status we already know. All others are set after the initial sync
   // completes (for now).
   // TODO(zea): Implement a better way that uses preferences for which types
   // need encryption.
   encrypted_types_.clear();
   if (types.count(syncable::PASSWORDS) > 0)
     encrypted_types_.insert(syncable::PASSWORDS);
-  if (passphrase_required_reason_ == sync_api::REASON_DECRYPTION ||
-      passphrase_required_reason_ == sync_api::REASON_SET_PASSPHRASE_FAILED) {
+  if (IsPassphraseRequiredForDecryption()) {
     if (IsEncryptedDatatypeEnabled()) {
       // We need a passphrase still. Prompt the user for a passphrase, and
       // DataTypeManager::Configure() will get called once the passphrase is
       // accepted.
       OnPassphraseRequired(passphrase_required_reason_);
       return;
     } else {
       // We've been informed that a passphrase is required for decryption, but
       // now there are no encrypted data types enabled, so change the value of
       // passphrase_required_reason_ to its default value. (NotifyObservers()
@@ skipping 97 matching lines @@
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   change_processor->Stop();
   if (backend_.get())
     backend_->DeactivateDataType(data_type_controller, change_processor);
 }
 
 void ProfileSyncService::SetPassphrase(const std::string& passphrase,
                                        bool is_explicit,
                                        bool is_creation) {
-  if (ShouldPushChanges() || ObservedPassphraseRequired()) {
+  if (ShouldPushChanges() || IsPassphraseRequired()) {
     backend_->SetPassphrase(passphrase, is_explicit);
   } else {
     cached_passphrase_.value = passphrase;
     cached_passphrase_.is_explicit = is_explicit;
     cached_passphrase_.is_creation = is_creation;
   }
 }
 
 void ProfileSyncService::EncryptDataTypes(
     const syncable::ModelTypeSet& encrypted_types) {
@@ skipping 34 matching lines @@
 
       if (!cached_passphrase_.value.empty()) {
         // Don't hold on to the passphrase in raw form longer than needed.
         SetPassphrase(cached_passphrase_.value,
                       cached_passphrase_.is_explicit,
                       cached_passphrase_.is_creation);
         cached_passphrase_ = CachedPassphrase();
       }
 
       // We should never get in a state where we have no encrypted datatypes
-      // enabled, and yet we still think we require a passphrase.
-      DCHECK(passphrase_required_reason_ ==
-                 sync_api::REASON_PASSPHRASE_NOT_REQUIRED ||
-             passphrase_required_reason_ == sync_api::REASON_ENCRYPTION ||
-             IsEncryptedDatatypeEnabled());
+      // enabled, and yet we still think we require a passphrase for decryption.
+      DCHECK(!(IsPassphraseRequiredForDecryption() &&
+               !IsEncryptedDatatypeEnabled()));
 
       // TODO(sync): Less wizard, more toast.
       wizard_.Step(SyncSetupWizard::DONE);
       NotifyObservers();
 
       // In the old world, this would be a no-op.  With new syncer thread,
       // this is the point where it is safe to switch from config-mode to
       // normal operation.
       backend_->StartSyncingWithServer();
       break;
@@ skipping 25 matching lines @@
       // request and shouldn't override an explicit one.  Thus, we either
       // update the implicit passphrase (idempotent if the passphrase didn't
       // actually change), or the user has an explicit passphrase set so this
       // becomes a no-op.
       tried_implicit_gaia_remove_when_bug_62103_fixed_ = true;
       SetPassphrase(successful->password, false, true);
 
       // If this signin was to initiate a passphrase migration (on the
       // first computer, thus not for decryption), continue the migration.
       if (passphrase_migration_in_progress_ &&
-          passphrase_required_reason_ != sync_api::REASON_DECRYPTION &&
-          passphrase_required_reason_ !=
-              sync_api::REASON_SET_PASSPHRASE_FAILED) {
+          IsPassphraseRequiredForEncryption()) {

[Raghu Simha, 2011/05/02 23:47:23]

Tim: This line requires special attention. With the old logic, this used to be
"!passphrase_required_for_decryption_". I believe it's equivalent to
IsPassphraseRequiredForEncryption. Could you confirm?

[tim (not reviewing), 2011/05/03 00:06:59]

The previous logic seems to also include NOT_REQUIRED?

[Raghu Simha, 2011/05/03 00:24:00]

I was talking about the previous previous logic in
http://codereview.chromium.org/6902101/diff/7025/chrome/browser/sync/profile_...
line 1205. But you're right. I've changed this to
!IsPassphraseRequiredForDecryption().

         wizard_.Step(SyncSetupWizard::PASSPHRASE_MIGRATION);
         passphrase_migration_in_progress_ = false;
       }
 
       break;
     }
     case NotificationType::GOOGLE_SIGNIN_FAILED: {
       GoogleServiceAuthError error =
           *(Details<const GoogleServiceAuthError>(details).ptr());
       UpdateAuthErrorState(error);
@@ skipping 63 matching lines @@
   // is initialized, all enabled data types are consistent with one
   // another, and no unrecoverable error has transpired.
   if (unrecoverable_error_detected_)
     return false;
 
   if (!data_type_manager_.get())
     return false;
 
   return data_type_manager_->state() == DataTypeManager::CONFIGURED;
 }