Further tweaks to the passphrase UI to deal with passphrase entry....

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 48 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()),
+      tried_creating_explicit_passphrase_(false),
+      tried_setting_explicit_passphrase_(false),
       observed_passphrase_required_(false),
       passphrase_required_for_decryption_(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),
@@ skipping 933 matching lines @@
 
 void ProfileSyncService::DeactivateDataType(
     DataTypeController* data_type_controller,
     ChangeProcessor* change_processor) {
   change_processor->Stop();
   if (backend_.get())
     backend_->DeactivateDataType(data_type_controller, change_processor);
 }
 
 void ProfileSyncService::SetPassphrase(const std::string& passphrase,
-                                       bool is_explicit) {
+                                       bool is_explicit,
+                                       bool is_creation) {
   if (ShouldPushChanges() || observed_passphrase_required_) {
     backend_->SetPassphrase(passphrase, is_explicit);
   } else {
     cached_passphrase_.value = passphrase;
     cached_passphrase_.is_explicit = is_explicit;
+    cached_passphrase_.is_creation = is_creation;
   }
+
+  if (is_explicit && is_creation)
+    tried_creating_explicit_passphrase_ = true;
+  else if (is_explicit)
+    tried_setting_explicit_passphrase_ = true;
 }
 
 void ProfileSyncService::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::SYNC_CONFIGURE_START: {
       FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
       // TODO(sync): Maybe toast?
       break;
     }
     case NotificationType::SYNC_CONFIGURE_DONE: {
       DataTypeManager::ConfigureResult result =
           *(Details<DataTypeManager::ConfigureResult>(details).ptr());
       if (result == DataTypeManager::ABORTED &&
           expect_sync_configuration_aborted_) {
         expect_sync_configuration_aborted_ = false;
         return;
       }
       if (result != DataTypeManager::OK) {
         OnUnrecoverableError(FROM_HERE, "Sync Configuration failed.");
         return;
       }
 
       if (!cached_passphrase_.value.empty()) {
         // Don't hold on to the passphrase in raw form longer than needed.
         SetPassphrase(cached_passphrase_.value,
-                      cached_passphrase_.is_explicit);
+                      cached_passphrase_.is_explicit,
+                      cached_passphrase_.is_creation);
         cached_passphrase_ = CachedPassphrase();
       }
 
       // TODO(sync): Less wizard, more toast.
       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;
       passphrase_required_for_decryption_ = *(Details<bool>(details).ptr());
 
       if (!cached_passphrase_.value.empty()) {
         SetPassphrase(cached_passphrase_.value,
-                      cached_passphrase_.is_explicit);
+                      cached_passphrase_.is_explicit,
+                      cached_passphrase_.is_creation);
         cached_passphrase_ = CachedPassphrase();
         break;
       }
 
       if (WizardIsVisible()) {
         wizard_.Step(SyncSetupWizard::ENTER_PASSPHRASE);
       }
 
       FOR_EACH_OBSERVER(Observer, observers_, OnStateChanged());
       break;
     }
     case NotificationType::SYNC_DATA_TYPES_UPDATED: {
       if (!HasSyncSetupCompleted()) break;
 
       syncable::ModelTypeSet types;
       GetPreferredDataTypes(&types);
       OnUserChoseDatatypes(false, types);
       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;
+      tried_setting_explicit_passphrase_ = false;
+      tried_creating_explicit_passphrase_ = 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();
         }
       }
       break;
     }
     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);
+      SetPassphrase(successful->password, false, true);
       break;
     }
     case NotificationType::GOOGLE_SIGNIN_FAILED: {
       GoogleServiceAuthError error =
           *(Details<const GoogleServiceAuthError>(details).ptr());
       UpdateAuthErrorState(error);
       break;
     }
     case NotificationType::TOKEN_AVAILABLE: {
       if (AreCredentialsAvailable()) {
@@ skipping 76 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;
 }