[Sync] Move keystore key handling to SyncEncryptionHandlerImpl

sync/internal_api/sync_encryption_handler_impl.cc

 // 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.
 
 #include "sync/internal_api/sync_encryption_handler_impl.h"
 
 #include <queue>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 34 matching lines @@
 
 template <typename T>
 T* TransactionalHolder<T>::GetMutable(
     syncable::BaseTransaction* const trans) {
   DCHECK_EQ(user_share_->directory.get(), trans->directory());
   return obj_;
 }
 
 SyncEncryptionHandlerImpl::SyncEncryptionHandlerImpl(
     UserShare* user_share,
-    Encryptor* encryptor)
+    Encryptor* encryptor,
+    const std::string& restored_key_for_bootstrapping,
+    const std::string& restored_keystore_key_for_bootstrapping)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       user_share_(user_share),
       cryptographer_unsafe_(encryptor),
       encrypted_types_unsafe_(SensitiveTypes()),
       cryptographer_holder_(user_share_, &cryptographer_unsafe_),
       encrypted_types_holder_(user_share_, &encrypted_types_unsafe_),
       encrypt_everything_(false),
       passphrase_state_(IMPLICIT_PASSPHRASE),
+      keystore_key_(restored_keystore_key_for_bootstrapping),
       nigori_overwrite_count_(0) {
+  // We only bootstrap the user provided passphrase. The keystore key is handled
+  // at Init time once we're sure the nigori is downloaded.
+  cryptographer_unsafe_.Bootstrap(restored_key_for_bootstrapping);
 }
 
 SyncEncryptionHandlerImpl::~SyncEncryptionHandlerImpl() {}
 
 void SyncEncryptionHandlerImpl::AddObserver(Observer* observer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!observers_.HasObserver(observer));
   observers_.AddObserver(observer);
 }
 
@@ skipping 348 matching lines @@
 }
 
 void SyncEncryptionHandlerImpl::UpdateNigoriFromEncryptedTypes(
     sync_pb::NigoriSpecifics* nigori,
     syncable::BaseTransaction* const trans) const {
   syncable::UpdateNigoriFromEncryptedTypes(encrypted_types_holder_.Get(trans),
                                            encrypt_everything_,
                                            nigori);
 }
 
+bool SyncEncryptionHandlerImpl::NeedKeystoreKey(
+    syncable::BaseTransaction* const trans) const {
+  return keystore_key_.empty();
+}
+
+bool SyncEncryptionHandlerImpl::SetKeystoreKey(
+    const std::string& key,
+    syncable::BaseTransaction* const trans) {
+  if (!keystore_key_.empty() || key.empty())
+    return false;
+  keystore_key_ = key;
+
+  // TODO(zea): trigger migration if necessary.
+
+  DVLOG(1) << "Keystore bootstrap token updated.";
+  FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
+                    OnBootstrapTokenUpdated(key,
+                                            KEYSTORE_BOOTSTRAP_TOKEN));
+  return true;
+}
+
 ModelTypeSet SyncEncryptionHandlerImpl::GetEncryptedTypes(
     syncable::BaseTransaction* const trans) const {
   return encrypted_types_holder_.Get(trans);
 }
 
 // This function iterates over all encrypted types.  There are many scenarios in
 // which data for some or all types is not currently available.  In that case,
 // the lookup of the root node will fail and we will skip encryption for that
 // type.
 void SyncEncryptionHandlerImpl::ReEncryptEverything(
@@ skipping 234 matching lines @@
       observers_,
       OnCryptographerStateChanged(
           cryptographer_holder_.GetMutable(trans->GetWrappedTrans())));
 
   // It's possible we need to change the bootstrap token even if we failed to
   // set the passphrase (for example if we need to preserve the new GAIA
   // passphrase).
   if (!bootstrap_token.empty()) {
     DVLOG(1) << "Passphrase bootstrap token updated.";
     FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
-                      OnBootstrapTokenUpdated(bootstrap_token));
+                      OnBootstrapTokenUpdated(bootstrap_token,
+                                              PASSPHRASE_BOOTSTRAP_TOKEN));
   }
 
   const Cryptographer& cryptographer =
       cryptographer_holder_.Get(trans->GetWrappedTrans());
   if (!success) {
     if (cryptographer.is_ready()) {
       LOG(ERROR) << "Attempt to change passphrase failed while cryptographer "
                  << "was ready.";
     } else if (cryptographer.has_pending_keys()) {
       FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
                         OnPassphraseRequired(REASON_DECRYPTION,
                                              cryptographer.GetPendingKeys()));
     } else {
       FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
                         OnPassphraseRequired(REASON_ENCRYPTION,
                                              sync_pb::EncryptedData()));
     }
     return;
   }
 
   DCHECK(cryptographer.is_ready());
 
+  // TODO(zea): trigger migration if necessary.
+
   sync_pb::NigoriSpecifics specifics(nigori_node->GetNigoriSpecifics());
   // Does not modify specifics.encrypted() if the original decrypted data was
   // the same.
   if (!cryptographer.GetKeys(specifics.mutable_encrypted()))
     NOTREACHED();
   if (is_explicit && passphrase_state_ != CUSTOM_PASSPHRASE) {
     passphrase_state_ = CUSTOM_PASSPHRASE;
     FOR_EACH_OBSERVER(SyncEncryptionHandler::Observer, observers_,
                       OnPassphraseStateChanged(passphrase_state_));
   }
@@ skipping 16 matching lines @@
   ModelTypeSet* encrypted_types = encrypted_types_holder_.GetMutable(trans);
   if (!encrypted_types->HasAll(new_encrypted_types)) {
     *encrypted_types = new_encrypted_types;
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OnEncryptedTypesChanged(*encrypted_types, encrypt_everything_));
   }
 }
 
 }  // namespace browser_sync