Switch to standard integer types in chromeos/.

chromeos/tpm/tpm_token_info_getter_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 <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task_runner.h"
@@ skipping 31 matching lines @@
 
 // Task runner for handling delayed tasks posted by TPMTokenInfoGetter when
 // retrying failed cryptohome method calls. It just records the requested
 // delay and immediately runs the task. The task is run asynchronously to be
 // closer to what's actually happening in production.
 // The delays used by TPMTokenGetter should be monotonically increasing, so
 // the fake task runner does not handle task reordering based on the delays.
 class FakeTaskRunner : public base::TaskRunner {
  public:
   // |delays|: Vector to which the dalays seen by the task runner are saved.
-  explicit FakeTaskRunner(std::vector<int64>* delays) : delays_(delays) {}
+  explicit FakeTaskRunner(std::vector<int64_t>* delays) : delays_(delays) {}
 
   // base::TaskRunner overrides:
   bool PostDelayedTask(const tracked_objects::Location& from_here,
                        const base::Closure& task,
                        base::TimeDelta delay) override {
     delays_->push_back(delay.InMilliseconds());
     base::ThreadTaskRunnerHandle::Get()->PostTask(from_here, task);
     return true;
   }
   bool RunsTasksOnCurrentThread() const override { return true; }
 
  protected:
   ~FakeTaskRunner() override {}
 
  private:
   // The vector of delays.
-  std::vector<int64>* delays_;
+  std::vector<int64_t>* delays_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeTaskRunner);
 };
 
 // Implementation of CryptohomeClient used in these tests. Note that
 // TestCryptohomeClient implements FakeCryptohomeClient purely for convenience
 // of not having to implement whole CryptohomeClient interface.
 // TestCryptohomeClient overrides all CryptohomeClient methods used in
 // TPMTokenInfoGetter tests.
 class TestCryptohomeClient : public chromeos::FakeCryptohomeClient {
@@ skipping 155 matching lines @@
     tpm_token_info_getter_ =
         chromeos::TPMTokenInfoGetter::CreateForSystemToken(
             cryptohome_client_.get(),
             scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
   }
 
  protected:
   scoped_ptr<TestCryptohomeClient> cryptohome_client_;
   scoped_ptr<chromeos::TPMTokenInfoGetter> tpm_token_info_getter_;
 
-  std::vector<int64> delays_;
+  std::vector<int64_t> delays_;
 
  private:
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SystemTPMTokenInfoGetterTest);
 };
 
 class UserTPMTokenInfoGetterTest : public testing::Test {
  public:
   UserTPMTokenInfoGetterTest() : user_id_("user") {}
   ~UserTPMTokenInfoGetterTest() override {}
 
   void SetUp() override {
     cryptohome_client_.reset(new TestCryptohomeClient(user_id_));
     tpm_token_info_getter_ =
         chromeos::TPMTokenInfoGetter::CreateForUserToken(
             user_id_,
             cryptohome_client_.get(),
             scoped_refptr<base::TaskRunner>(new FakeTaskRunner(&delays_)));
   }
 
  protected:
   scoped_ptr<TestCryptohomeClient> cryptohome_client_;
   scoped_ptr<chromeos::TPMTokenInfoGetter> tpm_token_info_getter_;
 
   std::string user_id_;
-  std::vector<int64> delays_;
+  std::vector<int64_t> delays_;
 
  private:
   base::MessageLoop message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(UserTPMTokenInfoGetterTest);
 };
 
 TEST_F(SystemTPMTokenInfoGetterTest, BasicFlow) {
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  EXPECT_EQ(std::vector<int64>(), delays_);
+  EXPECT_EQ(std::vector<int64_t>(), delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, TokenSlotIdEqualsZero) {
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_0", "2222", 0);
 
   EXPECT_TRUE(reported_info.IsReady());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_0", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(0, reported_info.slot_id);
 
-  EXPECT_EQ(std::vector<int64>(), delays_);
+  EXPECT_EQ(std::vector<int64_t>(), delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, TPMNotEnabled) {
   cryptohome_client_->set_tpm_is_enabled(false);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   EXPECT_FALSE(reported_info.enabled);
 
-  EXPECT_EQ(std::vector<int64>(), delays_);
+  EXPECT_EQ(std::vector<int64_t>(), delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, TpmEnabledCallFails) {
   cryptohome_client_->set_tpm_is_enabled_failure_count(1);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  const int64 kExpectedDelays[] = {100};
-  EXPECT_EQ(std::vector<int64>(kExpectedDelays,
-                               kExpectedDelays + arraysize(kExpectedDelays)),
+  const int64_t kExpectedDelays[] = {100};
+  EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
             delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyNotReady) {
   cryptohome_client_->set_get_tpm_token_info_not_set_count(1);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  const int64 kExpectedDelays[] = {100};
-  EXPECT_EQ(std::vector<int64>(kExpectedDelays,
-                               kExpectedDelays + arraysize(kExpectedDelays)),
+  const int64_t kExpectedDelays[] = {100};
+  EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
             delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyFails) {
   cryptohome_client_->set_get_tpm_token_info_failure_count(1);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  const int64 kExpectedDelays[] = {100};
-  EXPECT_EQ(std::vector<int64>(kExpectedDelays,
-                               kExpectedDelays + arraysize(kExpectedDelays)),
+  const int64_t kExpectedDelays[] = {100};
+  EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
             delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, RetryDelaysIncreaseExponentially) {
   cryptohome_client_->set_tpm_is_enabled_failure_count(2);
   cryptohome_client_->set_get_tpm_token_info_failure_count(1);
   cryptohome_client_->set_get_tpm_token_info_not_set_count(3);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 2);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(2, reported_info.slot_id);
 
-  int64 kExpectedDelays[] = { 100, 200, 400, 800, 1600, 3200 };
-  ASSERT_EQ(
-      std::vector<int64>(kExpectedDelays,
-                         kExpectedDelays + arraysize(kExpectedDelays)),
-      delays_);
+  int64_t kExpectedDelays[] = {100, 200, 400, 800, 1600, 3200};
+  ASSERT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
+            delays_);
 }
 
 TEST_F(SystemTPMTokenInfoGetterTest, RetryDelayBounded) {
   cryptohome_client_->set_tpm_is_enabled_failure_count(4);
   cryptohome_client_->set_get_tpm_token_info_failure_count(5);
   cryptohome_client_->set_get_tpm_token_info_not_set_count(6);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  int64 kExpectedDelays[] = {
-     100, 200, 400, 800, 1600, 3200, 6400, 12800, 25600, 51200, 102400, 204800,
-     300000, 300000, 300000
-  };
-  ASSERT_EQ(
-      std::vector<int64>(kExpectedDelays,
-                         kExpectedDelays + arraysize(kExpectedDelays)),
-      delays_);
+  int64_t kExpectedDelays[] = {100,    200,    400,    800,    1600,
+                               3200,   6400,   12800,  25600,  51200,
+                               102400, 204800, 300000, 300000, 300000};
+  ASSERT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
+            delays_);
 }
 
 TEST_F(UserTPMTokenInfoGetterTest, BasicFlow) {
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  EXPECT_EQ(std::vector<int64>(), delays_);
+  EXPECT_EQ(std::vector<int64_t>(), delays_);
 }
 
 TEST_F(UserTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyFails) {
   cryptohome_client_->set_get_tpm_token_info_failure_count(1);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  const int64 kExpectedDelays[] = {100};
-  EXPECT_EQ(std::vector<int64>(kExpectedDelays,
-                               kExpectedDelays + arraysize(kExpectedDelays)),
+  const int64_t kExpectedDelays[] = {100};
+  EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
             delays_);
 }
 
 TEST_F(UserTPMTokenInfoGetterTest, GetTpmTokenInfoInitiallyNotReady) {
   cryptohome_client_->set_get_tpm_token_info_not_set_count(1);
 
   TestTPMTokenInfo reported_info;
   tpm_token_info_getter_->Start(
       base::Bind(&RecordGetterResult, &reported_info));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(reported_info.IsReady());
   cryptohome_client_->SetTPMTokenInfo("TOKEN_1", "2222", 1);
 
   EXPECT_TRUE(reported_info.IsReady());
   EXPECT_TRUE(reported_info.enabled);
   EXPECT_EQ("TOKEN_1", reported_info.name);
   EXPECT_EQ("2222", reported_info.pin);
   EXPECT_EQ(1, reported_info.slot_id);
 
-  const int64 kExpectedDelays[] = {100};
-  EXPECT_EQ(std::vector<int64>(kExpectedDelays,
-                               kExpectedDelays + arraysize(kExpectedDelays)),
+  const int64_t kExpectedDelays[] = {100};
+  EXPECT_EQ(std::vector<int64_t>(kExpectedDelays,
+                                 kExpectedDelays + arraysize(kExpectedDelays)),
             delays_);
 }
 
 }  // namespace