Moved the handling of the initial passphrase into SyncSetupFlow.

chrome/browser/sync/sync_setup_flow.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/sync_setup_flow.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 16 matching lines @@
 namespace {
 
 // Helper function to disable password sync.
 void DisablePasswordSync(ProfileSyncService* service) {
   syncable::ModelTypeSet types;
   service->GetPreferredDataTypes(&types);
   types.erase(syncable::PASSWORDS);
   service->OnUserChoseDatatypes(false, types);
 }
 
-// Fills |args| for the enter passphrase screen.
-void GetArgsForEnterPassphrase(bool tried_creating_explicit_passphrase,
-                               bool tried_setting_explicit_passphrase,
-                               DictionaryValue* args) {
-  args->SetBoolean("show_passphrase", true);
-  args->SetBoolean("passphrase_creation_rejected",
-                   tried_creating_explicit_passphrase);
-  args->SetBoolean("passphrase_setting_rejected",
-                   tried_setting_explicit_passphrase);
-}
-
 // Returns the next step for the non-fatal error case.
 SyncSetupWizard::State GetStepForNonFatalError(ProfileSyncService* service) {
   // TODO(sync): Update this error handling to allow different platforms to
   // display the error appropriately (http://crbug.com/92722) instead of
   // navigating to a LOGIN state that is not supported on every platform.
   if (service->IsPassphraseRequired()) {
     if (service->IsUsingSecondaryPassphrase())
       return SyncSetupWizard::ENTER_PASSPHRASE;
     return SyncSetupWizard::GetLoginState();
   }
@@ skipping 24 matching lines @@
   flow_handler_->SetFlow(NULL);
 }
 
 // static
 SyncSetupFlow* SyncSetupFlow::Run(ProfileSyncService* service,
                                   SyncSetupFlowContainer* container,
                                   SyncSetupWizard::State start,
                                   SyncSetupWizard::State end) {
   if (start == SyncSetupWizard::NONFATAL_ERROR)
     start = GetStepForNonFatalError(service);
-
-  DictionaryValue args;
-  if (start == SyncSetupWizard::GAIA_LOGIN)
-    SyncSetupFlow::GetArgsForGaiaLogin(service, &args);
-  else if (start == SyncSetupWizard::CONFIGURE)
-    SyncSetupFlow::GetArgsForConfigure(service, &args);
-  else if (start == SyncSetupWizard::ENTER_PASSPHRASE)
-    GetArgsForEnterPassphrase(false, false, &args);
-
-  std::string json_args;
-  base::JSONWriter::Write(&args, false, &json_args);
-
-  return new SyncSetupFlow(start, end, json_args, container, service);
+  return new SyncSetupFlow(start, end, container, service);
 }
 
 // static
 void SyncSetupFlow::GetArgsForGaiaLogin(const ProfileSyncService* service,
                                         DictionaryValue* args) {
   const GoogleServiceAuthError& error = service->GetAuthError();
   if (!service->last_attempted_user_email().empty()) {
     args->SetString("user", service->last_attempted_user_email());
     args->SetInteger("error", error.state());
     args->SetBoolean("editable_user", true);
   } else {
     string16 user;
     if (!service->cros_user().empty())
       user = UTF8ToUTF16(service->cros_user());
     else
       user = service->GetAuthenticatedUsername();
     args->SetString("user", user);
     args->SetInteger("error", 0);
     args->SetBoolean("editable_user", user.empty());
   }
 
   args->SetString("captchaUrl", error.captcha().image_url.spec());
 }
 
-// static
 void SyncSetupFlow::GetArgsForConfigure(ProfileSyncService* service,
                                         DictionaryValue* args) {
   // The SYNC_EVERYTHING case will set this to true.
   args->SetBoolean("showSyncEverythingPage", false);
 
   args->SetBoolean("keepEverythingSynced",
       service->profile()->GetPrefs()->GetBoolean(prefs::kKeepEverythingSynced));
 
   // Bookmarks, Preferences, and Themes are launched for good, there's no
   // going back now.  Check if the other data types are registered though.
@@ skipping 40 matching lines @@
   syncable::ModelTypeSet encrypted_types;
   service->GetEncryptedDataTypes(&encrypted_types);
   bool encrypt_all =
       encrypted_types.upper_bound(syncable::PASSWORDS) != encrypted_types.end();
   if (service->HasPendingEncryptedTypes())
     encrypt_all = true;
   args->SetBoolean("encryptAllData", encrypt_all);
 
   // Load the parameters for the encryption tab.
   args->SetBoolean("usePassphrase", service->IsUsingSecondaryPassphrase());
+
+  // Determine if we need a passphrase or not, and if so, prompt the user.
+  if (service->IsPassphraseRequiredForDecryption() &&
+      (service->IsUsingSecondaryPassphrase() || cached_passphrase_.empty())) {
+    // We need a passphrase, and either it's an explicit passphrase, or we
+    // don't have a cached gaia passphrase, so we have to prompt the user.
+    args->SetBoolean("show_passphrase", true);
+  }
+  args->SetBoolean("passphrase_creation_rejected",
+                   tried_creating_explicit_passphrase_);
+  args->SetBoolean("passphrase_setting_rejected",
+                   tried_setting_explicit_passphrase_);
 }
 
 bool SyncSetupFlow::AttachSyncSetupHandler(SyncSetupFlowHandler* handler) {
   if (flow_handler_)
     return false;
 
   flow_handler_ = handler;
   handler->SetFlow(this);
   ActivateState(current_state_);
   return true;
@@ skipping 61 matching lines @@
   }
 
   service_->OnUserCancelledDialog();
   delete this;
 }
 
 void SyncSetupFlow::OnUserSubmittedAuth(const std::string& username,
                                         const std::string& password,
                                         const std::string& captcha,
                                         const std::string& access_code) {
+  cached_passphrase_ = password;
   service_->OnUserSubmittedAuth(username, password, captcha, access_code);
 }
 
 void SyncSetupFlow::OnUserConfigured(const SyncConfiguration& configuration) {
   // Go to the "loading..." screen.
   Advance(SyncSetupWizard::SETTING_UP);
 
   // Note: encryption will not occur until OnUserChoseDatatypes is called.
   syncable::ModelTypeSet encrypted_types;
   if (configuration.encrypt_all) {
     // Encrypt all registered types.
     service_->GetRegisteredDataTypes(&encrypted_types);
   }  // Else we clear the pending types for encryption.
   service_->set_pending_types_for_encryption(encrypted_types);
 
   if (!configuration.gaia_passphrase.empty()) {
     // Caller passed a gaia passphrase. This is illegal if we are currently
     // using a secondary passphrase.
     DCHECK(!service_->IsUsingSecondaryPassphrase());
-    service_->SetPassphrase(configuration.gaia_passphrase, false, false);
+    service_->SetPassphrase(configuration.gaia_passphrase, false);
+  } else if (!service_->IsUsingSecondaryPassphrase() &&
+             !cached_passphrase_.empty()) {
+    // Service needs a GAIA passphrase and we have one cached, so try it.
+    service_->SetPassphrase(cached_passphrase_, false);
+    cached_passphrase_.clear();
+  } else {
+    // No gaia passphrase cached or set, so make sure the ProfileSyncService
+    // wasn't expecting one.
+    DCHECK(!service_->IsPassphraseRequiredForDecryption() ||
+           service_->IsUsingSecondaryPassphrase());
   }
 
   // It's possible the user has to provide a secondary passphrase even when
   // they have not set one previously. This occurs when the user has changed
   // their gaia password and then sign in to a new machine for the first time.
   // The new machine will download data encrypted with their old gaia password,
   // which their current gaia password will not be able to decrypt, triggering
   // a prompt for a passphrase. At this point, the user must enter their old
   // password, which we store as a new secondary passphrase.
   // TODO(zea): eventually use the above gaia_passphrase instead of the
   // secondary passphrase in this case.
   if (configuration.use_secondary_passphrase) {
-    if (!service_->IsUsingSecondaryPassphrase()) {
-      service_->SetPassphrase(configuration.secondary_passphrase, true, true);
+    service_->SetPassphrase(configuration.secondary_passphrase, true);
+    if (service_->IsUsingSecondaryPassphrase())
+      tried_setting_explicit_passphrase_ = true;
+    else
       tried_creating_explicit_passphrase_ = true;
-    } else {
-      service_->SetPassphrase(configuration.secondary_passphrase, true, false);
-      tried_setting_explicit_passphrase_ = true;
-    }
   }
 
   service_->OnUserChoseDatatypes(configuration.sync_everything,
                                  configuration.data_types);
 }
 
 void SyncSetupFlow::OnPassphraseEntry(const std::string& passphrase) {
   Advance(SyncSetupWizard::SETTING_UP);
-  service_->SetPassphrase(passphrase, true, false);
+  service_->SetPassphrase(passphrase, true);
   tried_setting_explicit_passphrase_ = true;
 }
 
 void SyncSetupFlow::OnPassphraseCancel() {
   // If the user cancels when being asked for the passphrase,
   // just disable encrypted sync and continue setting up.
   if (current_state_ == SyncSetupWizard::ENTER_PASSPHRASE)
     DisablePasswordSync(service_);
 
   Advance(SyncSetupWizard::SETTING_UP);
 }
 
 // Use static Run method to get an instance.
 SyncSetupFlow::SyncSetupFlow(SyncSetupWizard::State start_state,
                              SyncSetupWizard::State end_state,
-                             const std::string& args,
                              SyncSetupFlowContainer* container,
                              ProfileSyncService* service)
     : container_(container),
-      dialog_start_args_(args),
       current_state_(start_state),
       end_state_(end_state),
       login_start_time_(base::TimeTicks::Now()),
       flow_handler_(NULL),
       service_(service),
       tried_creating_explicit_passphrase_(false),
       tried_setting_explicit_passphrase_(false) {
 }
 
 // Returns true if the flow should advance to |state| based on |current_state_|.
@@ skipping 70 matching lines @@
     }
     case SyncSetupWizard::CONFIGURE: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForConfigure(service_, &args);
       flow_handler_->ShowConfigure(args);
       break;
     }
     case SyncSetupWizard::ENTER_PASSPHRASE: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForConfigure(service_, &args);
-      GetArgsForEnterPassphrase(tried_creating_explicit_passphrase_,
-                                tried_setting_explicit_passphrase_,
-                                &args);
+      GetArgsForConfigure(service_, &args);
+      // TODO(atwilson): Remove ShowPassphraseEntry in favor of using
+      // ShowConfigure() - http://crbug.com/90786.
       flow_handler_->ShowPassphraseEntry(args);
       break;
     }
     case SyncSetupWizard::SETUP_ABORTED_BY_PENDING_CLEAR: {
       DictionaryValue args;
       SyncSetupFlow::GetArgsForConfigure(service_, &args);
       args.SetBoolean("was_aborted", true);
       flow_handler_->ShowConfigure(args);
       break;
     }
@@ skipping 12 matching lines @@
       break;
     }
     case SyncSetupWizard::DONE:
       flow_handler_->ShowSetupDone(
           UTF16ToWide(service_->GetAuthenticatedUsername()));
       break;
     default:
       NOTREACHED() << "Invalid advance state: " << state;
   }
 }