Stop using browser signin for passphrase migration, just use the normal signi...

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 52 matching lines @@
 static const int kSyncClearDataTimeoutInSeconds = 60;  // 1 minute.
 
 ProfileSyncService::ProfileSyncService(ProfileSyncFactory* factory,
                                        Profile* profile,
                                        const std::string& cros_user)
     : last_auth_error_(AuthError::None()),
       tried_creating_explicit_passphrase_(false),
       tried_setting_explicit_passphrase_(false),
       observed_passphrase_required_(false),
       passphrase_required_for_decryption_(false),
+      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),
       ALLOW_THIS_IN_INITIALIZER_LIST(wizard_(this)),
       unrecoverable_error_detected_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(scoped_runnable_method_factory_(this)),
       token_migrator_(NULL),
@@ skipping 659 matching lines @@
   wizard_.Step(SyncSetupWizard::GAIA_LOGIN);
 
   NotifyObservers();
 }
 
 void ProfileSyncService::ShowErrorUI(gfx::NativeWindow parent_window) {
   if (observed_passphrase_required()) {
     if (IsUsingSecondaryPassphrase())
       PromptForExistingPassphrase(parent_window);
     else
-      ShowLoginDialog(parent_window);
+      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 ||
       error.state() == GoogleServiceAuthError::ACCOUNT_DISABLED ||
       error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE) {
     ShowLoginDialog(parent_window);
   }
@@ skipping 12 matching lines @@
 void ProfileSyncService::PromptForExistingPassphrase(
     gfx::NativeWindow parent_window) {
   if (WizardIsVisible()) {
     wizard_.Focus();
     return;
   }
   wizard_.SetParent(parent_window);
   wizard_.Step(SyncSetupWizard::ENTER_PASSPHRASE);
 }
 
-void ProfileSyncService::ShowPassphraseMigration(
+void ProfileSyncService::SigninForPassphraseMigration(
     gfx::NativeWindow parent_window) {
-  wizard_.SetParent(parent_window);
-  wizard_.Step(SyncSetupWizard::PASSPHRASE_MIGRATION);
-}
-
-void ProfileSyncService::SigninForPassphrase(TabContents* container) {
-  string16 prefilled_username = GetAuthenticatedUsername();
-  string16 login_message = sync_ui_util::GetLoginMessageForEncryption();
-  profile_->GetBrowserSignin()->RequestSignin(container,
-                                              prefilled_username,
-                                              login_message,
-                                              this);
+  passphrase_migration_in_progress_ = true;
+  ShowLoginDialog(parent_window);
 }
 
 SyncBackendHost::StatusSummary ProfileSyncService::QuerySyncStatusSummary() {
   if (backend_.get() && backend_initialized_)
     return backend_->GetStatusSummary();
   else
     return SyncBackendHost::Status::OFFLINE_UNUSABLE;
 }
 
 SyncBackendHost::Status ProfileSyncService::QueryDetailedSyncStatus() {
@@ skipping 320 matching lines @@
     case NotificationType::GOOGLE_SIGNIN_SUCCESSFUL: {
       const GoogleServiceSigninSuccessDetails* successful =
           (Details<const GoogleServiceSigninSuccessDetails>(details).ptr());
       // We pass 'false' to SetPassphrase to denote that this is an implicit
       // 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_) {
+        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);
       break;
     }
     case NotificationType::TOKEN_AVAILABLE: {
       if (AreCredentialsAvailable()) {
@@ skipping 15 matching lines @@
         DisableForUser();
       }
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
 
-// This is the delegate callback from BrowserSigin.
-void ProfileSyncService::OnLoginSuccess() {
-  // The reason for the browser signin was a non-explicit passphrase
-  // required signal.  If this is the first time through the passphrase
-  // process, we want to show the migration UI and offer an explicit
-  // passphrase.  Otherwise, we're done because the implicit is enough.
-
-  if (passphrase_required_for_decryption_) {
-    // NOT first time (decrypting something encrypted elsewhere).
-    // Do nothing.
-  } else {
-    ShowPassphraseMigration(NULL);
-  }
-}
-
-// This is the delegate callback from BrowserSigin.
-void ProfileSyncService::OnLoginFailure(const GoogleServiceAuthError& error) {
-  // Do nothing.  The UI will already reflect the fact that the
-  // user is not signed in.
-}
-
 void ProfileSyncService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void ProfileSyncService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 bool ProfileSyncService::HasObserver(Observer* observer) const {
   return observers_.HasObserver(observer);
@@ skipping 20 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;
 }