[Sync] Move keystore key handling to SyncEncryptionHandlerImpl

sync/util/cryptographer.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_UTIL_CRYPTOGRAPHER_H_
 #define SYNC_UTIL_CRYPTOGRAPHER_H_
 
 #include <map>
 #include <string>
 
@@ skipping 45 matching lines @@
   // Cryptographer instance into the ready state (is_ready will be true).
   // It must be a string that was previously built by the
   // GetSerializedBootstrapToken function.  It is possible that the token is no
   // longer valid (due to server key change), in which case the normal
   // decryption code paths will fail and the user will need to provide a new
   // passphrase.
   // It is an error to call this if is_ready() == true, though it is fair to
   // never call Bootstrap at all.
   void Bootstrap(const std::string& restored_bootstrap_token);
 
-  // Bootstrap the keystore key.
-  void BootstrapKeystoreKey(
-      const std::string& restored_keystore_bootstrap_token);
-
   // Returns whether we can decrypt |encrypted| using the keys we currently know
   // about.
   bool CanDecrypt(const sync_pb::EncryptedData& encrypted) const;
 
   // Returns whether |encrypted| can be decrypted using the default encryption
   // key.
   bool CanDecryptUsingDefaultKey(const sync_pb::EncryptedData& encrypted) const;
 
   // Encrypts |message| into |encrypted|. Does not overwrite |encrypted| if
   // |message| already matches the decrypted data within |encrypted| and
@@ skipping 48 matching lines @@
   // Attempts to decrypt the set of keys that was copied in the previous call to
   // SetPendingKeys using |params|. Returns true if the pending keys were
   // successfully decrypted and installed. If successful, the default key
   // is updated.
   bool DecryptPendingKeys(const KeyParams& params);
 
   // Sets the default key to the nigori with name |key_name|. |key_name| must
   // correspond to a nigori that has already been installed into the keybag.
   void SetDefaultKey(const std::string& key_name);
 
-  bool is_initialized() const { return !nigoris_.empty() && default_nigori_; }
+  bool is_initialized() const {
+    return !nigoris_.empty() && default_nigori_.get();
+  }
 
   // Returns whether this Cryptographer is ready to encrypt and decrypt data.
-  bool is_ready() const { return is_initialized() &&
-                          has_pending_keys() == false; }
+  bool is_ready() const {
+    return is_initialized() && !has_pending_keys();
+  }
 
   // Returns whether there is a pending set of keys that needs to be decrypted.
   bool has_pending_keys() const { return NULL != pending_keys_.get(); }
 
   // Obtain a token that can be provided on construction to a future
   // Cryptographer instance to bootstrap itself.  Returns false if such a token
   // can't be created (i.e. if this Cryptograhper doesn't have valid keys).
   bool GetBootstrapToken(std::string* token) const;
 
-  // Obtain the bootstrap token based on the keystore encryption key.
-  bool GetKeystoreKeyBootstrapToken(std::string* token) const;
-
-  // Set the keystore-derived nigori from the provided key.
-  // Returns true if we succesfully create the keystore derived nigori from the
-  // provided key, false otherwise.
-  bool SetKeystoreKey(const std::string& keystore_key);
-
-  // Returns true if we currently have a keystore-derived nigori, false
-  // otherwise.
-  bool HasKeystoreKey() const;
-
   Encryptor* encryptor() const { return encryptor_; }
 
  private:
   FRIEND_TEST_ALL_PREFIXES(SyncCryptographerTest, PackUnpack);
 
   typedef std::map<std::string, linked_ptr<const Nigori> > NigoriMap;
 
   // Helper method to instantiate Nigori instances for each set of key
   // parameters in |bag|.
   // Does not update the default nigori.
   void InstallKeyBag(const sync_pb::NigoriKeyBag& bag);
 
-  // Helper method to add a nigori as either the new default nigori or the new
-  // keystore nigori.
-  bool AddKeyImpl(Nigori* nigori, bool is_keystore_key);
+  // Helper method to add a nigori as the default key.
+  bool AddKeyImpl(scoped_ptr<Nigori> nigori);
 
   // Functions to serialize + encrypt a Nigori object in an opaque format for
   // persistence by sync infrastructure.
   bool PackBootstrapToken(const Nigori* nigori, std::string* pack_into) const;
   Nigori* UnpackBootstrapToken(const std::string& token) const;
 
   Encryptor* const encryptor_;
 
-  NigoriMap nigoris_;  // The Nigoris we know about, mapped by key name.
-  NigoriMap::value_type* default_nigori_;  // The Nigori used for encryption.
-  NigoriMap::value_type* keystore_nigori_; // Nigori generated from keystore.
+  // The Nigoris we know about, mapped by key name.
+  NigoriMap nigoris_;
+  // The following are cached separately for speed of access, and must exist
+  // within |nigoris_| if set.
+  // The key name associated with |default_nigori_|.
+  std::string default_nigori_name_;
+  // The Nigori used for encryption.
+  linked_ptr<const Nigori> default_nigori_;
 
   scoped_ptr<sync_pb::EncryptedData> pending_keys_;
 
   DISALLOW_COPY_AND_ASSIGN(Cryptographer);
 };
 
 }  // namespace syncer
 
 #endif  // SYNC_UTIL_CRYPTOGRAPHER_H_