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

components/drive/file_system_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_system.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/testing_pref_service.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/drive/change_list_loader.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/drive_api_util.h"
 #include "components/drive/drive_test_util.h"
 #include "components/drive/event_logger.h"
@@ skipping 210 matching lines @@
                                 base::ThreadTaskRunnerHandle::Get().get(),
                                 fake_free_disk_space_getter_.get()));
 
     scoped_ptr<internal::ResourceMetadata, test_util::DestroyHelperForTests>
         resource_metadata(new internal::ResourceMetadata(
             metadata_storage_.get(), cache.get(),
             base::ThreadTaskRunnerHandle::Get()));
 
     ASSERT_EQ(FILE_ERROR_OK, resource_metadata->Initialize());
 
-    const int64 changestamp = param == USE_SERVER_TIMESTAMP ?
-        fake_drive_service_->about_resource().largest_change_id() : 1;
+    const int64_t changestamp =
+        param == USE_SERVER_TIMESTAMP
+            ? fake_drive_service_->about_resource().largest_change_id()
+            : 1;
     ASSERT_EQ(FILE_ERROR_OK,
               resource_metadata->SetLargestChangestamp(changestamp));
 
     // drive/root
     ResourceEntry root;
     ASSERT_EQ(FILE_ERROR_OK, resource_metadata->GetResourceEntryByPath(
         util::GetDriveMyDriveRootPath(), &root));
     root.set_resource_id(fake_drive_service_->GetRootResourceId());
     ASSERT_EQ(FILE_ERROR_OK, resource_metadata->RefreshEntry(root));
 
@@ skipping 299 matching lines @@
   ASSERT_TRUE(server_entry);
   EXPECT_EQ(last_accessed, server_entry->last_viewed_by_me_date());
   EXPECT_EQ(last_modified, server_entry->modified_date());
 }
 
 TEST_F(FileSystemTest, TruncateFile) {
   base::FilePath file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<ResourceEntry> entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
 
-  const int64 kLength = entry->file_info().size() + 100;
+  const int64_t kLength = entry->file_info().size() + 100;
 
   FileError error = FILE_ERROR_FAILED;
   file_system_->TruncateFile(
       file_path,
       kLength,
       google_apis::test_util::CreateCopyResultCallback(&error));
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(FILE_ERROR_OK, error);
 
   // File is touched on the server.
@@ skipping 379 matching lines @@
   EXPECT_EQ(FILE_ERROR_OK, error_unpin);
 
   // No cache file available because the sync was cancelled by Unpin().
   entry = GetResourceEntrySync(file_path);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().cache_state().is_present());
 }
 
 TEST_F(FileSystemTest, GetAvailableSpace) {
   FileError error = FILE_ERROR_OK;
-  int64 bytes_total;
-  int64 bytes_used;
+  int64_t bytes_total;
+  int64_t bytes_used;
   file_system_->GetAvailableSpace(
       google_apis::test_util::CreateCopyResultCallback(
           &error, &bytes_total, &bytes_used));
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_EQ(6789012345LL, bytes_used);
   EXPECT_EQ(9876543210LL, bytes_total);
 }
 
 TEST_F(FileSystemTest, MarkCacheFileAsMountedAndUnmounted) {
   ASSERT_TRUE(LoadFullResourceList());
@@ skipping 78 matching lines @@
       google_apis::test_util::CreateCopyResultCallback(&available));
   content::RunAllBlockingPoolTasksUntilIdle();
   ASSERT_FALSE(available);
 
   entry = GetResourceEntrySync(file_in_root);
   ASSERT_TRUE(entry);
   EXPECT_FALSE(entry->file_specific_info().cache_state().is_present());
 }
 
 }   // namespace drive