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

components/drive/service/fake_drive_service_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/service/fake_drive_service.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 74 matching lines @@
     scoped_ptr<FileResource> entry = FindEntry(resource_id);
     if (entry) {
       for (size_t i = 0; i < entry->parents().size(); ++i) {
         if (entry->parents()[i].file_id() == parent_id)
           return true;
       }
     }
     return false;
   }
 
-  int64 GetLargestChangeByAboutResource() {
+  int64_t GetLargestChangeByAboutResource() {
     DriveApiErrorCode error;
     scoped_ptr<AboutResource> about_resource;
     fake_service_.GetAboutResource(
         test_util::CreateCopyResultCallback(&error, &about_resource));
     base::RunLoop().RunUntilIdle();
     return about_resource->largest_change_id();
   }
 
   base::MessageLoop message_loop_;
   FakeDriveService fake_service_;
@@ skipping 269 matching lines @@
             change_list->largest_change_id());
   // This should be empty as the latest changestamp was passed to
   // GetChangeList(), hence there should be no new entries.
   EXPECT_EQ(0U, change_list->items().size());
   // It's considered loaded even if the result is empty.
   EXPECT_EQ(1, fake_service_.change_list_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_WithNewEntry) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
-  const int64 old_largest_change_id =
+  const int64_t old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   // Add a new directory in the root directory.
   ASSERT_TRUE(AddNewDirectory(
       fake_service_.GetRootResourceId(), "new directory"));
 
   // Get the resource list newer than old_largest_change_id.
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<ChangeList> change_list;
   fake_service_.GetChangeList(
@@ skipping 23 matching lines @@
       test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_FALSE(change_list);
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_DeletedEntry) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   ASSERT_TRUE(Exists("2_file_resource_id"));
-  const int64 old_largest_change_id =
+  const int64_t old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   fake_service_.DeleteResource("2_file_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(HTTP_NO_CONTENT, error);
   ASSERT_FALSE(Exists("2_file_resource_id"));
 
@@ skipping 14 matching lines @@
   const ChangeResource& item = *change_list->items()[0];
   EXPECT_EQ("2_file_resource_id", item.file_id());
   EXPECT_FALSE(item.file());
   EXPECT_TRUE(item.is_deleted());
   EXPECT_EQ(1, fake_service_.change_list_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_TrashedEntry) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   ASSERT_TRUE(Exists("2_file_resource_id"));
-  const int64 old_largest_change_id =
+  const int64_t old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   fake_service_.TrashResource("2_file_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(HTTP_SUCCESS, error);
   ASSERT_FALSE(Exists("2_file_resource_id"));
 
   // Get the resource list newer than old_largest_change_id.
@@ skipping 153 matching lines @@
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
 
   EXPECT_EQ(2U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, GetRemainingChangeList_GetChangeList) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_default_max_results(2);
-  const int64 old_largest_change_id =
+  const int64_t old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   // Add 5 new directory in the root directory.
   for (int i = 0; i < 5; ++i) {
     ASSERT_TRUE(AddNewDirectory(
         fake_service_.GetRootResourceId(),
         base::StringPrintf("new directory %d", i)));
   }
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
@@ skipping 395 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, CopyResource) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "2_file_resource_id";
   const std::string kParentResourceId = "2_folder_resource_id";
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.CopyResource(
       kResourceId,
       kParentResourceId,
       "new title",
       base::Time::FromUTCExploded(kModifiedDate),
@@ skipping 26 matching lines @@
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, CopyResource_EmptyParentResourceId) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "2_file_resource_id";
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.CopyResource(
       kResourceId,
       std::string(),
       "new title",
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
@@ skipping 29 matching lines @@
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, UpdateResource) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
   const base::Time::Exploded kViewedDate = {2013, 8, 1, 20, 16, 00, 14, 234};
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "2_file_resource_id";
   const std::string kParentResourceId = "2_folder_resource_id";
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.UpdateResource(
       kResourceId, kParentResourceId, "new title",
       base::Time::FromUTCExploded(kModifiedDate),
       base::Time::FromUTCExploded(kViewedDate),
       google_apis::drive::Properties(),
@@ skipping 27 matching lines @@
       base::Time(), google_apis::drive::Properties(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, UpdateResource_EmptyParentResourceId) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "2_file_resource_id";
 
   // Just make sure that the resource is under root.
   ASSERT_TRUE(HasParent(kResourceId, "fake_root"));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.UpdateResource(
       kResourceId, std::string(), "new title", base::Time(), base::Time(),
@@ skipping 45 matching lines @@
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_FORBIDDEN, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "2_file_resource_id";
   const std::string kOldParentResourceId = fake_service_.GetRootResourceId();
   const std::string kNewParentResourceId = "1_folder_resource_id";
 
   // Here's the original parent link.
   EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
@@ skipping 10 matching lines @@
   EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId));
   // Should be incremented as a file was moved.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "subdirectory_file_1_id";
   const std::string kOldParentResourceId = "1_folder_resource_id";
   const std::string kNewParentResourceId = "2_folder_resource_id";
 
   // Here's the original parent link.
   EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
@@ skipping 26 matching lines @@
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_OrphanFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "1_orphanfile_resource_id";
   const std::string kNewParentResourceId = "1_folder_resource_id";
 
   // The file does not belong to any directory, even to the root.
   EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId()));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   fake_service_.AddResourceToDirectory(
@@ skipping 26 matching lines @@
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kResourceId = "subdirectory_file_1_id";
   const std::string kParentResourceId = "1_folder_resource_id";
 
   scoped_ptr<FileResource> entry = FindEntry(kResourceId);
   ASSERT_TRUE(entry);
   // The entry should have a parent now.
   ASSERT_FALSE(entry->parents().empty());
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
@@ skipping 60 matching lines @@
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_EmptyParent) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
       std::string(), "new directory", AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
       fake_service_.GetRootResourceId(), "new directory",
       AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToRootDirectoryOnEmptyFileSystem) {
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
       fake_service_.GetRootResourceId(), "new directory",
       AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kParentResourceId = "1_folder_resource_id";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
       kParentResourceId, "new directory", AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
@@ skipping 274 matching lines @@
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
   EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(static_cast<int64>(contents.size() / 2),
+  EXPECT_GE(static_cast<int64_t>(contents.size() / 2),
             upload_progress_values.back().first);
 
   upload_progress_values.clear();
   fake_service_.ResumeUpload(
       upload_location,
       contents.size() / 2, contents.size(), contents.size(), "text/plain",
       local_file_path,
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, response.code);
   EXPECT_TRUE(entry.get());
-  EXPECT_EQ(static_cast<int64>(contents.size()), entry->file_size());
+  EXPECT_EQ(static_cast<int64_t>(contents.size()), entry->file_size());
   EXPECT_TRUE(Exists(entry->file_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2),
+  EXPECT_GE(static_cast<int64_t>(contents.size() - contents.size() / 2),
             upload_progress_values.back().first);
   EXPECT_EQ(base::MD5String(contents), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath local_file_path =
       temp_dir.path().Append(FILE_PATH_LITERAL("new file.foo"));
   std::string contents("hogefugapiyo");
@@ skipping 24 matching lines @@
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
   EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(static_cast<int64>(contents.size() / 2),
+  EXPECT_GE(static_cast<int64_t>(contents.size() / 2),
             upload_progress_values.back().first);
 
   upload_progress_values.clear();
   fake_service_.ResumeUpload(
       upload_location,
       contents.size() / 2, contents.size(), contents.size(), "test/foo",
       local_file_path,
       test_util::CreateCopyResultCallback(&response, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, response.code);
   EXPECT_TRUE(entry.get());
-  EXPECT_EQ(static_cast<int64>(contents.size()), entry->file_size());
+  EXPECT_EQ(static_cast<int64_t>(contents.size()), entry->file_size());
   EXPECT_TRUE(Exists(entry->file_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
   EXPECT_LE(0, upload_progress_values.front().first);
-  EXPECT_GE(static_cast<int64>(contents.size() - contents.size() / 2),
+  EXPECT_GE(static_cast<int64_t>(contents.size() - contents.size() / 2),
             upload_progress_values.back().first);
   EXPECT_EQ(base::MD5String(contents), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewFile(
       kContentType,
       kContentData,
       fake_service_.GetRootResourceId(),
       kTitle,
       false,  // shared_with_me
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kContentType, entry->mime_type());
-  EXPECT_EQ(static_cast<int64>(kContentData.size()), entry->file_size());
+  EXPECT_EQ(static_cast<int64_t>(kContentData.size()), entry->file_size());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ(kTitle, entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
   EXPECT_EQ(base::MD5String(kContentData), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectoryOnEmptyFileSystem) {
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewFile(
       kContentType,
       kContentData,
       fake_service_.GetRootResourceId(),
       kTitle,
       false,  // shared_with_me
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kContentType, entry->mime_type());
-  EXPECT_EQ(static_cast<int64>(kContentData.size()), entry->file_size());
+  EXPECT_EQ(static_cast<int64_t>(kContentData.size()), entry->file_size());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ(kTitle, entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
   EXPECT_EQ(base::MD5String(kContentData), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
   const std::string kParentResourceId = "1_folder_resource_id";
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewFile(
       kContentType,
       kContentData,
       kParentResourceId,
       kTitle,
       false,  // shared_with_me
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kContentType, entry->mime_type());
-  EXPECT_EQ(static_cast<int64>(kContentData.size()), entry->file_size());
+  EXPECT_EQ(static_cast<int64_t>(kContentData.size()), entry->file_size());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ(kTitle, entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), kParentResourceId));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
   EXPECT_EQ(base::MD5String(kContentData), entry->md5_checksum());
 }
 
@@ skipping 43 matching lines @@
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_SharedWithMeLabel) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
 
-  int64 old_largest_change_id = GetLargestChangeByAboutResource();
+  int64_t old_largest_change_id = GetLargestChangeByAboutResource();
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewFile(
       kContentType,
       kContentData,
       fake_service_.GetRootResourceId(),
       kTitle,
       true,  // shared_with_me
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ(kContentType, entry->mime_type());
-  EXPECT_EQ(static_cast<int64>(kContentData.size()), entry->file_size());
+  EXPECT_EQ(static_cast<int64_t>(kContentData.size()), entry->file_size());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ(kTitle, entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), fake_service_.GetRootResourceId()));
   EXPECT_FALSE(entry->shared_with_me_date().is_null());
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
   EXPECT_EQ(base::MD5String(kContentData), entry->md5_checksum());
 }
@@ skipping 53 matching lines @@
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 }  // namespace
 
 }  // namespace drive