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

chrome/browser/sync/profile_sync_service.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #define CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_
 #pragma once
 
 #include <string>
 
@@ skipping 204 matching lines @@
   // re-authentication, and returns true if it actually opened the dialog.
   // Returns false if a dialog is already showing, an auth attempt is in
   // progress, the sync system is already authenticated, or some error
   // occurred preventing the action. We make it the duty of ProfileSyncService
   // to open the dialog to easily ensure only one is ever showing.
   virtual bool SetupInProgress() const;
   bool WizardIsVisible() const {
     return wizard_.IsVisible();
   }
   virtual void ShowLoginDialog(gfx::NativeWindow parent_window);
-  void ShowChooseDataTypes(gfx::NativeWindow parent_window);
+  void ShowConfigure(gfx::NativeWindow parent_window);
 
   // Pretty-printed strings for a given StatusSummary.
   static std::string BuildSyncStatusSummaryText(
       const browser_sync::SyncBackendHost::StatusSummary& summary);
 
   // Returns true if the SyncBackendHost has told us it's ready to accept
   // changes.
   // TODO(timsteele): What happens if the bookmark model is loaded, a change
   // takes place, and the backend isn't initialized yet?
   bool sync_initialized() const { return backend_initialized_; }
   bool unrecoverable_error_detected() const {
     return unrecoverable_error_detected_;
   }
   const std::string& unrecoverable_error_message() {
     return unrecoverable_error_message_;
   }
   tracked_objects::Location unrecoverable_error_location() {
     return unrecoverable_error_location_.get() ?
         *unrecoverable_error_location_.get() : tracked_objects::Location();
   }
 
   bool UIShouldDepictAuthInProgress() const {
     return is_auth_in_progress_;
   }
 
+  bool observed_passphrase_required() const {
+    return observed_passphrase_required_;
+  }
+
   // A timestamp marking the last time the service observed a transition from
   // the SYNCING state to the READY state. Note that this does not reflect the
   // last time we polled the server to see if there were any changes; the
   // timestamp is only snapped when syncing takes place and we download or
   // upload some bookmark entity.
   const base::Time& last_synced_time() const { return last_synced_time_; }
 
   // Returns a user-friendly string form of last synced time (in minutes).
   string16 GetLastSyncedTimeString() const;
 
@@ skipping 126 matching lines @@
   // service using this member. Captcha and error state are reflected.
   GoogleServiceAuthError last_auth_error_;
 
   // Our asynchronous backend to communicate with sync components living on
   // other threads.
   scoped_ptr<browser_sync::SyncBackendHost> backend_;
 
   // Cache of the last name the client attempted to authenticate.
   std::string last_attempted_user_email_;
 
+  // Whether we have seen a SYNC_PASSPHRASE_REQUIRED since initializing the
+  // backend, telling us that it is safe to send a passphrase down ASAP.
+  bool observed_passphrase_required_;
+
  private:
   friend class ProfileSyncServiceTest;
   friend class ProfileSyncServicePasswordTest;
   friend class ProfileSyncServicePreferenceTest;
   friend class ProfileSyncServiceSessionTest;
   friend class ProfileSyncServiceTestHarness;
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceTest, InitialState);
   FRIEND_TEST_ALL_PREFIXES(ProfileSyncServiceTest,
                            UnrecoverableErrorSuspendsService);
 
@@ skipping 82 matching lines @@
   bool expect_sync_configuration_aborted_;
 
   scoped_ptr<TokenMigrator> token_migrator_;
 
   // Sometimes we need to temporarily hold on to a passphrase because we don't
   // yet have a backend to send it to.  This happens during initialization as
   // we don't StartUp until we have a valid token, which happens after valid
   // credentials were provided.
   std::string cached_passphrase_;
 
-  // Whether we have seen a SYNC_PASSPHRASE_REQUIRED since initializing the
-  // backend, telling us that it is safe to send a passphrase down ASAP.
-  bool observed_passphrase_required_;
-
   // Keep track of where we are in a server clear operation
   ClearServerDataState clear_server_data_state_;
 
   // Timeout for the clear data command.  This timeout is a temporary hack
   // and is necessary becaue the nudge sync framework can drop nudges for
   // a wide variety of sync-related conditions (throttling, connections issues,
   // syncer paused, etc.).  It can only be removed correctly when the framework
   // is reworked to allow one-shot commands like clearing server data.
   base::OneShotTimer<ProfileSyncService> clear_server_data_timer_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncService);
 };
 
 #endif  // CHROME_BROWSER_SYNC_PROFILE_SYNC_SERVICE_H_