sync: Specialize functions that fetch type root

sync/internal_api/sync_encryption_handler_impl_unittest.cc

 // Copyright 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/base64.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 128 matching lines @@
                             const std::string& passphrase) {
     VerifyMigratedNigoriWithTimestamp(0, passphrase_type, passphrase);
   }
 
   void VerifyMigratedNigoriWithTimestamp(
       int64 migration_time,
       PassphraseType passphrase_type,
       const std::string& passphrase) {
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     const sync_pb::NigoriSpecifics& nigori = nigori_node.GetNigoriSpecifics();
     if (migration_time > 0)
       EXPECT_EQ(migration_time, nigori.keystore_migration_time());
     else
       EXPECT_TRUE(nigori.has_keystore_migration_time());
     EXPECT_TRUE(nigori.keybag_is_frozen());
     if (passphrase_type == CUSTOM_PASSPHRASE ||
         passphrase_type == FROZEN_IMPLICIT_PASSPHRASE) {
       EXPECT_TRUE(nigori.encrypt_everything());
       EXPECT_TRUE(nigori.keystore_decryptor_token().blob().empty());
@@ skipping 72 matching lines @@
   }
 
   // Build a migrated nigori node with the specified default passphrase
   // and keystore key and initialize the encryption handler with it.
   void InitKeystoreMigratedNigori(int64 migration_time,
                                   const std::string& default_passphrase,
                                   const std::string& keystore_key) {
     {
       WriteTransaction trans(FROM_HERE, user_share());
       WriteNode nigori_node(&trans);
-      ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+      ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
       sync_pb::NigoriSpecifics nigori = BuildMigratedNigori(
           KEYSTORE_PASSPHRASE,
           migration_time,
           default_passphrase,
           keystore_key);
       nigori_node.SetNigoriSpecifics(nigori);
     }
 
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE, _));
@@ skipping 12 matching lines @@
     Mock::VerifyAndClearExpectations(observer());
   }
 
   // Build a migrated nigori node with the specified default passphrase
   // as a custom passphrase.
   void InitCustomPassMigratedNigori(int64 migration_time,
                                     const std::string& default_passphrase) {
     {
       WriteTransaction trans(FROM_HERE, user_share());
       WriteNode nigori_node(&trans);
-      ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+      ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
       sync_pb::NigoriSpecifics nigori = BuildMigratedNigori(
           CUSTOM_PASSPHRASE,
           migration_time,
           default_passphrase,
           kKeystoreKey);
       nigori_node.SetNigoriSpecifics(nigori);
     }
 
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
@@ skipping 16 matching lines @@
                             PassphraseType passphrase_type) {
     DCHECK_NE(passphrase_type, FROZEN_IMPLICIT_PASSPHRASE);
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     KeyParams default_key = {"localhost", "dummy", default_passphrase};
     other_cryptographer.AddKey(default_key);
     EXPECT_TRUE(other_cryptographer.is_ready());
 
     {
       WriteTransaction trans(FROM_HERE, user_share());
       WriteNode nigori_node(&trans);
-      ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+      ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
       sync_pb::NigoriSpecifics nigori;
       other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
       nigori.set_keybag_is_frozen(passphrase_type == CUSTOM_PASSPHRASE);
       nigori_node.SetNigoriSpecifics(nigori);
     }
 
     if (passphrase_type != IMPLICIT_PASSPHRASE) {
       EXPECT_CALL(*observer(),
                   OnPassphraseTypeChanged(passphrase_type, _));
     }
@@ skipping 257 matching lines @@
   // specifics.
   PumpLoop();
 
   {
     // The cryptographer should be able to decrypt both sets of keys and still
     // be encrypting with the newest, and the encrypted types should be the
     // most recent.
     // In addition, the nigori node should match the current encryption state.
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     const sync_pb::NigoriSpecifics& nigori = nigori_node.GetNigoriSpecifics();
     EXPECT_TRUE(GetCryptographer()->CanDecryptUsingDefaultKey(
         our_encrypted_specifics.encrypted()));
     EXPECT_TRUE(GetCryptographer()->CanDecrypt(
         other_encrypted_specifics.encrypted()));
     EXPECT_TRUE(GetCryptographer()->CanDecrypt(nigori.encryption_keybag()));
     EXPECT_TRUE(nigori.encrypt_everything());
     EXPECT_TRUE(
         GetCryptographer()->CanDecryptUsingDefaultKey(
             nigori.encryption_keybag()));
@@ skipping 122 matching lines @@
     encryption_handler()->SetKeystoreKeys(BuildEncryptionKeyProto(
                                               kRawKeystoreKey),
                                           trans.GetWrappedTrans());
     Mock::VerifyAndClearExpectations(observer());
   }
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     KeyParams other_key = {"localhost", "dummy", kOtherKey};
     other_cryptographer.AddKey(other_key);
 
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(false);
     nigori.set_encrypt_everything(false);
     EXPECT_CALL(*observer(),
                 OnCryptographerStateChanged(_)).Times(AnyNumber());
@@ skipping 36 matching lines @@
     encryption_handler()->SetKeystoreKeys(BuildEncryptionKeyProto(
                                               kRawKeystoreKey),
                                           trans.GetWrappedTrans());
     Mock::VerifyAndClearExpectations(observer());
   }
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
 
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     KeyParams other_key = {"localhost", "dummy", kOtherKey};
     other_cryptographer.AddKey(other_key);
 
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_encrypt_everything(false);
     EXPECT_CALL(*observer(),
                 OnCryptographerStateChanged(_)).Times(AnyNumber());
@@ skipping 227 matching lines @@
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
   EXPECT_FALSE(GetCryptographer()->is_ready());
   EXPECT_NE(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
 
   // Now build a nigori node with the generated keystore decryptor token and
   // initialize the encryption handler with it. The cryptographer should be
   // initialized properly to decrypt both kCurKey and kKeystoreKey.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.mutable_keystore_decryptor_token()->CopyFrom(
         keystore_decryptor_token);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
 
     EXPECT_CALL(*observer(), OnPassphraseAccepted());
     EXPECT_CALL(*observer(),
@@ skipping 59 matching lines @@
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(FROZEN_IMPLICIT_PASSPHRASE, _));
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     EXPECT_CALL(*observer(),
                 OnCryptographerStateChanged(_)).Times(AnyNumber());
     EXPECT_CALL(*observer(),
                 OnEncryptedTypesChanged(_, true));
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.set_keybag_is_frozen(true);
     nigori.set_passphrase_type(
         sync_pb::NigoriSpecifics::FROZEN_IMPLICIT_PASSPHRASE);
     nigori.set_keystore_migration_time(1);
     nigori.set_encrypt_everything(true);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
@@ skipping 59 matching lines @@
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(CUSTOM_PASSPHRASE, _));
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     EXPECT_CALL(*observer(),
                 OnCryptographerStateChanged(_)).Times(AnyNumber());
     EXPECT_CALL(*observer(),
                 OnEncryptedTypesChanged(_, true));
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.set_keybag_is_frozen(true);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE);
     nigori.set_keystore_migration_time(1);
     nigori.set_encrypt_everything(true);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
   // Run any tasks posted via AppplyNigoriUpdate.
@@ skipping 41 matching lines @@
   sync_pb::EncryptedData encrypted;
   KeyParams old_key = {"localhost", "dummy", kOldKey};
   KeyParams cur_key = {"localhost", "dummy", kCurKey};
   GetCryptographer()->AddKey(old_key);
   GetCryptographer()->AddKey(cur_key);
 
   // Build a migrated nigori with full encryption.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     GetCryptographer()->GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE);
     nigori.set_encrypt_everything(true);
     nigori_node.SetNigoriSpecifics(nigori);
   }
 
   EXPECT_CALL(*observer(),
@@ skipping 24 matching lines @@
   // Now build an old unmigrated nigori node with old encrypted types. We should
   // properly overwrite it with the migrated + encrypt everything state.
   EXPECT_CALL(*observer(),
               OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(), OnEncryptionComplete());
   {
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     other_cryptographer.AddKey(old_key);
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(false);
     nigori.set_encrypt_everything(false);
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
   PumpLoop();
 
   // Verify we're still migrated and have proper encryption state.
@@ skipping 13 matching lines @@
   sync_pb::EncryptedData encrypted;
   KeyParams old_key = {"localhost", "dummy", kOldKey};
   KeyParams cur_key = {"localhost", "dummy", kCurKey};
   GetCryptographer()->AddKey(old_key);
   GetCryptographer()->AddKey(cur_key);
 
   // Build a migrated nigori with full encryption.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     GetCryptographer()->GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE);
     nigori.set_encrypt_everything(true);
     nigori_node.SetNigoriSpecifics(nigori);
   }
 
   EXPECT_CALL(*observer(),
@@ skipping 22 matching lines @@
   Mock::VerifyAndClearExpectations(observer());
 
   // Now build an old keystore nigori node with old encrypted types. We should
   // properly overwrite it with the migrated + encrypt everything state.
   EXPECT_CALL(*observer(),
               OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(), OnEncryptionComplete());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     other_cryptographer.AddKey(old_key);
     encryption_handler()->GetKeystoreDecryptor(
         other_cryptographer,
         kKeystoreKey,
         nigori.mutable_keystore_decryptor_token());
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_encrypt_everything(false);
@@ skipping 28 matching lines @@
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
   EXPECT_FALSE(GetCryptographer()->is_ready());
   EXPECT_NE(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
 
   // Now build a nigori node with the generated keystore decryptor token and
   // initialize the encryption handler with it. The cryptographer should be
   // initialized properly to decrypt both kCurKey and kKeystoreKey.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.mutable_keystore_decryptor_token()->CopyFrom(
         keystore_decryptor_token);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
 
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE, _));
@@ skipping 60 matching lines @@
       other_cryptographer,
       kKeystoreKey,
       &keystore_decryptor_token));
 
   // Build a nigori node with the generated keystore decryptor token and
   // initialize the encryption handler with it. The cryptographer should be
   // initialized properly to decrypt both kOldKey and kKeystoreKey.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.mutable_keystore_decryptor_token()->CopyFrom(
         keystore_decryptor_token);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
     nigori_node.SetNigoriSpecifics(nigori);
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
@@ skipping 81 matching lines @@
       other_cryptographer,
       kKeystoreKey,
       &keystore_decryptor_token));
 
   // Build a nigori node with the generated keystore decryptor token and
   // initialize the encryption handler with it. The cryptographer will have
   // pending keys until we provide the decryption passphrase.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.mutable_keystore_decryptor_token()->CopyFrom(
         keystore_decryptor_token);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
     nigori_node.SetNigoriSpecifics(nigori);
   }
 
@@ skipping 86 matching lines @@
       other_cryptographer,
       kKeystoreKey,
       &keystore_decryptor_token));
 
   // Build a nigori node with the generated keystore decryptor token and
   // initialize the encryption handler with it. The cryptographer will have
   // pending keys until we provide the decryption passphrase.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.mutable_keystore_decryptor_token()->CopyFrom(
         keystore_decryptor_token);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
     nigori_node.SetNigoriSpecifics(nigori);
   }
 
@@ skipping 74 matching lines @@
       other_cryptographer,
       kKeystoreKey,
       &keystore_decryptor_token));
 
   // Build a nigori node with the generated keystore decryptor token and
   // initialize the encryption handler with it. The cryptographer will have
   // pending keys until we provide the decryption passphrase.
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     nigori.mutable_keystore_decryptor_token()->CopyFrom(
         keystore_decryptor_token);
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
     nigori_node.SetNigoriSpecifics(nigori);
   }
   EXPECT_CALL(*observer(),
@@ skipping 97 matching lines @@
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   VerifyMigratedNigori(KEYSTORE_PASSPHRASE, kCurKey);
 
   // Now build an old keystore passphrase nigori node.
   EXPECT_CALL(*observer(),
               OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(), OnEncryptionComplete());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
-    ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
+    ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     other_cryptographer.AddKey(old_key);
     encryption_handler()->GetKeystoreDecryptor(
         other_cryptographer,
         kKeystoreKey,
         nigori.mutable_keystore_decryptor_token());
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(true);
     nigori.set_encrypt_everything(false);
@@ skipping 328 matching lines @@
     encryption_handler()->SetKeystoreKeys(keys,
                                           trans.GetWrappedTrans());
   }
   PumpLoop();
   Mock::VerifyAndClearExpectations(observer());
 
   VerifyMigratedNigoriWithTimestamp(1, CUSTOM_PASSPHRASE, kCustomPass);
 }
 
 }  // namespace syncer