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

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_writer_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/file_system_provider/fileapi/file_stream_writer.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
@@ skipping 79 matching lines @@
   scoped_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* profile_;  // Owned by TestingProfileManager.
   FakeProvidedFileSystem* provided_file_system_;  // Owned by Service.
   storage::FileSystemURL file_url_;
   storage::FileSystemURL wrong_file_url_;
 };
 
 TEST_F(FileSystemProviderFileStreamWriter, Write) {
   std::vector<int> write_log;
 
-  const int64 initial_offset = 0;
+  const int64_t initial_offset = 0;
   FileStreamWriter writer(file_url_, initial_offset);
   scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
 
   {
     const int result = writer.Write(io_buffer.get(),
                                     sizeof(kTextToWrite) - 1,
                                     base::Bind(&LogValue, &write_log));
     EXPECT_EQ(net::ERR_IO_PENDING, result);
     base::RunLoop().RunUntilIdle();
 
@@ skipping 30 matching lines @@
     const std::string expected_contents =
         std::string(kTextToWrite) + kTextToWrite;
     EXPECT_EQ(expected_contents,
               entry->contents.substr(0, expected_contents.size()));
   }
 }
 
 TEST_F(FileSystemProviderFileStreamWriter, Cancel) {
   std::vector<int> write_log;
 
-  const int64 initial_offset = 0;
+  const int64_t initial_offset = 0;
   FileStreamWriter writer(file_url_, initial_offset);
   scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
 
   const int write_result = writer.Write(io_buffer.get(),
                                         sizeof(kTextToWrite) - 1,
                                         base::Bind(&LogValue, &write_log));
   EXPECT_EQ(net::ERR_IO_PENDING, write_result);
 
   std::vector<int> cancel_log;
   const int cancel_result = writer.Cancel(base::Bind(&LogValue, &cancel_log));
   EXPECT_EQ(net::ERR_IO_PENDING, cancel_result);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0u, write_log.size());
   ASSERT_EQ(1u, cancel_log.size());
   EXPECT_EQ(net::OK, cancel_log[0]);
 }
 
 TEST_F(FileSystemProviderFileStreamWriter, Cancel_NotRunning) {
   std::vector<int> write_log;
 
-  const int64 initial_offset = 0;
+  const int64_t initial_offset = 0;
   FileStreamWriter writer(file_url_, initial_offset);
   scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
 
   std::vector<int> cancel_log;
   const int cancel_result = writer.Cancel(base::Bind(&LogValue, &cancel_log));
   EXPECT_EQ(net::ERR_UNEXPECTED, cancel_result);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0u, write_log.size());
   EXPECT_EQ(0u, cancel_log.size());  // Result returned synchronously.
 }
 
 TEST_F(FileSystemProviderFileStreamWriter, Write_WrongFile) {
   std::vector<int> write_log;
 
-  const int64 initial_offset = 0;
+  const int64_t initial_offset = 0;
   FileStreamWriter writer(wrong_file_url_, initial_offset);
   scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
 
   const int result = writer.Write(io_buffer.get(),
                                   sizeof(kTextToWrite) - 1,
                                   base::Bind(&LogValue, &write_log));
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(1u, write_log.size());
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, write_log[0]);
 }
 
 TEST_F(FileSystemProviderFileStreamWriter, Write_Append) {
   std::vector<int> write_log;
 
   const FakeEntry* const entry =
       provided_file_system_->GetEntry(base::FilePath(kFakeFilePath));
   ASSERT_TRUE(entry);
 
   const std::string original_contents = entry->contents;
-  const int64 initial_offset = *entry->metadata->size;
+  const int64_t initial_offset = *entry->metadata->size;
   ASSERT_LT(0, initial_offset);
 
   FileStreamWriter writer(file_url_, initial_offset);
   scoped_refptr<net::IOBuffer> io_buffer(new net::StringIOBuffer(kTextToWrite));
 
   const int result = writer.Write(io_buffer.get(),
                                   sizeof(kTextToWrite) - 1,
                                   base::Bind(&LogValue, &write_log));
   EXPECT_EQ(net::ERR_IO_PENDING, result);
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(1u, write_log.size());
   EXPECT_EQ(sizeof(kTextToWrite) - 1, static_cast<size_t>(write_log[0]));
 
   const std::string expected_contents = original_contents + kTextToWrite;
   EXPECT_EQ(expected_contents, entry->contents);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos