Refactor sync passphrase setup flow and fix passphrase tests

chrome/browser/sync/glue/sync_backend_host.h

 // 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.
 
 #ifndef CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #define CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 61 matching lines @@
   virtual void OnAuthError() = 0;
 
   // We are no longer permitted to communicate with the server. Sync should
   // be disabled and state cleaned up at once.
   virtual void OnStopSyncingPermanently() = 0;
 
   // Called to handle success/failure of clearing server data
   virtual void OnClearServerDataSucceeded() = 0;
   virtual void OnClearServerDataFailed() = 0;
 
-  // The syncer requires a passphrase to decrypt sensitive
-  // updates. This is called when the first sensitive data type is
-  // setup by the user as well as anytime any the passphrase is
-  // changed in another synced client.  if
-  // |passphrase_required_for_decryption| is false, the passphrase is
-  // required only for encryption.
-  virtual void OnPassphraseRequired(bool for_decryption) = 0;
+  // The syncer requires a passphrase to decrypt sensitive updates. This is
+  // called when the first sensitive data type is setup by the user and anytime
+  // the passphrase is changed by another synced client. |reason| denotes why
+  // the passphrase was required.
+  virtual void OnPassphraseRequired(
+      sync_api::PassphraseRequiredReason reason) = 0;
 
   // Called when the passphrase provided by the user is
   // accepted. After this is called, updates to sensitive nodes are
   // encrypted using the accepted passphrase.
   virtual void OnPassphraseAccepted() = 0;
 
   virtual void OnEncryptionComplete(
       const syncable::ModelTypeSet& encrypted_types) = 0;
 
   // Called to perform migration of |types|.
@@ skipping 171 matching lines @@
     virtual void OnChangesApplied(
         syncable::ModelType model_type,
         const sync_api::BaseTransaction* trans,
         const sync_api::SyncManager::ChangeRecord* changes,
         int change_count);
     virtual void OnChangesComplete(syncable::ModelType model_type);
     virtual void OnSyncCycleCompleted(
         const sessions::SyncSessionSnapshot* snapshot);
     virtual void OnInitializationComplete();
     virtual void OnAuthError(const GoogleServiceAuthError& auth_error);
-    virtual void OnPassphraseRequired(bool for_decryption);
-    virtual void OnPassphraseFailed();
+    virtual void OnPassphraseRequired(
+        sync_api::PassphraseRequiredReason reason);
     virtual void OnPassphraseAccepted(const std::string& bootstrap_token);
     virtual void OnStopSyncingPermanently();
     virtual void OnUpdatedToken(const std::string& token);
     virtual void OnClearServerDataFailed();
     virtual void OnClearServerDataSucceeded();
     virtual void OnEncryptionComplete(
         const syncable::ModelTypeSet& encrypted_types);
 
     // JsBackend implementation.
     virtual void SetParentJsEventRouter(JsEventRouter* router);
@@ skipping 57 matching lines @@
     void DoRequestClearServerData();
 
     // Sets |deferred_nudge_for_cleanup_requested_| to true. See comment below.
     void DeferNudgeForCleanup();
 
     // Called on our SyncBackendHost's |core_thread_| to set the passphrase
     // on behalf of SyncBackendHost::SupplyPassphrase.
     void DoSetPassphrase(const std::string& passphrase, bool is_explicit);
 
     // Getter/setter for whether we are waiting on SetPassphrase to process a
-    // passphrase. Set by SetPassphrase, cleared by OnPassphraseFailed or
+    // passphrase. Set by SetPassphrase, cleared by OnPassphraseRequired or
     // OnPassphraseAccepted.
     bool processing_passphrase() const;
     void set_processing_passphrase();
 
     // Called on SyncBackendHost's |core_thread_| to set the datatypes we need
     // to encrypt as well as encrypt all local data of that type.
     void DoEncryptDataTypes(const syncable::ModelTypeSet& encrypted_types);
 
     // The shutdown order is a bit complicated:
     // 1) From |core_thread_|, invoke the syncapi Shutdown call to do a final
@@ skipping 73 matching lines @@
     // off as soon as the SyncManager tells us it completed
     // initialization.
     void SaveChanges();
 
     // Dispatched to from HandleAuthErrorEventOnCoreLoop to handle updating
     // frontend UI components.
     void HandleAuthErrorEventOnFrontendLoop(
         const GoogleServiceAuthError& new_auth_error);
 
     // Invoked when a passphrase is required to decrypt a set of Nigori keys,
-    // or for encrypting.  If the reason is decryption, |for_decryption| will
-    // be true.
-    void NotifyPassphraseRequired(bool for_decryption);
-
-    // Invoked when the syncer attempts to set a passphrase but fails to decrypt
-    // the cryptographer's pending keys. This tells the profile sync service
-    // that a new passphrase is required.
-    void NotifyPassphraseFailed();
+    // or for encrypting. |reason| denotes why the passhrase was required.
+    void NotifyPassphraseRequired(sync_api::PassphraseRequiredReason reason);
 
     // Invoked when the passphrase provided by the user has been accepted.
     void NotifyPassphraseAccepted(const std::string& bootstrap_token);
 
     // Invoked when an updated token is available from the sync server.
     void NotifyUpdatedToken(const std::string& token);
 
     // Invoked when sync finishes encrypting new datatypes or has become aware
     // of new datatypes requiring encryption.
     void NotifyEncryptionComplete(const syncable::ModelTypeSet&
@@ skipping 174 matching lines @@
 
   // Whether we've processed the initialization complete callback.
   bool syncapi_initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncBackendHost);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_GLUE_SYNC_BACKEND_HOST_H_