[Sync] Add keystore encryption info to about:sync

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/base64.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 14 matching lines @@
 #include "sync/test/fake_encryptor.h"
 #include "sync/util/cryptographer.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 using ::testing::_;
+using ::testing::AnyNumber;
 using ::testing::Mock;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
 // The raw keystore key the server sends.
 static const char kRawKeystoreKey[] = "keystore_key";
 // Base64 encoded version of |kRawKeystoreKey|.
 static const char kKeystoreKey[] = "a2V5c3RvcmVfa2V5";
 
 class SyncEncryptionHandlerObserverMock
@@ skipping 332 matching lines @@
   sync_pb::NigoriSpecifics current_nigori_specifics;
   GetCryptographer()->AddKey(old_key);
   GetCryptographer()->AddKey(current_key);
   GetCryptographer()->Encrypt(
       our_encrypted_specifics,
       our_encrypted_specifics.mutable_encrypted());
   GetCryptographer()->GetKeys(
       current_nigori_specifics.mutable_encryption_keybag());
   current_nigori_specifics.set_encrypt_everything(true);
 
-  EXPECT_CALL(*observer(), OnCryptographerStateChanged(_));
+  EXPECT_CALL(*observer(), OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(), OnEncryptedTypesChanged(
       HasModelTypes(UserTypes()), true));
   {
     // Update the encryption handler.
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->ApplyNigoriUpdate(
         current_nigori_specifics,
         trans.GetWrappedTrans());
   }
   Mock::VerifyAndClearExpectations(observer());
 
   // Now set up the old nigori specifics and apply it on top.
   // Has an old set of keys, and no encrypted types.
   sync_pb::NigoriSpecifics old_nigori;
   other_cryptographer.GetKeys(old_nigori.mutable_encryption_keybag());
 
-  EXPECT_CALL(*observer(), OnCryptographerStateChanged(_));
+  EXPECT_CALL(*observer(), OnCryptographerStateChanged(_)).Times(AnyNumber());
   {
     // Update the encryption handler.
     WriteTransaction trans(FROM_HERE, user_share());
     encryption_handler()->ApplyNigoriUpdate(
         old_nigori,
         trans.GetWrappedTrans());
   }
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_FALSE(GetCryptographer()->has_pending_keys());
 
@@ skipping 90 matching lines @@
     ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), 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(_));
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
   // Run any tasks posted via AppplyNigoriUpdate.
   PumpLoop();
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
   encryption_handler()->SetDecryptionPassphrase(kOtherKey);
@@ skipping 23 matching lines @@
     ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), 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(_));
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
   // Run any tasks posted via AppplyNigoriUpdate.
   PumpLoop();
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete()).Times(2);
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
   encryption_handler()->SetDecryptionPassphrase(kOtherKey);
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(CUSTOM_PASSPHRASE, encryption_handler()->GetPassphraseType());
   VerifyMigratedNigori(CUSTOM_PASSPHRASE, kOtherKey);
 }
 
 // Test that we trigger a migration when we set the keystore key, had an
 // implicit passphrase, and did not have encrypt everything. We should switch
 // to KEYSTORE_PASSPHRASE.
 TEST_F(SyncEncryptionHandlerImplTest, MigrateOnKeystoreKeyAvailableImplicit) {
   const char kCurKey[] = "cur";
   KeyParams current_key = {"localhost", "dummy", kCurKey};
   GetCryptographer()->AddKey(current_key);
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->Init();
   Mock::VerifyAndClearExpectations(observer());
 
   {
     ReadTransaction trans(FROM_HERE, user_share());
     // Once we provide a keystore key, we should perform the migration.
     EXPECT_CALL(*observer(),
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
+    EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   // The actual migration gets posted, so run all pending tasks.
   PumpLoop();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(KEYSTORE_PASSPHRASE,
             encryption_handler()->GetPassphraseType());
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigori(KEYSTORE_PASSPHRASE, kCurKey);
 }
 
 // Test that we trigger a migration when we set the keystore key, had an
 // implicit passphrase, and encrypt everything enabled. We should switch to
 // FROZEN_IMPLICIT_PASSPHRASE.
 TEST_F(SyncEncryptionHandlerImplTest,
        MigrateOnKeystoreKeyAvailableFrozenImplicit) {
   const char kCurKey[] = "cur";
   KeyParams current_key = {"localhost", "dummy", kCurKey};
   GetCryptographer()->AddKey(current_key);
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->Init();
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->EnableEncryptEverything();
 
   {
     ReadTransaction trans(FROM_HERE, user_share());
     // Once we provide a keystore key, we should perform the migration.
     EXPECT_CALL(*observer(),
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
+    EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(FROZEN_IMPLICIT_PASSPHRASE));
   // The actual migration gets posted, so run all pending tasks.
   PumpLoop();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(FROZEN_IMPLICIT_PASSPHRASE,
             encryption_handler()->GetPassphraseType());
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigori(FROZEN_IMPLICIT_PASSPHRASE, kCurKey);
 }
 
 // Test that we trigger a migration when we set the keystore key, had a
 // custom passphrase, and encrypt everything enabled. The passphrase state
 // should remain as CUSTOM_PASSPHRASE, and encrypt everything stay the same.
 TEST_F(SyncEncryptionHandlerImplTest,
        MigrateOnKeystoreKeyAvailableCustomWithEncryption) {
   const char kCurKey[] = "cur";
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_)).Times(2);
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnPassphraseRequired(_, _));
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   encryption_handler()->Init();
   encryption_handler()->SetEncryptionPassphrase(kCurKey, true);
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->EnableEncryptEverything();
   Mock::VerifyAndClearExpectations(observer());
 
   {
     ReadTransaction trans(FROM_HERE, user_share());
     // Once we provide a keystore key, we should perform the migration.
     EXPECT_CALL(*observer(),
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
+    EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   // The actual migration gets posted, so run all pending tasks.
   PumpLoop();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(CUSTOM_PASSPHRASE,
             encryption_handler()->GetPassphraseType());
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigori(CUSTOM_PASSPHRASE, kCurKey);
 }
 
 // Test that we trigger a migration when we set the keystore key, had a
 // custom passphrase, and did not have encrypt everything. The passphrase state
 // should remain as CUSTOM_PASSPHRASE, and encrypt everything should be enabled.
 TEST_F(SyncEncryptionHandlerImplTest,
        MigrateOnKeystoreKeyAvailableCustomNoEncryption) {
   const char kCurKey[] = "cur";
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_)).Times(2);
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnPassphraseRequired(_, _));
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   encryption_handler()->Init();
   encryption_handler()->SetEncryptionPassphrase(kCurKey, true);
   Mock::VerifyAndClearExpectations(observer());
 
   {
     ReadTransaction trans(FROM_HERE, user_share());
     // Once we provide a keystore key, we should perform the migration.
     EXPECT_CALL(*observer(),
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
+    EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   // The actual migration gets posted, so run all pending tasks.
   PumpLoop();
@@ skipping 37 matching lines @@
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
 
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
     EXPECT_CALL(*observer(),
-                OnCryptographerStateChanged(_)).Times(2);
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
   // Run any tasks posted via AppplyNigoriUpdate.
   PumpLoop();
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
@@ skipping 35 matching lines @@
                                          trans.GetWrappedTrans());
   }
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
 
   {
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(FROZEN_IMPLICIT_PASSPHRASE));
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     EXPECT_CALL(*observer(),
-                OnCryptographerStateChanged(_));
+                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);
     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);
   }
   // Run any tasks posted via AppplyNigoriUpdate.
   PumpLoop();
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(FROZEN_IMPLICIT_PASSPHRASE,
             encryption_handler()->GetPassphraseType());
   EXPECT_TRUE(GetCryptographer()->has_pending_keys());
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
 
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   encryption_handler()->SetDecryptionPassphrase(kCurKey);
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   VerifyMigratedNigoriWithTimestamp(1, FROZEN_IMPLICIT_PASSPHRASE, kCurKey);
 
   // Check that the cryptographer still encrypts with the current key.
@@ skipping 29 matching lines @@
                                          trans.GetWrappedTrans());
   }
   EXPECT_FALSE(encryption_handler()->MigratedToKeystore());
 
   {
     EXPECT_CALL(*observer(),
                 OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     EXPECT_CALL(*observer(),
-                OnCryptographerStateChanged(_));
+                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);
     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.
   PumpLoop();
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(CUSTOM_PASSPHRASE, encryption_handler()->GetPassphraseType());
   EXPECT_TRUE(GetCryptographer()->has_pending_keys());
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
 
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   encryption_handler()->SetDecryptionPassphrase(kCurKey);
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   VerifyMigratedNigoriWithTimestamp(1, CUSTOM_PASSPHRASE, kCurKey);
 
   // Check that the cryptographer still encrypts with the current key.
@@ skipping 32 matching lines @@
     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(),
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true)).Times(2);
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->Init();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), CUSTOM_PASSPHRASE);
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigoriWithTimestamp(1, CUSTOM_PASSPHRASE, kCurKey);
 
   {
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   Mock::VerifyAndClearExpectations(observer());
 
   // 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(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   {
     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);
     sync_pb::NigoriSpecifics nigori;
     other_cryptographer.GetKeys(nigori.mutable_encryption_keybag());
     nigori.set_keybag_is_frozen(false);
     nigori.set_encrypt_everything(false);
@@ skipping 33 matching lines @@
     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(),
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true)).Times(2);
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->Init();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), CUSTOM_PASSPHRASE);
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigoriWithTimestamp(1, CUSTOM_PASSPHRASE, kCurKey);
 
   {
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   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(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     other_cryptographer.AddKey(old_key);
     encryption_handler()->GetKeystoreDecryptor(
         other_cryptographer,
         kKeystoreKey,
@@ skipping 44 matching lines @@
     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));
     EXPECT_CALL(*observer(),
-                OnCryptographerStateChanged(_));
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
     EXPECT_CALL(*observer(),
                 OnPassphraseRequired(_, _));
     encryption_handler()->ApplyNigoriUpdate(nigori, trans.GetWrappedTrans());
     nigori_node.SetNigoriSpecifics(nigori);
   }
   // Run any tasks posted via AppplyNigoriUpdate.
   PumpLoop();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->has_pending_keys());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   {
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   PumpLoop();
@@ skipping 49 matching lines @@
     nigori_node.SetNigoriSpecifics(nigori);
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
 
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_)).Times(2);
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->Init();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   const char kNewKey[] = "new_key";
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete()).Times(2);
@@ skipping 60 matching lines @@
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
     nigori_node.SetNigoriSpecifics(nigori);
   }
 
   EXPECT_CALL(*observer(),
               OnPassphraseRequired(_, _));
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   encryption_handler()->Init();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->has_pending_keys());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->SetDecryptionPassphrase(kOldKey);
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   const char kNewKey[] = "new_key";
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(CUSTOM_PASSPHRASE));
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete()).Times(2);
@@ skipping 60 matching lines @@
     nigori.set_keystore_migration_time(1);
     nigori.set_passphrase_type(sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE);
     nigori_node.SetNigoriSpecifics(nigori);
   }
 
   EXPECT_CALL(*observer(),
               OnPassphraseRequired(_, _));
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   encryption_handler()->Init();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->has_pending_keys());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->SetDecryptionPassphrase(kOldKey);
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   // Should get dropped on the floor silently.
@@ skipping 60 matching lines @@
     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(),
               OnPassphraseRequired(_, _));
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   encryption_handler()->Init();
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->has_pending_keys());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
               OnPassphraseAccepted());
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnBootstrapTokenUpdated(_, PASSPHRASE_BOOTSTRAP_TOKEN));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->SetDecryptionPassphrase(kCurKey);
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_CALL(*observer(),
               OnPassphraseTypeChanged(FROZEN_IMPLICIT_PASSPHRASE));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, true));
+  EXPECT_CALL(*observer(),
+                OnCryptographerStateChanged(_)).Times(AnyNumber());
   encryption_handler()->EnableEncryptEverything();
   Mock::VerifyAndClearExpectations(observer());
 
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_EQ(FROZEN_IMPLICIT_PASSPHRASE,
             encryption_handler()->GetPassphraseType());
   EXPECT_TRUE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigoriWithTimestamp(1, FROZEN_IMPLICIT_PASSPHRASE, kCurKey);
 
@@ skipping 23 matching lines @@
   KeyParams cur_key = {"localhost", "dummy", kCurKey};
   KeyParams keystore_key = {"localhost", "dummy", kKeystoreKey};
   GetCryptographer()->AddKey(old_key);
   GetCryptographer()->AddKey(cur_key);
 
   Cryptographer other_cryptographer(GetCryptographer()->encryptor());
   other_cryptographer.AddKey(old_key);
   EXPECT_TRUE(other_cryptographer.is_ready());
 
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   EXPECT_CALL(*observer(),
               OnEncryptedTypesChanged(_, false));
   EXPECT_CALL(*observer(),
               OnEncryptionComplete());
   encryption_handler()->Init();
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
 
   {
     EXPECT_CALL(*observer(),
                 OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
     ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler()->SetKeystoreKey(kRawKeystoreKey,
                                          trans.GetWrappedTrans());
   }
   EXPECT_CALL(*observer(),
             OnPassphraseTypeChanged(KEYSTORE_PASSPHRASE));
   PumpLoop();
   Mock::VerifyAndClearExpectations(observer());
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   VerifyMigratedNigori(KEYSTORE_PASSPHRASE, kCurKey);
 
   // Now build an old keystore passphrase nigori node.
   EXPECT_CALL(*observer(),
-              OnCryptographerStateChanged(_));
+              OnCryptographerStateChanged(_)).Times(AnyNumber());
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     ASSERT_EQ(nigori_node.InitByTagLookup(kNigoriTag), BaseNode::INIT_OK);
     sync_pb::NigoriSpecifics nigori;
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
     other_cryptographer.AddKey(old_key);
     encryption_handler()->GetKeystoreDecryptor(
         other_cryptographer,
         kKeystoreKey,
@@ skipping 10 matching lines @@
 
   // Verify we're still migrated and have proper encryption state.
   EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
   EXPECT_TRUE(GetCryptographer()->is_ready());
   EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
   EXPECT_FALSE(encryption_handler()->EncryptEverythingEnabled());
   VerifyMigratedNigori(KEYSTORE_PASSPHRASE, kCurKey);
 }
 
 }  // namespace syncer