[Sync] Support receiving early passphrase required information in Sync UI.

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 707 matching lines @@
   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;
   }
 
+  VLOG(1) << "Passphrase required with reason: "
+          << sync_api::PassphraseRequiredReasonToString(reason);
   passphrase_required_reason_ = reason;
 
   // 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 look for one.
   if (!IsEncryptedDatatypeEnabled() && IsPassphraseRequiredForDecryption()) {
     VLOG(1) << "Not decrypting and no encrypted datatypes enabled"
             << ", accepted passphrase.";
     OnPassphraseAccepted();
   }
@@ skipping 33 matching lines @@
   // this time.
   syncable::ModelTypeSet types;
   GetPreferredDataTypes(&types);
 
   // Reset passphrase_required_reason_ before configuring the DataTypeManager
   // since we know we no longer require the passphrase.
   passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
 
   if (data_type_manager_.get()) {
     // Unblock the data type manager if necessary.
+    // This will always trigger a SYNC_CONFIGURE_DONE on completion, which will
+    // step the UI wizard into DONE state (even if no datatypes have changed).
     data_type_manager_->Configure(types,
                                   sync_api::CONFIGURE_REASON_RECONFIGURATION);
   }
 
   NotifyObservers();
-
-  // TODO(tim): We shouldn't call this if !HasSyncSetupCompleted and the user
-  // isn't actually at the ENTER_PASSPHRASE screen.  It results in a
-  // LOG(WARNING) currently.
-  wizard_.Step(SyncSetupWizard::DONE);
 }
 
 void ProfileSyncService::OnEncryptionComplete(
     const syncable::ModelTypeSet& encrypted_types) {
   NotifyObservers();
 }
 
 void ProfileSyncService::OnMigrationNeededForTypes(
     const syncable::ModelTypeSet& types) {
   DCHECK(backend_initialized_);
@@ skipping 306 matching lines @@
 
     // We create the migrator at the same time.
     migrator_.reset(
         new browser_sync::BackendMigrator(this, data_type_manager_.get()));
   }
 
   syncable::ModelTypeSet types;
   GetPreferredDataTypes(&types);
   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.
-      VLOG(0) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
+      // We need a passphrase still. We don't bother to attempt to configure
+      // until we receive an OnPassphraseAccepted (which triggers a configure).
+      VLOG(1) << "ProfileSyncService::ConfigureDataTypeManager bailing out "
               << "because a passphrase required";
-      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()
       // will be called when configuration completes).
       passphrase_required_reason_ = sync_api::REASON_PASSPHRASE_NOT_REQUIRED;
     }
   }
 
@@ skipping 65 matching lines @@
     ChangeProcessor* change_processor) {
   if (!backend_.get())
     return;
   backend_->DeactivateDataType(data_type_controller, change_processor);
 }
 
 void ProfileSyncService::SetPassphrase(const std::string& passphrase,
                                        bool is_explicit,
                                        bool is_creation) {
   if (ShouldPushChanges() || IsPassphraseRequired()) {
+    VLOG(1) << "Setting " << (is_explicit ? "explicit" : "implicit")
+            << " passphrase " << (is_creation ? " for creation" : "");
     backend_->SetPassphrase(passphrase, is_explicit);
   } else {
     if (is_explicit) {
       cached_passphrase_.value = passphrase;
       cached_passphrase_.is_explicit = is_explicit;
       cached_passphrase_.is_creation = is_creation;
     } else {
       gaia_password_ = passphrase;
     }
   }
@@ skipping 186 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;
 }