[Sync] Refactor passphrase state handling

sync/internal_api/public/sync_encryption_handler.h

 // Copyright (c) 2012 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 SYNC_INTERNAL_API_PUBLIC_SYNC_ENCRYPTION_HANDLER_H_
 #define SYNC_INTERNAL_API_PUBLIC_SYNC_ENCRYPTION_HANDLER_H_
 
 #include <string>
 
 #include "sync/internal_api/public/base/model_type.h"
@@ skipping 11 matching lines @@
   REASON_PASSPHRASE_NOT_REQUIRED = 0,  // Initial value.
   REASON_ENCRYPTION = 1,               // The cryptographer requires a
                                        // passphrase for its first attempt at
                                        // encryption. Happens only during
                                        // migration or upgrade.
   REASON_DECRYPTION = 2,               // The cryptographer requires a
                                        // passphrase for its first attempt at
                                        // decryption.
 };
 
+// The different states for the encryption passphrase. These control if and how
+// the user should be prompted for a decryption passphrase.
+enum PassphraseState {
+  IMPLICIT_PASSPHRASE = 0,             // GAIA-based passphrase (deprecated).
+  KEYSTORE_PASSPHRASE = 1,             // Keystore passphrase.
+  FROZEN_IMPLICIT_PASSPHRASE = 2,      // Frozen GAIA passphrase.
+  CUSTOM_PASSPHRASE = 3,               // User-provided passphrase.
+};
+
 // Sync's encryption handler. Handles tracking encrypted types, ensuring the
 // cryptographer encrypts with the proper key and has the most recent keybag,
 // and keeps the nigori node up to date.
+// Implementations of this class must be assumed to be non-thread-safe. All
+// methods must be invoked on the sync thread.
 class SyncEncryptionHandler {
  public:
   // All Observer methods are done synchronously from within a transaction and
   // on the sync thread.
   class Observer {
    public:
     Observer();
 
     // Called when user interaction is required to obtain a valid passphrase.
     // - If the passphrase is required for encryption, |reason| will be
@@ skipping 41 matching lines @@
 
     // Called after we finish encrypting the current set of encrypted
     // types.
     virtual void OnEncryptionComplete() = 0;
 
     // The cryptographer has been updated. Listeners should check that their
     // own state matches the cryptographer.
     // Used primarily for debugging.
     virtual void OnCryptographerStateChanged(Cryptographer* cryptographer) = 0;
 
+    // The passprhase state has changed.
+    virtual void OnPassphraseStateChanged(PassphraseState state) = 0;
+
    protected:
     virtual ~Observer();
   };
 
   SyncEncryptionHandler();
   virtual ~SyncEncryptionHandler();
 
-  // Add/Remove SyncEncryptionHandler::Observer's.
-  // Must be called from sync thread.
+  // Add/Remove SyncEncryptionHandler::Observers.
   virtual void AddObserver(Observer* observer) = 0;
   virtual void RemoveObserver(Observer* observer) = 0;
 
   // Reads the nigori node, updates internal state as needed, and, if an
   // empty/stale nigori node is detected, overwrites the existing
   // nigori node. Upon completion, if the cryptographer is still ready
   // attempts to re-encrypt all sync data.
   // Note: This method is expensive (it iterates through all encrypted types),
   // so should only be used sparingly (e.g. on startup).
   virtual void Init() = 0;
@@ skipping 16 matching lines @@
   // error to call this when we don't have pending keys.
   virtual void SetDecryptionPassphrase(const std::string& passphrase) = 0;
 
   // Enables encryption of all datatypes.
   virtual void EnableEncryptEverything() = 0;
 
   // Whether encryption of all datatypes is enabled. If false, only sensitive
   // types are encrypted.
   virtual bool EncryptEverythingEnabled() const = 0;
 
-  // Whether the account requires a user-provided passphrase to decrypt
-  // encrypted data.
-  virtual bool IsUsingExplicitPassphrase() const = 0;
+  // Returns the current state of the passphrase needed to decrypt the
+  // bag of encryption keys in the nigori node.
+  virtual PassphraseState GetPassphraseState() const = 0;
 
   // The set of types that are always encrypted.
   static ModelTypeSet SensitiveTypes();
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_INTERNAL_API_PUBLIC_SYNC_ENCRYPTION_HANDLER_H_