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

chrome/browser/chromeos/drive/fileapi/fileapi_worker_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/drive/fileapi/fileapi_worker.h"
 
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "components/drive/dummy_file_system.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 42 matching lines @@
   bool closed() const { return closed_; }
 
  private:
   const base::FilePath local_file_path_;
   const OpenMode expected_open_mode_;
   bool closed_;
 };
 
 // Helper function of testing OpenFile() for write access. It checks that the
 // file handle correctly writes to the expected file.
-void VerifyWrite(
-    int64 expected_size,
-    const base::FilePath& expected_written_path,
-    const std::string& write_data,
-    base::File file,
-    const base::Closure& close_callback) {
+void VerifyWrite(int64_t expected_size,
+                 const base::FilePath& expected_written_path,
+                 const std::string& write_data,
+                 base::File file,
+                 const base::Closure& close_callback) {
   // Check that the file was properly opened.
   EXPECT_TRUE(file.IsValid());
   EXPECT_FALSE(close_callback.is_null());
 
   // Check that the file has the expected length (i.e., truncated or not)
   base::File::Info info;
   EXPECT_TRUE(file.GetInfo(&info));
   EXPECT_EQ(expected_size, info.size);
 
   // Write some data.
@@ skipping 75 matching lines @@
 
 TEST_F(FileApiWorkerTest, OpenFileForCreateWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kWriteData = "byebye";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
 
   // CREATE => CREATE (fails if file exists.)
   TestFileSystemForOpenFile file_system(temp_path, CREATE_FILE);
-  const int64 kExpectedSize = 0;
+  const int64_t kExpectedSize = 0;
 
   OpenFile(kDummyPath,
            base::File::FLAG_CREATE | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenAlwaysWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kWriteData = "byebye";
   const std::string kInitialData = "hello";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // OPEN_ALWAYS => OPEN_OR_CREATE (success whether file exists or not.)
   // No truncation should take place.
   TestFileSystemForOpenFile file_system(temp_path, OPEN_OR_CREATE_FILE);
-  const int64 kExpectedSize = static_cast<int64>(kInitialData.size());
+  const int64_t kExpectedSize = static_cast<int64_t>(kInitialData.size());
 
   OpenFile(kDummyPath,
            base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenTruncatedWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kInitialData = "hello";
   const std::string kWriteData = "byebye";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // OPEN_TRUNCATED => OPEN (failure when the file did not exist.)
   // It should truncate the file before passing to the callback.
   TestFileSystemForOpenFile file_system(temp_path, OPEN_FILE);
-  const int64 kExpectedSize = 0;
+  const int64_t kExpectedSize = 0;
 
   OpenFile(kDummyPath,
            base::File::FLAG_OPEN_TRUNCATED | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenCreateAlwaysWrite) {
   const base::FilePath kDummyPath = base::FilePath::FromUTF8Unsafe("whatever");
   const std::string kInitialData = "hello";
   const std::string kWriteData = "byebye";
 
   base::FilePath temp_path;
   base::CreateTemporaryFile(&temp_path);
   google_apis::test_util::WriteStringToFile(temp_path, kInitialData);
 
   // CREATE_ALWAYS => OPEN_OR_CREATE (success whether file exists or not.)
   // It should truncate the file before passing to the callback.
   TestFileSystemForOpenFile file_system(temp_path, OPEN_OR_CREATE_FILE);
-  const int64 kExpectedSize = 0;
+  const int64_t kExpectedSize = 0;
 
   OpenFile(kDummyPath,
            base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE,
            base::Bind(&VerifyWrite, kExpectedSize, temp_path, kWriteData),
            &file_system);
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 TEST_F(FileApiWorkerTest, OpenFileForOpenRead) {
@@ skipping 10 matching lines @@
   OpenFile(kDummyPath,
            base::File::FLAG_OPEN | base::File::FLAG_READ,
            base::Bind(&VerifyRead, kInitialData),
            &file_system);
   content::RunAllBlockingPoolTasksUntilIdle();
   EXPECT_TRUE(file_system.closed());
 }
 
 }  // namespace fileapi_internal
 }  // namespace drive