Switch to standard integer types in components/, part 1 of 4.

components/drive/file_cache_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 "components/drive/file_cache.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/callback_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/path_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 143 matching lines @@
   const std::string id_pinned = "id_pinned", md5_pinned = "md5_pinned";
   const time_t last_accessed_pinned = 1;
   const base::FilePath& pinned_path =
       AddTestEntry(id_pinned, md5_pinned, last_accessed_pinned, src_file);
   ASSERT_EQ(FILE_ERROR_OK, cache_->Pin(id_pinned));
 
   // Call FreeDiskSpaceIfNeededFor().
   fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
   fake_free_disk_space_getter_->PushFakeValue(0);
   fake_free_disk_space_getter_->PushFakeValue(0);
-  const int64 kNeededBytes = 1;
+  const int64_t kNeededBytes = 1;
   EXPECT_TRUE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   // Only 'temporary' file gets removed.
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_tmp, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_present());
   EXPECT_FALSE(base::PathExists(tmp_path));
 
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_pinned, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
@@ skipping 30 matching lines @@
 
   const std::string id_c = "id_c", md5_c = "md5_c";
   const time_t last_accessed_c = 4;
   const base::FilePath& c_path =
       AddTestEntry(id_c, md5_c, last_accessed_c, src_file);
 
   // Call FreeDiskSpaceIfNeededFor.
   fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
   fake_free_disk_space_getter_->PushFakeValue(kMinFreeSpaceInBytes);
   fake_free_disk_space_getter_->PushFakeValue(kMinFreeSpaceInBytes);
-  const int64 kNeededBytes = kTemporaryFileSizeInBytes * 3 / 2;
+  const int64_t kNeededBytes = kTemporaryFileSizeInBytes * 3 / 2;
   EXPECT_TRUE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   // Entry A is evicted.
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_a, &entry));
   EXPECT_FALSE(entry.file_specific_info().cache_state().is_present());
   EXPECT_FALSE(base::PathExists(a_path));
 
   // Pinned entry should not be evicted.
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_pinned, &entry));
@@ skipping 30 matching lines @@
 
   // Remove metadata of entry B.
   ASSERT_EQ(FILE_ERROR_OK, metadata_storage_->RemoveEntry(id_b));
 
   // Confirm cache file of entry B exists.
   ASSERT_TRUE(base::PathExists(b_path));
 
   // Run FreeDiskSpaceIfNeededFor.
   fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
   fake_free_disk_space_getter_->PushFakeValue(kMinFreeSpaceInBytes);
-  const int64 kNeededBytes = 1;
+  const int64_t kNeededBytes = 1;
   EXPECT_TRUE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
   // Entry A is not evicted.
   ResourceEntry entry;
   EXPECT_EQ(FILE_ERROR_OK, metadata_storage_->GetEntry(id_a, &entry));
   EXPECT_TRUE(entry.file_specific_info().cache_state().is_present());
   EXPECT_TRUE(base::PathExists(a_path));
 
   // Entry B is evicted.
   EXPECT_EQ(FILE_ERROR_NOT_FOUND, metadata_storage_->GetEntry(id_b, &entry));
   EXPECT_FALSE(base::PathExists(b_path));
 }
 
 TEST_F(FileCacheTest, TooManyCacheFiles) {
   const size_t kMaxNumOfEvictedCacheFiles = 50;
   cache_->SetMaxNumOfEvictedCacheFilesForTest(kMaxNumOfEvictedCacheFiles);
 
   // Create temporary file.
   base::FilePath src_file;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(), &src_file));
   ASSERT_EQ(kTemporaryFileSizeInBytes,
             base::WriteFile(src_file, "abcdefghij", kTemporaryFileSizeInBytes));
 
   // Add kNumOfTestFiles=kMaxNumOfEvictedCacheFiles*2 entries.
   std::vector<base::FilePath> paths;
-  const int32 kNumOfTestFiles = kMaxNumOfEvictedCacheFiles * 2;
+  const int32_t kNumOfTestFiles = kMaxNumOfEvictedCacheFiles * 2;
   for (int i = 0; i < kNumOfTestFiles; ++i) {
     // Set last accessed in reverse order to the file name. i.e. If you sort
     // files in name-asc order, they will be last access desc order.
     paths.push_back(AddTestEntry(
         base::StringPrintf("id_%02d", i), base::StringPrintf("md5_%02d", i),
         kNumOfTestFiles - i /* last accessed */, src_file));
   }
 
   // Confirm cache files of kNumOfTestFiles actually exist.
   for (const auto& path : paths) {
     ASSERT_TRUE(base::PathExists(path)) << path.value();
   }
 
   // Try to free kMaxNumOfEvictedCacheFiles * 3 / 2.
   fake_free_disk_space_getter_->set_default_value(test_util::kLotsOfSpace);
   fake_free_disk_space_getter_->PushFakeValue(kMinFreeSpaceInBytes);
   fake_free_disk_space_getter_->PushFakeValue(kMinFreeSpaceInBytes);
   fake_free_disk_space_getter_->PushFakeValue(
       kMinFreeSpaceInBytes +
       (kMaxNumOfEvictedCacheFiles * kTemporaryFileSizeInBytes));
-  const int64 kNeededBytes =
+  const int64_t kNeededBytes =
       (kMaxNumOfEvictedCacheFiles * 3 / 2) * kTemporaryFileSizeInBytes;
   EXPECT_FALSE(cache_->FreeDiskSpaceIfNeededFor(kNeededBytes));
 
-  for (uint32 i = 0; i < kNumOfTestFiles; ++i) {
+  for (uint32_t i = 0; i < kNumOfTestFiles; ++i) {
     // Assert that only first kMaxNumOfEvictedCacheFiles exist.
     ASSERT_EQ(i < kMaxNumOfEvictedCacheFiles, base::PathExists(paths[i]));
   }
 }
 
 TEST_F(FileCacheTest, GetFile) {
   const base::FilePath src_file_path = temp_dir_.path().Append("test.dat");
   const std::string src_contents = "test";
   EXPECT_TRUE(google_apis::test_util::WriteStringToFile(src_file_path,
                                                         src_contents));
@@ skipping 373 matching lines @@
 
   // Clear cache.
   EXPECT_TRUE(cache_->ClearAll());
 
   // Verify that the cache is removed.
   EXPECT_TRUE(base::IsDirectoryEmpty(cache_files_dir_));
 }
 
 }  // namespace internal
 }  // namespace drive