Refactor sync passphrase setup flow and fix passphrase tests

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 50 matching lines @@
 
 const char* ProfileSyncService::kDevServerUrl =
     "https://clients4.google.com/chrome-sync/dev";
 
 static const int kSyncClearDataTimeoutInSeconds = 60;  // 1 minute.
 
 ProfileSyncService::ProfileSyncService(ProfileSyncFactory* factory,
                                        Profile* profile,
                                        const std::string& cros_user)
     : last_auth_error_(AuthError::None()),
-      observed_passphrase_required_(false),
-      passphrase_required_for_decryption_(false),
+      passphrase_required_reason_(sync_api::REASON_PASSPHRASE_NOT_REQUIRED),
       passphrase_migration_in_progress_(false),
       factory_(factory),
       profile_(profile),
       cros_user_(cros_user),
       sync_service_url_(kDevServerUrl),
       backend_initialized_(false),
       is_auth_in_progress_(false),
       wizard_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       unrecoverable_error_detected_(false),
       scoped_runnable_method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
@@ skipping 289 matching lines @@
   scoped_ptr<SyncBackendHost> doomed_backend(backend_.release());
   if (doomed_backend.get()) {
     doomed_backend->Shutdown(sync_disabled);
 
     doomed_backend.reset();
   }
 
   // Clear various flags.
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
-  observed_passphrase_required_ = false;
+  passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
   last_attempted_user_email_.clear();
   last_auth_error_ = GoogleServiceAuthError::None();
 }
 
 void ProfileSyncService::ClearServerData() {
   clear_server_data_state_ = CLEAR_CLEARING;
   clear_server_data_timer_.Start(
       base::TimeDelta::FromSeconds(kSyncClearDataTimeoutInSeconds), this,
       &ProfileSyncService::OnClearServerDataTimeout);
   backend_->RequestClearServerData();
@@ skipping 192 matching lines @@
   clear_server_data_timer_.Stop();
 
   // Even if the timout fired, we still transition to the succeeded state as
   // we want UI to update itself and no longer allow the user to press "clear"
   if (clear_server_data_state_ != CLEAR_SUCCEEDED) {
     clear_server_data_state_ = CLEAR_SUCCEEDED;
     NotifyObservers();
   }
 }
 
-void ProfileSyncService::OnPassphraseRequired(bool for_decryption) {
+void ProfileSyncService::OnPassphraseRequired(
+    sync_api::PassphraseRequiredReason reason) {
   DCHECK(backend_.get());
   DCHECK(backend_->IsNigoriEnabled());
 
   // TODO(lipalani) : add this check to other locations as well.
   if (unrecoverable_error_detected_) {
     // When unrecoverable error is detected we post a task to shutdown the
     // backend. The task might not have executed yet.
     return;
   }
-  observed_passphrase_required_ = true;
-  passphrase_required_for_decryption_ = for_decryption;
+
+  passphrase_required_reason_ = reason;
 
   if (!cached_passphrase_.value.empty()) {
     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() && for_decryption) {
+  // 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)) {
     OnPassphraseAccepted();
     return;
   }
 
-  if (WizardIsVisible() && for_decryption) {
+  if (WizardIsVisible() &&
+      (reason == sync_api::REASON_DECRYPTION ||
+       reason == sync_api::REASON_SET_PASSPHRASE_FAILED)) {
     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;
   GetPreferredDataTypes(&types);
-  // Reset "passphrase_required" flag before configuring the DataTypeManager
+
+  // Reset passphrase_required_reason_ before configuring the DataTypeManager
   // since we know we no longer require the passphrase.
-  observed_passphrase_required_ = false;
+  passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
+
   if (data_type_manager_.get())
     data_type_manager_->Configure(types);
 
   NotifyObservers();
 
   wizard_.Step(SyncSetupWizard::DONE);
 }
 
 void ProfileSyncService::OnEncryptionComplete(
     const syncable::ModelTypeSet& encrypted_types) {
@@ skipping 27 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 (observed_passphrase_required()) {
+  if (ObservedPassphraseRequired()) {
     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_ &&
-       observed_passphrase_required_));
+       ObservedPassphraseRequired()));
 }
 
 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 (observed_passphrase_required_ && passphrase_required_for_decryption_) {
+  if (passphrase_required_reason_ == sync_api::REASON_DECRYPTION ||
+      passphrase_required_reason_ == sync_api::REASON_SET_PASSPHRASE_FAILED) {
     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(true);
+      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 clear the flag
-      // (NotifyObservers() will be called when configuration completes).
-      observed_passphrase_required_ = false;
+      // now there are no encrypted data types enabled, so change the value of
+      // passphrase_required_reason_ to its default value. (NotifyObservers()
+      // will be called when configuration completes).
+      passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
     }
   }
   data_type_manager_->Configure(types);
 }
 
 sync_api::UserShare* ProfileSyncService::GetUserShare() const {
   if (backend_.get() && backend_initialized_) {
     return backend_->GetUserShare();
   }
   NOTREACHED();
@@ skipping 85 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() || observed_passphrase_required_) {
+  if (ShouldPushChanges() || ObservedPassphraseRequired()) {
     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 35 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(!(observed_passphrase_required_ &&
-               passphrase_required_for_decryption_ &&
-               !IsEncryptedDatatypeEnabled()));
+      DCHECK(passphrase_required_reason_ ==
+                 sync_api::REASON_PASSPHRASE_NOT_REQUIRED ||
+             passphrase_required_reason_ == sync_api::REASON_ENCRYPTION ||
+             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_for_decryption_) {
+          passphrase_required_reason_ != sync_api::REASON_DECRYPTION &&
+          passphrase_required_reason_ !=
+              sync_api::REASON_SET_PASSPHRASE_FAILED) {
         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;
 }