[Sync] Move keystore key handling to SyncEncryptionHandlerImpl

sync/internal_api/sync_encryption_handler_impl_unittest.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 <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 22 matching lines @@
 using ::testing::Mock;
 using ::testing::StrictMock;
 
 class SyncEncryptionHandlerObserverMock
     : public SyncEncryptionHandler::Observer {
  public:
   MOCK_METHOD2(OnPassphraseRequired,
                void(PassphraseRequiredReason,
                     const sync_pb::EncryptedData&));  // NOLINT
   MOCK_METHOD0(OnPassphraseAccepted, void());  // NOLINT
-  MOCK_METHOD1(OnBootstrapTokenUpdated, void(const std::string&));  // NOLINT
+  MOCK_METHOD2(OnBootstrapTokenUpdated,
+               void(const std::string&, BootstrapTokenType type));  // NOLINT
   MOCK_METHOD2(OnEncryptedTypesChanged,
                void(ModelTypeSet, bool));  // NOLINT
   MOCK_METHOD0(OnEncryptionComplete, void());  // NOLINT
   MOCK_METHOD1(OnCryptographerStateChanged, void(Cryptographer*));  // NOLINT
   MOCK_METHOD1(OnPassphraseStateChanged, void(PassphraseState));  // NOLINT
 };
 
 }  // namespace
 
 class SyncEncryptionHandlerImplTest : public ::testing::Test {
  public:
   SyncEncryptionHandlerImplTest() {}
   virtual ~SyncEncryptionHandlerImplTest() {}
 
   virtual void SetUp() {
     test_user_share_.SetUp();
     SetUpEncryption();
     CreateRootForType(NIGORI);
   }
 
   virtual void TearDown() {
     test_user_share_.TearDown();
   }
 
  protected:
   void SetUpEncryption() {
-    ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler_.reset(
         new SyncEncryptionHandlerImpl(user_share(),
-                                      &encryptor_));
+                                      &encryptor_,
+                                      "", ""  /* bootstrap tokens */));
     encryption_handler_->AddObserver(&observer_);
   }
 
   void CreateRootForType(ModelType model_type) {
     syncer::syncable::Directory* directory = user_share()->directory.get();
 
     std::string tag_name = ModelTypeToRootTag(model_type);
 
     syncable::WriteTransaction wtrans(FROM_HERE, syncable::UNITTEST, directory);
     syncable::MutableEntry node(&wtrans,
@@ skipping 37 matching lines @@
   MessageLoop message_loop_;
 };
 
 // Verify that the encrypted types are being written to and read from the
 // nigori node properly.
 TEST_F(SyncEncryptionHandlerImplTest, NigoriEncryptionTypes) {
   sync_pb::NigoriSpecifics nigori;
 
   StrictMock<SyncEncryptionHandlerObserverMock> observer2;
   SyncEncryptionHandlerImpl handler2(user_share(),
-                                     &encryptor_);
+                                     &encryptor_,
+                                     "", ""  /* bootstrap tokens */);
   handler2.AddObserver(&observer2);
 
   // Just set the sensitive types (shouldn't trigger any notifications).
   ModelTypeSet encrypted_types(SyncEncryptionHandler::SensitiveTypes());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->MergeEncryptedTypes(
         encrypted_types,
         trans.GetWrappedTrans());
     encryption_handler()->UpdateNigoriFromEncryptedTypes(
@@ skipping 265 matching lines @@
     EXPECT_TRUE(GetCryptographer()->CanDecrypt(
         other_encrypted_specifics.encrypted()));
     EXPECT_TRUE(GetCryptographer()->CanDecrypt(nigori.encrypted()));
     EXPECT_TRUE(nigori.encrypt_everything());
     EXPECT_TRUE(
         GetCryptographer()->CanDecryptUsingDefaultKey(nigori.encrypted()));
   }
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
 }
 
+// Ensure setting the keystore key works, updates the bootstrap token, and
+// doesn't modify the cryptographer.
+TEST_F(SyncEncryptionHandlerImplTest, SetKeystoreUpdatedBoostrapToken) {
+  WriteTransaction trans(FROM_HERE, user_share());
+  EXPECT_CALL(*observer(), OnBootstrapTokenUpdated(_, _)).Times(0);
+  EXPECT_FALSE(GetCryptographer()->is_initialized());
+  EXPECT_TRUE(encryption_handler()->NeedKeystoreKey(trans.GetWrappedTrans()));
+  EXPECT_FALSE(encryption_handler()->SetKeystoreKey("",
+                                                    trans.GetWrappedTrans()));
+  EXPECT_TRUE(encryption_handler()->NeedKeystoreKey(trans.GetWrappedTrans()));
+  Mock::VerifyAndClearExpectations(observer());
+
+  const char kValidKey[] = "keystore_key";
+  EXPECT_CALL(*observer(),
+              OnBootstrapTokenUpdated(kValidKey, KEYSTORE_BOOTSTRAP_TOKEN));
+  EXPECT_TRUE(encryption_handler()->SetKeystoreKey(kValidKey,
+                                                   trans.GetWrappedTrans()));
+  EXPECT_FALSE(encryption_handler()->NeedKeystoreKey(trans.GetWrappedTrans()));
+  EXPECT_FALSE(GetCryptographer()->is_initialized());
+}
+
 }  // namespace syncer