Switch to standard integer types in sync/.

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 <stdint.h>
+
 #include <string>
 
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/tracked_objects.h"
 #include "sync/internal_api/public/base/model_type_test_util.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
@@ skipping 122 matching lines @@
   SyncEncryptionHandlerObserverMock* observer() { return &observer_; }
   Cryptographer* GetCryptographer() {
     return encryption_handler_->GetCryptographerUnsafe();
   }
 
   void VerifyMigratedNigori(PassphraseType passphrase_type,
                             const std::string& passphrase) {
     VerifyMigratedNigoriWithTimestamp(0, passphrase_type, passphrase);
   }
 
-  void VerifyMigratedNigoriWithTimestamp(
-      int64 migration_time,
-      PassphraseType passphrase_type,
-      const std::string& passphrase) {
+  void VerifyMigratedNigoriWithTimestamp(int64_t migration_time,
+                                         PassphraseType passphrase_type,
+                                         const std::string& passphrase) {
     ReadTransaction trans(FROM_HERE, user_share());
     ReadNode nigori_node(&trans);
     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 ||
@@ skipping 26 matching lines @@
 
     Cryptographer temp_cryptographer(&encryptor_);
     KeyParams params = {"localhost", "dummy", passphrase};
     temp_cryptographer.AddKey(params);
     EXPECT_TRUE(temp_cryptographer.CanDecryptUsingDefaultKey(
         nigori.encryption_keybag()));
   }
 
   sync_pb::NigoriSpecifics BuildMigratedNigori(
       PassphraseType passphrase_type,
-      int64 migration_time,
+      int64_t migration_time,
       const std::string& default_passphrase,
       const std::string& keystore_key) {
     DCHECK_NE(passphrase_type, IMPLICIT_PASSPHRASE);
     Cryptographer other_cryptographer(GetCryptographer()->encryptor());
 
     std::string default_key = default_passphrase;
     if (default_key.empty()) {
       default_key = keystore_key;
     } else {
       KeyParams keystore_params = {"localhost", "dummy", keystore_key};
@@ skipping 22 matching lines @@
       nigori.set_passphrase_type(
           passphrase_type == CUSTOM_PASSPHRASE ?
               sync_pb::NigoriSpecifics::CUSTOM_PASSPHRASE :
               sync_pb::NigoriSpecifics::FROZEN_IMPLICIT_PASSPHRASE);
     }
     return nigori;
   }
 
   // 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,
+  void InitKeystoreMigratedNigori(int64_t 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.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
       sync_pb::NigoriSpecifics nigori = BuildMigratedNigori(
           KEYSTORE_PASSPHRASE,
           migration_time,
           default_passphrase,
@@ skipping 13 matching lines @@
                 OnEncryptionComplete()).Times(AtLeast(1));
     encryption_handler()->Init();
     EXPECT_TRUE(encryption_handler()->MigratedToKeystore());
     EXPECT_EQ(encryption_handler()->GetPassphraseType(), KEYSTORE_PASSPHRASE);
     EXPECT_FALSE(encryption_handler()->IsEncryptEverythingEnabled());
     Mock::VerifyAndClearExpectations(observer());
   }
 
   // Build a migrated nigori node with the specified default passphrase
   // as a custom passphrase.
-  void InitCustomPassMigratedNigori(int64 migration_time,
+  void InitCustomPassMigratedNigori(int64_t migration_time,
                                     const std::string& default_passphrase) {
     {
       WriteTransaction trans(FROM_HERE, user_share());
       WriteNode nigori_node(&trans);
       ASSERT_EQ(nigori_node.InitTypeRoot(NIGORI), BaseNode::INIT_OK);
       sync_pb::NigoriSpecifics nigori = BuildMigratedNigori(
           CUSTOM_PASSPHRASE,
           migration_time,
           default_passphrase,
           kKeystoreKey);
@@ skipping 50 matching lines @@
     Mock::VerifyAndClearExpectations(observer());
   }
 
   // Verify we can restore the SyncEncryptionHandler state using a saved
   // |bootstrap_token| and |nigori_state|.
   //
   // |migration_time| is the time migration occurred.
   //
   // |passphrase| is the custom passphrase.
   void VerifyRestoreAfterCustomPassphrase(
-      int64 migration_time,
+      int64_t migration_time,
       const std::string& passphrase,
       const std::string& bootstrap_token,
       const SyncEncryptionHandler::NigoriState& nigori_state,
       PassphraseType passphrase_type) {
     TearDown();
     test_user_share_.SetUp();
     SetUpEncryptionWithKeyForBootstrapping(bootstrap_token);
     EXPECT_CALL(*observer(), OnCryptographerStateChanged(_)).Times(AnyNumber());
     EXPECT_CALL(*observer(), OnEncryptedTypesChanged(_, true))
         .Times(AnyNumber());
@@ skipping 973 matching lines @@
 TEST_F(SyncEncryptionHandlerImplTest, ReceiveUnmigratedNigoriAfterMigration) {
   const char kOldKey[] = "old";
   const char kCurKey[] = "cur";
   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.
-  const int64 migration_time = 1;
+  const int64_t migration_time = 1;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     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);
@@ skipping 117 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());
   SyncEncryptionHandler::NigoriState captured_nigori_state;
   EXPECT_CALL(*observer(), OnLocalSetPassphraseEncryption(_))
       .WillOnce(testing::SaveArg<0>(&captured_nigori_state));
   EXPECT_CALL(*observer(), OnEncryptionComplete());
-  const int64 migration_time = 1;
+  const int64_t migration_time = 1;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     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,
@@ skipping 119 matching lines @@
   other_cryptographer.AddKey(cur_key);
   EXPECT_TRUE(other_cryptographer.is_ready());
   EXPECT_TRUE(encryption_handler()->GetKeystoreDecryptor(
       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.
-  const int64 migration_time = 1;
+  const int64_t migration_time = 1;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     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(migration_time);
@@ skipping 96 matching lines @@
   other_cryptographer.AddNonDefaultKey(keystore_key);
   EXPECT_TRUE(other_cryptographer.is_ready());
   EXPECT_TRUE(encryption_handler()->GetKeystoreDecryptor(
       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.
-  const int64 migration_time = 1;
+  const int64_t migration_time = 1;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     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(migration_time);
@@ skipping 193 matching lines @@
   other_cryptographer.AddNonDefaultKey(keystore_key);
   EXPECT_TRUE(other_cryptographer.is_ready());
   EXPECT_TRUE(encryption_handler()->GetKeystoreDecryptor(
       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.
-  const int64 migration_time = 1;
+  const int64_t migration_time = 1;
   {
     WriteTransaction trans(FROM_HERE, user_share());
     WriteNode nigori_node(&trans);
     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(migration_time);
@@ skipping 446 matching lines @@
 
 // Verify that a key rotation done after we've migrated a custom passphrase
 // nigori node preserves the custom passphrase.
 TEST_F(SyncEncryptionHandlerImplTest, RotateKeysMigratedCustomPassphrase) {
   const char kCustomPass[] = "custom_passphrase";
   const char kRawOldKeystoreKey[] = "old_keystore_key";
 
   KeyParams custom_key = {"localhost", "dummy", kCustomPass};
   GetCryptographer()->AddKey(custom_key);
 
-  const int64 migration_time = 1;
+  const int64_t migration_time = 1;
   InitCustomPassMigratedNigori(migration_time, kCustomPass);
   VerifyMigratedNigoriWithTimestamp(migration_time, CUSTOM_PASSPHRASE,
                                     kCustomPass);
 
   SyncEncryptionHandler::NigoriState captured_nigori_state;
   {
     // Pass multiple keystore keys, signaling a rotation has happened.
     google::protobuf::RepeatedPtrField<google::protobuf::string> keys;
     keys.Add()->assign(kRawOldKeystoreKey);
     keys.Add()->assign(kRawKeystoreKey);
@@ skipping 66 matching lines @@
               OnBootstrapTokenUpdated(_, KEYSTORE_BOOTSTRAP_TOKEN));
   {
     ReadTransaction trans(FROM_HERE, user_share());
     encryption_handler()->SetKeystoreKeys(BuildEncryptionKeyProto(
                                               kRawKeystoreKey),
                                           trans.GetWrappedTrans());
   }
 }
 
 }  // namespace syncer