Moved the handling of the initial passphrase into SyncSetupFlow.

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 <set>
 #include <utility>
@@ skipping 77 matching lines @@
       cros_user_(cros_user),
       sync_service_url_(kDevServerUrl),
       backend_initialized_(false),
       is_auth_in_progress_(false),
       wizard_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       signin_(signin_manager),
       unrecoverable_error_detected_(false),
       scoped_runnable_method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       expect_sync_configuration_aborted_(false),
       clear_server_data_state_(CLEAR_NOT_STARTED),
-      set_backend_encrypted_types_(false) {
+      set_backend_encrypted_types_(false),
+      auto_start_enabled_(false) {
   // By default, dev, canary, and unbranded Chromium users will go to the
   // development servers. Development servers have more features than standard
   // sync servers. Users with officially-branded Chrome stable and beta builds
   // will go to the standard sync servers.
   //
   // GetChannel hits the registry on Windows. See http://crbug.com/70380.
   base::ThreadRestrictions::ScopedAllowIO allow_io;
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE ||
       channel == chrome::VersionInfo::CHANNEL_BETA) {
     sync_service_url_ = GURL(kSyncServerUrl);
   }
+
+  // TODO(atwilson): Set auto_start_enabled_ for other platforms that want this
+  // functionality.
+  if (!cros_user_.empty())
+    auto_start_enabled_ = true;
 }
 
 ProfileSyncService::~ProfileSyncService() {
   Shutdown(false);
 }
 
 bool ProfileSyncService::AreCredentialsAvailable() {
   if (IsManaged()) {
     return false;
   }
@@ skipping 40 matching lines @@
   // so only initialize this if the token service has not been initialized
   // (e.g. the browser crashed or is being debugged).
   if (cros_user_.empty() ||
       !profile_->GetTokenService()->Initialized()) {
     // Will load tokens from DB and broadcast Token events after.
     // Note: We rely on signin_ != NULL unless !cros_user_.empty().
     signin_->Initialize(profile_);
   }
 
   if (!HasSyncSetupCompleted()) {
-    // Under ChromeOS, just autostart it anyway if creds are here and start
-    // is not being suppressed by preferences.
-    if (!cros_user_.empty() &&
+    // If autostart is enabled, but we haven't completed sync setup, try to
+    // start sync anyway (it's possible we crashed/shutdown after logging in
+    // but before the backend finished initializing the last time).
+    if (auto_start_enabled_ &&
         !profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart) &&
         AreCredentialsAvailable()) {
       StartUp();
     }
   } else if (AreCredentialsAvailable()) {
     // If we have credentials and sync setup finished, autostart the backend.
     // Note that if we haven't finished setting up sync, backend bring up will
     // be done by the wizard.
     StartUp();
   }
 }
 
 void ProfileSyncService::RegisterAuthNotifications() {
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_AVAILABLE,
                  Source<TokenService>(profile_->GetTokenService()));
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_LOADING_FINISHED,
                  Source<TokenService>(profile_->GetTokenService()));
   registrar_.Add(this,
                  chrome::NOTIFICATION_TOKEN_REQUEST_FAILED,
                  Source<TokenService>(profile_->GetTokenService()));
   registrar_.Add(this,
-                 chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
-                 Source<Profile>(profile_));
-  registrar_.Add(this,
                  chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED,
                  Source<Profile>(profile_));
 }
 
 void ProfileSyncService::RegisterDataTypeController(
     DataTypeController* data_type_controller) {
   DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       data_type_controller;
 }
@@ skipping 254 matching lines @@
 
     doomed_backend.reset();
   }
 
   scoped_runnable_method_factory_.RevokeAll();
 
   // Clear various flags.
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
-  cached_passphrase_ = CachedPassphrase();
-  gaia_password_.clear();
+  cached_passphrases_ = CachedPassphrases();
   pending_types_for_encryption_.clear();
   set_backend_encrypted_types_ = 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(FROM_HERE,
@@ skipping 152 matching lines @@
   sync_js_controller_.AttachJsBackend(js_backend);
 
   // 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();
   }
   NotifyObservers();
 
-  if (!cros_user_.empty()) {
+  if (auto_start_enabled_ && !SetupInProgress()) {
+    // Backend is initialized but we're not in sync setup, so this must be an
+    // autostart - mark our sync setup as completed.
     if (profile_->GetPrefs()->GetBoolean(prefs::kSyncSuppressStart)) {
+      // TODO(sync): This call to ShowConfigure() should go away in favor
+      // of the code below that calls wizard_.Step() - http://crbug.com/95269.
       ShowConfigure(true);
       return;
     } else {
       SetSyncSetupCompleted();
     }
   }
 
   if (HasSyncSetupCompleted()) {
     ConfigureDataTypeManager();
   } else if (SetupInProgress()) {
@@ skipping 143 matching lines @@
   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;
 
-  // Store any passphrases we have into temps and clear out the originals so
-  // we don't hold on to the passphrases any longer than we have to. We
-  // then use the passphrases if they're present (after OnPassphraseAccepted).
-  std::string gaia_password = gaia_password_;
-  std::string cached_passphrase = cached_passphrase_.value;
-  bool is_explicit = cached_passphrase_.is_explicit;
-  bool is_creation = cached_passphrase_.is_creation;
-  gaia_password_ = std::string();
-  cached_passphrase_ = CachedPassphrase();
-
   // 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) << "Decrypting and no encrypted datatypes enabled"
             << ", accepted passphrase.";
     OnPassphraseAccepted();
   }
 
   // First try supplying gaia password as the passphrase.
-  if (!gaia_password.empty()) {
+  // TODO(atwilson): This logic seems odd here - we know what kind of passphrase
+  // is required (explicit/gaia) so we should not bother setting the wrong kind
+  // of passphrase - http://crbug.com/95269.
+  if (!cached_passphrases_.gaia_passphrase.empty()) {
+    std::string gaia_passphrase = cached_passphrases_.gaia_passphrase;
+    cached_passphrases_.gaia_passphrase.clear();
     VLOG(1) << "Attempting gaia passphrase.";
-    // SetPassphrase will set gaia_password_ if the syncer isn't ready.
-    SetPassphrase(gaia_password, false, true);
+    // SetPassphrase will re-cache this passphrase if the syncer isn't ready.
+    SetPassphrase(gaia_passphrase, false);
     return;
   }
 
   // If the above failed then try the custom passphrase the user might have
   // entered in setup.
-  if (!cached_passphrase.empty()) {
-    VLOG(1) << "Attempting cached passphrase.";
-    // SetPassphrase will set cached_passphrase_ if the syncer isn't ready.
-    SetPassphrase(cached_passphrase, is_explicit, is_creation);
+  if (!cached_passphrases_.explicit_passphrase.empty()) {
+    std::string explicit_passphrase = cached_passphrases_.explicit_passphrase;
+    cached_passphrases_.explicit_passphrase.clear();
+    VLOG(1) << "Attempting explicit passphrase.";
+    // SetPassphrase will re-cache this passphrase if the syncer isn't ready.
+    SetPassphrase(explicit_passphrase, true);
     return;
   }
 
   // Prompt the user for a password.
   if (WizardIsVisible() && IsEncryptedDatatypeEnabled() &&
       IsPassphraseRequiredForDecryption()) {
     VLOG(1) << "Prompting user for passphrase.";
     wizard_.Step(SyncSetupWizard::ENTER_PASSPHRASE);
   }
 
   NotifyObservers();
 }
 
 void ProfileSyncService::OnPassphraseAccepted() {
   VLOG(1) << "Received OnPassphraseAccepted.";
   // Don't hold on to a passphrase in raw form longer than needed.
-  gaia_password_ = std::string();
-  cached_passphrase_ = CachedPassphrase();
+  cached_passphrases_ = CachedPassphrases();
 
   // Make sure the data types that depend on the passphrase are started at
   // 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;
 
@@ skipping 456 matching lines @@
   backend_->ActivateDataType(type, group, change_processor);
 }
 
 void ProfileSyncService::DeactivateDataType(syncable::ModelType type) {
   if (!backend_.get())
     return;
   backend_->DeactivateDataType(type);
 }
 
 void ProfileSyncService::SetPassphrase(const std::string& passphrase,
-                                       bool is_explicit,
-                                       bool is_creation) {
+                                       bool is_explicit) {
   if (ShouldPushChanges() || IsPassphraseRequired()) {
-    VLOG(1) << "Setting " << (is_explicit ? "explicit" : "implicit")
-            << " passphrase" << (is_creation ? " for creation" : "");
+    VLOG(1) << "Setting " << (is_explicit ? "explicit" : "implicit");
     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;
+      cached_passphrases_.explicit_passphrase = passphrase;
     } else {
-      gaia_password_ = passphrase;
+      cached_passphrases_.gaia_passphrase = passphrase;
     }
   }
 }
 
 void ProfileSyncService::set_pending_types_for_encryption(
     const syncable::ModelTypeSet& encrypted_types) {
   set_backend_encrypted_types_ = false;
   if (encrypted_types.empty()) {
     // We can't unencrypt types.
     VLOG(1) << "No datatypes set for encryption, dropping encryption request.";
@@ skipping 48 matching lines @@
         expect_sync_configuration_aborted_ = false;
         return;
       }
       if (status != DataTypeManager::OK) {
         VLOG(0) << "ProfileSyncService::Observe: Unrecoverable error detected";
         std::string message =
           "Sync Configuration failed while configuring " +
           syncable::ModelTypeSetToString(result->failed_types) +
           ": " + DataTypeManager::ConfigureStatusToString(status);
         OnUnrecoverableError(result->location, message);
-        cached_passphrase_ = CachedPassphrase();
+        cached_passphrases_ = CachedPassphrases();
         return;
       }
 
       // We should never get in a state where we have no encrypted datatypes
       // enabled, and yet we still think we require a passphrase for decryption.
       DCHECK(!(IsPassphraseRequiredForDecryption() &&
                !IsEncryptedDatatypeEnabled()));
 
       // 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
@@ skipping 18 matching lines @@
       if (*pref_name == prefs::kSyncManaged) {
         NotifyObservers();
         if (*pref_sync_managed_) {
           DisableForUser();
         } else if (HasSyncSetupCompleted() && AreCredentialsAvailable()) {
           StartUp();
         }
       }
       break;
     }
-    case chrome::NOTIFICATION_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.
-      if (browser_sync::IsUsingOAuth()) {
-        // TODO(rickcam): Bug 92323: Fetch password through special Gaia request
-        DCHECK(successful->password.empty());
-        LOG(WARNING) << "Not initializing sync passphrase.";
-      } else {
-        SetPassphrase(successful->password, false, true);
-      }
-      break;
-    }
     case chrome::NOTIFICATION_GOOGLE_SIGNIN_FAILED: {
       GoogleServiceAuthError error =
           *(Details<const GoogleServiceAuthError>(details).ptr());
       UpdateAuthErrorState(error);
       break;
     }
     case chrome::NOTIFICATION_TOKEN_REQUEST_FAILED: {
       GoogleServiceAuthError error(
           GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
       UpdateAuthErrorState(error);
@@ skipping 99 matching lines @@
         syncable::ModelTypeBitSetFromValue(
             *profile_->GetPrefs()->GetList(prefs::kAcknowledgedSyncTypes));
     syncable::ModelTypeSet registered;
     GetRegisteredDataTypes(&registered);
     syncable::ModelTypeBitSet registered_bit_set =
         syncable::ModelTypeBitSetFromSet(registered);
     unacknowledged = registered_bit_set & ~acknowledged;
   }
   return unacknowledged;
 }
-