Fix some problems with the ENTER_PASSPHRASE state in sync setup....

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2010 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 <map>
 #include <set>
 
 #include "app/l10n_util.h"
@@ skipping 44 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),
       factory_(factory),
       profile_(profile),
       cros_user_(cros_user),
       sync_service_url_(kDevServerUrl),
       backend_initialized_(false),
       is_auth_in_progress_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(wizard_(this)),
       unrecoverable_error_detected_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(scoped_runnable_method_factory_(this)),
       token_migrator_(NULL),
-      observed_passphrase_required_(false),
+
       clear_server_data_state_(CLEAR_NOT_STARTED) {
   DCHECK(factory);
   DCHECK(profile);
   registrar_.Add(this,
                  NotificationType::SYNC_DATA_TYPES_UPDATED,
                  Source<Profile>(profile));
 
   // By default, dev & chromium users will go to the development servers.
   // Dev servers have more features than standard sync servers.
   // Chrome stable and beta builds will go to the standard sync servers.
@@ skipping 471 matching lines @@
   // The very first time the backend initializes is effectively the first time
   // we can say we successfully "synced".  last_synced_time_ will only be null
   // in this case, because the pref wasn't restored on StartUp.
   if (last_synced_time_.is_null()) {
     UpdateLastSyncedTime();
   }
   FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
 
   if (!cros_user_.empty()) {
     if (profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart)) {
-      ShowChooseDataTypes(NULL);
+      ShowConfigure(NULL);
     } else {
       SetSyncSetupCompleted();
     }
   }
 
   if (HasSyncSetupCompleted()) {
     ConfigureDataTypeManager();
   }
 }
 
@@ skipping 83 matching lines @@
     return;
   }
 
   if (!auth_error_time_.is_null()) {
     UMA_HISTOGRAM_LONG_TIMES("Sync.ReauthorizationTime",
                              base::TimeTicks::Now() - auth_error_time_);
     auth_error_time_ = base::TimeTicks();  // Reset auth_error_time_ to null.
   }
 
   wizard_.SetParent(parent_window);
-  wizard_.Step(SyncSetupWizard::GAIA_LOGIN);
+  // This method will also be called if a passphrase is needed.
+  if (observed_passphrase_required_)
+    wizard_.Step(SyncSetupWizard::ENTER_PASSPHRASE);
+  else
+    wizard_.Step(SyncSetupWizard::GAIA_LOGIN);
 
   FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
 }
 
-void ProfileSyncService::ShowChooseDataTypes(gfx::NativeWindow parent_window) {
+void ProfileSyncService::ShowConfigure(gfx::NativeWindow parent_window) {
   if (WizardIsVisible()) {
     wizard_.Focus();
     return;
   }
   wizard_.SetParent(parent_window);
   wizard_.Step(SyncSetupWizard::CONFIGURE);
 }
 
 SyncBackendHost::StatusSummary ProfileSyncService::QuerySyncStatusSummary() {
   if (backend_.get() && backend_initialized_)
@@ skipping 263 matching lines @@
         return;
       }
 
       if (!cached_passphrase_.empty()) {
         // Don't hold on to the passphrase in raw form longer than needed.
         SetPassphrase(cached_passphrase_);
         cached_passphrase_.clear();
       }
 
       // TODO(sync): Less wizard, more toast.
-      wizard_.Step(SyncSetupWizard::DONE);
+      if (!observed_passphrase_required_)
+        wizard_.Step(SyncSetupWizard::DONE);
       FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
 
       break;
     }
     case NotificationType::SYNC_PASSPHRASE_REQUIRED: {
       DCHECK(backend_.get());
       DCHECK(backend_->IsNigoriEnabled());
       observed_passphrase_required_ = true;
 
       if (!cached_passphrase_.empty()) {
@@ skipping 19 matching lines @@
       break;
     }
     case NotificationType::SYNC_PASSPHRASE_ACCEPTED: {
       // Make sure the data types that depend on the passphrase are started at
       // this time.
       syncable::ModelTypeSet types;
       GetPreferredDataTypes(&types);
       data_type_manager_->Configure(types);
 
       FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
+      observed_passphrase_required_ = false;
+      wizard_.Step(SyncSetupWizard::DONE);
       break;
     }
     case NotificationType::PREF_CHANGED: {
       std::string* pref_name = Details<std::string>(details).ptr();
       if (*pref_name == prefs::kSyncManaged) {
         FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
         if (*pref_sync_managed_) {
           DisableForUser();
         } else if (HasSyncSetupCompleted() && AreCredentialsAvailable()) {
           StartUp();
@@ skipping 75 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;
 }