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

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 238 matching lines @@
   }
   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 tried_creating_explicit_passphrase() const {
+    return tried_creating_explicit_passphrase_;
+  }
+
+  bool tried_setting_explicit_passphrase() const {
+    return tried_setting_explicit_passphrase_;
+  }
+
   bool observed_passphrase_required() const {
     return observed_passphrase_required_;
   }
 
   bool passphrase_required_for_decryption() const {
     return passphrase_required_for_decryption_;
   }
 
   // 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
@@ skipping 88 matching lines @@
   virtual bool IsUsingSecondaryPassphrase() const;
 
   // Sets the Cryptographer's passphrase, or caches it until that is possible.
   // This will check asynchronously whether the passphrase is valid and notify
   // ProfileSyncServiceObservers via the NotificationService when the outcome
   // is known.
   // |is_explicit| is true if the call is in response to the user explicitly
   // setting a passphrase as opposed to implicitly (from the users' perspective)
   // using their Google Account password.  An implicit SetPassphrase will *not*
   // *not* override an explicit passphrase set previously.
-  virtual void SetPassphrase(const std::string& passphrase, bool is_explicit);
+  // |is_creation| is true if the call is in response to the user setting
+  // up a new passphrase, and false if it's being set in response to a prompt
+  // for an existing passphrase.
+  virtual void SetPassphrase(const std::string& passphrase,
+                             bool is_explicit,
+                             bool is_creation);
 
   // Returns whether processing changes is allowed.  Check this before doing
   // any model-modifying operations.
   bool ShouldPushChanges();
 
   const GURL& sync_service_url() const { return sync_service_url_; }
   SigninManager* signin() { return signin_.get(); }
   const std::string& cros_user() const { return cros_user_; }
 
  protected:
@@ skipping 32 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 the user has tried creating an explicit passphrase on this
+  // machine.
+  bool tried_creating_explicit_passphrase_;
+
+  // Whether the user has tried setting an explicit passphrase on this
+  // machine.
+  bool tried_setting_explicit_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_;
 
   // Was the last SYNC_PASSPHRASE_REQUIRED notification sent because it
   // was required for decryption?
   bool passphrase_required_for_decryption_;
 
  private:
   friend class ProfileSyncServiceTest;
@@ skipping 90 matching lines @@
 
   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.
   struct CachedPassphrase {
     std::string value;
     bool is_explicit;
-    CachedPassphrase() : is_explicit(false) {}
+    bool is_creation;
+    CachedPassphrase() : is_explicit(false), is_creation(false) {}
   };
   CachedPassphrase cached_passphrase_;
 
   // TODO(tim): Remove this once new 'explicit passphrase' code flushes through
   // dev channel. See bug 62103.
   // To "migrate" early adopters of password sync on dev channel to the new
   // model that stores their secondary passphrase preference in the cloud, we
   // need some extra state since this cloud pref will be empty for all of them
   // regardless of how they set up sync, and we can't trust
   // kSyncUsingSecondaryPassphrase due to bugs in that implementation.
   bool tried_implicit_gaia_remove_when_bug_62103_fixed_;
 
   // 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 because 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_