Switch to standard integer types in chrome/browser/chromeos/.

chrome/browser/chromeos/login/auth/cryptohome_authenticator_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/login/auth/chrome_cryptohome_authenticator.h"
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
@@ skipping 41 matching lines @@
 
 namespace {
 
 // Label under which the user's key is stored.
 const char kCryptohomeGAIAKeyLabel[] = "gaia";
 
 // Salt used by pre-hashed key.
 const char kSalt[] = "SALT $$";
 
 // An owner key in PKCS#8 PrivateKeyInfo for testing owner checks.
-const uint8 kOwnerPrivateKey[] = {
+const uint8_t kOwnerPrivateKey[] = {
     0x30, 0x82, 0x01, 0x53, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
     0x01, 0x3d, 0x30, 0x82, 0x01, 0x39, 0x02, 0x01, 0x00, 0x02, 0x41, 0x00,
     0xb4, 0xf5, 0xab, 0xfe, 0xd8, 0xf1, 0xcb, 0x5f, 0x8f, 0x48, 0x3e, 0xdf,
     0x40, 0x8e, 0x2b, 0x15, 0x43, 0x6c, 0x67, 0x74, 0xa2, 0xcb, 0xe4, 0xf3,
     0xec, 0xab, 0x41, 0x57, 0x1d, 0x5f, 0xed, 0xcf, 0x09, 0xf4, 0xcc, 0xbb,
     0x52, 0x52, 0xe8, 0x46, 0xf5, 0xc5, 0x01, 0xa3, 0xd8, 0x24, 0xc0, 0x15,
     0xc5, 0x65, 0x50, 0x7d, 0xbd, 0x4e, 0x81, 0xb2, 0x28, 0x38, 0xf9, 0x3d,
     0x3e, 0x2a, 0x68, 0xf7, 0x02, 0x03, 0x01, 0x00, 0x01, 0x02, 0x40, 0x40,
     0xc7, 0xb5, 0xb3, 0xbc, 0xac, 0x0a, 0x77, 0x02, 0x0f, 0x05, 0xda, 0xdb,
@@ skipping 11 matching lines @@
     0x72, 0xcc, 0xd4, 0xf3, 0x97, 0xc6, 0x44, 0x55, 0xf2, 0xe0, 0x94, 0x9c,
     0x97, 0x75, 0x64, 0x34, 0x52, 0x4b, 0xc1, 0x53, 0xdd, 0x8f, 0x21, 0x02,
     0x20, 0x0e, 0xef, 0x48, 0x92, 0x2d, 0x9c, 0xe8, 0xd3, 0x7e, 0x1e, 0x55,
     0x0f, 0x23, 0x74, 0x76, 0x07, 0xec, 0x2c, 0x9e, 0xe4, 0x0e, 0xc0, 0x72,
     0xeb, 0x70, 0xcb, 0x74, 0xef, 0xcc, 0x26, 0x50, 0xff, 0x02, 0x20, 0x29,
     0x32, 0xd0, 0xbf, 0x11, 0xf2, 0xbf, 0x54, 0xfd, 0x6d, 0xf2, 0x1c, 0xbe,
     0x50, 0x18, 0x62, 0x6d, 0x23, 0xe4, 0x26, 0x03, 0x8b, 0xb3, 0x42, 0x24,
     0x7e, 0x68, 0x37, 0x26, 0xda, 0xb9, 0x87};
 
 // The public key alone matcing kOwnerPrivateKey.
-const uint8 kOwnerPublicKey[] = {
+const uint8_t kOwnerPublicKey[] = {
     0x30, 0x5c, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
     0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x4b, 0x00, 0x30, 0x48, 0x02, 0x41,
     0x00, 0xb4, 0xf5, 0xab, 0xfe, 0xd8, 0xf1, 0xcb, 0x5f, 0x8f, 0x48, 0x3e,
     0xdf, 0x40, 0x8e, 0x2b, 0x15, 0x43, 0x6c, 0x67, 0x74, 0xa2, 0xcb, 0xe4,
     0xf3, 0xec, 0xab, 0x41, 0x57, 0x1d, 0x5f, 0xed, 0xcf, 0x09, 0xf4, 0xcc,
     0xbb, 0x52, 0x52, 0xe8, 0x46, 0xf5, 0xc5, 0x01, 0xa3, 0xd8, 0x24, 0xc0,
     0x15, 0xc5, 0x65, 0x50, 0x7d, 0xbd, 0x4e, 0x81, 0xb2, 0x28, 0x38, 0xf9,
     0x3d, 0x3e, 0x2a, 0x68, 0xf7, 0x02, 0x03, 0x01, 0x00, 0x01};
 
-std::vector<uint8> GetOwnerPublicKey() {
-  return std::vector<uint8>(kOwnerPublicKey,
-                            kOwnerPublicKey + arraysize(kOwnerPublicKey));
+std::vector<uint8_t> GetOwnerPublicKey() {
+  return std::vector<uint8_t>(kOwnerPublicKey,
+                              kOwnerPublicKey + arraysize(kOwnerPublicKey));
 }
 
 bool CreateOwnerKeyInSlot(PK11SlotInfo* slot) {
-  const std::vector<uint8> key(kOwnerPrivateKey,
-                               kOwnerPrivateKey + arraysize(kOwnerPrivateKey));
+  const std::vector<uint8_t> key(
+      kOwnerPrivateKey, kOwnerPrivateKey + arraysize(kOwnerPrivateKey));
   return crypto::ImportNSSKeyFromPrivateKeyInfo(slot, key,
                                                 true /* permanent */);
 }
 
 }  // namespace
 
 class CryptohomeAuthenticatorTest : public testing::Test {
  public:
   CryptohomeAuthenticatorTest()
       : user_context_(AccountId::FromUserEmail("me@nowhere.org")),
@@ skipping 103 matching lines @@
         .WillOnce(Invoke(MockAuthStatusConsumer::OnGuestSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectPasswordChange() {
     EXPECT_CALL(consumer_, OnPasswordChangeDetected())
         .WillOnce(Invoke(MockAuthStatusConsumer::OnMigrateQuit))
         .RetiresOnSaturation();
   }
 
-  void ExpectGetKeyDataExCall(scoped_ptr<int64> key_type,
+  void ExpectGetKeyDataExCall(scoped_ptr<int64_t> key_type,
                               scoped_ptr<std::string> salt) {
     key_definitions_.clear();
     key_definitions_.push_back(cryptohome::KeyDefinition(
         std::string() /* secret */,
         kCryptohomeGAIAKeyLabel,
         cryptohome::PRIV_DEFAULT));
     cryptohome::KeyDefinition& key_definition = key_definitions_.back();
     key_definition.revision = 1;
     if (key_type) {
       key_definition.provider_data.push_back(
@@ skipping 301 matching lines @@
   // Set up mock async method caller to respond successfully to a cryptohome
   // remove attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_,
               AsyncRemove(user_context_.GetAccountId().GetUserEmail(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
-  ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
+  ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), scoped_ptr<std::string>());
   ExpectMountExCall(true /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveResyncFail) {
@@ skipping 34 matching lines @@
   // Set up mock async method caller to respond successfully to a key migration.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_,
               AsyncMigrateKey(user_context_.GetAccountId().GetUserEmail(), _,
                               transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome mount
   // attempt.
-  ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
+  ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), scoped_ptr<std::string>());
   ExpectMountExCall(false /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecoverButFail) {
@@ skipping 41 matching lines @@
 
 TEST_F(CryptohomeAuthenticatorTest, DriveCreateForNewUser) {
   UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
-  ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
+  ExpectGetKeyDataExCall(scoped_ptr<int64_t>(), scoped_ptr<std::string>());
   ExpectMountExCall(true /* expect_create_attempt */);
 
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected because the user doesn't exist; additionally,
   // an online auth attempt has completed successfully.
   state_->PresetCryptohomeStatus(false,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
@@ skipping 48 matching lines @@
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock homedir methods to respond with key metadata indicating that a
   // pre-hashed key was used to create the cryptohome and allow a successful
   // mount when this pre-hashed key is used.
 
   ExpectGetKeyDataExCall(
-      make_scoped_ptr(new int64(Key::KEY_TYPE_SALTED_SHA256)),
+      make_scoped_ptr(new int64_t(Key::KEY_TYPE_SALTED_SHA256)),
       make_scoped_ptr(new std::string(kSalt)));
   ExpectMountExCall(false /* expect_create_attempt */);
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, FailLoginWithMissingSalt) {
   CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256, kSalt);
 
   FailOnLoginSuccess();
   ExpectLoginFailure(AuthFailure(AuthFailure::COULD_NOT_MOUNT_CRYPTOHOME));
 
   // Set up mock homedir methods to respond with key metadata indicating that a
   // pre-hashed key was used to create the cryptohome but without the required
   // salt.
   ExpectGetKeyDataExCall(
-      make_scoped_ptr(new int64(Key::KEY_TYPE_SALTED_SHA256)),
+      make_scoped_ptr(new int64_t(Key::KEY_TYPE_SALTED_SHA256)),
       scoped_ptr<std::string>());
 
   auth_->AuthenticateToLogin(NULL, user_context_);
   base::RunLoop().Run();
 }
 
 }  // namespace chromeos