Switch to standard integer types in base/files/.

base/files/file_proxy.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 "base/files/file_proxy.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 
 namespace {
 
 void FileDeleter(base::File file) {
 }
 
 }  // namespace
 
@@ skipping 36 matching lines @@
   void Close() {
     file_.Close();
     error_ = File::FILE_OK;
   }
 
   void SetTimes(Time last_access_time, Time last_modified_time) {
     bool rv = file_.SetTimes(last_access_time, last_modified_time);
     error_ = rv ? File::FILE_OK : File::FILE_ERROR_FAILED;
   }
 
-  void SetLength(int64 length) {
+  void SetLength(int64_t length) {
     if (file_.SetLength(length))
       error_ = File::FILE_OK;
   }
 
   void Flush() {
     if (file_.Flush())
       error_ = File::FILE_OK;
   }
 
   void Reply(const FileProxy::StatusCallback& callback) {
@@ skipping 26 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(CreateOrOpenHelper);
 };
 
 class CreateTemporaryHelper : public FileHelper {
  public:
   CreateTemporaryHelper(FileProxy* proxy, File file)
       : FileHelper(proxy, std::move(file)) {
   }
 
-  void RunWork(uint32 additional_file_flags) {
+  void RunWork(uint32_t additional_file_flags) {
     // TODO(darin): file_util should have a variant of CreateTemporaryFile
     // that returns a FilePath and a File.
     if (!CreateTemporaryFile(&file_path_)) {
       // TODO(davidben): base::CreateTemporaryFile should preserve the error
       // code.
       error_ = File::FILE_ERROR_FAILED;
       return;
     }
 
-    uint32 file_flags = File::FLAG_WRITE |
-                        File::FLAG_TEMPORARY |
-                        File::FLAG_CREATE_ALWAYS |
-                        additional_file_flags;
+    uint32_t file_flags = File::FLAG_WRITE | File::FLAG_TEMPORARY |
+                          File::FLAG_CREATE_ALWAYS | additional_file_flags;
 
     file_.Initialize(file_path_, file_flags);
     if (file_.IsValid()) {
       error_ = File::FILE_OK;
     } else {
       error_ = file_.error_details();
       DeleteFile(file_path_, false);
       file_path_.clear();
     }
   }
@@ skipping 33 matching lines @@
 
 class ReadHelper : public FileHelper {
  public:
   ReadHelper(FileProxy* proxy, File file, int bytes_to_read)
       : FileHelper(proxy, std::move(file)),
         buffer_(new char[bytes_to_read]),
         bytes_to_read_(bytes_to_read),
         bytes_read_(0) {
   }
 
-  void RunWork(int64 offset) {
+  void RunWork(int64_t offset) {
     bytes_read_ = file_.Read(offset, buffer_.get(), bytes_to_read_);
     error_ = (bytes_read_ < 0) ? File::FILE_ERROR_FAILED : File::FILE_OK;
   }
 
   void Reply(const FileProxy::ReadCallback& callback) {
     PassFile();
     DCHECK(!callback.is_null());
     callback.Run(error_, buffer_.get(), bytes_read_);
   }
 
  private:
   scoped_ptr<char[]> buffer_;
   int bytes_to_read_;
   int bytes_read_;
   DISALLOW_COPY_AND_ASSIGN(ReadHelper);
 };
 
 class WriteHelper : public FileHelper {
  public:
   WriteHelper(FileProxy* proxy,
               File file,
               const char* buffer, int bytes_to_write)
       : FileHelper(proxy, std::move(file)),
         buffer_(new char[bytes_to_write]),
         bytes_to_write_(bytes_to_write),
         bytes_written_(0) {
     memcpy(buffer_.get(), buffer, bytes_to_write);
   }
 
-  void RunWork(int64 offset) {
+  void RunWork(int64_t offset) {
     bytes_written_ = file_.Write(offset, buffer_.get(), bytes_to_write_);
     error_ = (bytes_written_ < 0) ? File::FILE_ERROR_FAILED : File::FILE_OK;
   }
 
   void Reply(const FileProxy::WriteCallback& callback) {
     PassFile();
     if (!callback.is_null())
       callback.Run(error_, bytes_written_);
   }
 
  private:
   scoped_ptr<char[]> buffer_;
   int bytes_to_write_;
   int bytes_written_;
   DISALLOW_COPY_AND_ASSIGN(WriteHelper);
 };
 
 }  // namespace
 
 FileProxy::FileProxy(TaskRunner* task_runner) : task_runner_(task_runner) {
 }
 
 FileProxy::~FileProxy() {
   if (file_.IsValid())
     task_runner_->PostTask(FROM_HERE, Bind(&FileDeleter, Passed(&file_)));
 }
 
 bool FileProxy::CreateOrOpen(const FilePath& file_path,
-                             uint32 file_flags,
+                             uint32_t file_flags,
                              const StatusCallback& callback) {
   DCHECK(!file_.IsValid());
   CreateOrOpenHelper* helper = new CreateOrOpenHelper(this, File());
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&CreateOrOpenHelper::RunWork, Unretained(helper), file_path,
            file_flags),
       Bind(&CreateOrOpenHelper::Reply, Owned(helper), callback));
 }
 
-bool FileProxy::CreateTemporary(uint32 additional_file_flags,
+bool FileProxy::CreateTemporary(uint32_t additional_file_flags,
                                 const CreateTemporaryCallback& callback) {
   DCHECK(!file_.IsValid());
   CreateTemporaryHelper* helper = new CreateTemporaryHelper(this, File());
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&CreateTemporaryHelper::RunWork, Unretained(helper),
            additional_file_flags),
       Bind(&CreateTemporaryHelper::Reply, Owned(helper), callback));
 }
 
@@ skipping 25 matching lines @@
 
 bool FileProxy::GetInfo(const GetFileInfoCallback& callback) {
   DCHECK(file_.IsValid());
   GetInfoHelper* helper = new GetInfoHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&GetInfoHelper::RunWork, Unretained(helper)),
       Bind(&GetInfoHelper::Reply, Owned(helper), callback));
 }
 
-bool FileProxy::Read(int64 offset,
+bool FileProxy::Read(int64_t offset,
                      int bytes_to_read,
                      const ReadCallback& callback) {
   DCHECK(file_.IsValid());
   if (bytes_to_read < 0)
     return false;
 
   ReadHelper* helper = new ReadHelper(this, std::move(file_), bytes_to_read);
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&ReadHelper::RunWork, Unretained(helper), offset),
       Bind(&ReadHelper::Reply, Owned(helper), callback));
 }
 
-bool FileProxy::Write(int64 offset,
+bool FileProxy::Write(int64_t offset,
                       const char* buffer,
                       int bytes_to_write,
                       const WriteCallback& callback) {
   DCHECK(file_.IsValid());
   if (bytes_to_write <= 0 || buffer == NULL)
     return false;
 
   WriteHelper* helper =
       new WriteHelper(this, std::move(file_), buffer, bytes_to_write);
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&WriteHelper::RunWork, Unretained(helper), offset),
       Bind(&WriteHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::SetTimes(Time last_access_time,
                          Time last_modified_time,
                          const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&GenericFileHelper::SetTimes, Unretained(helper), last_access_time,
            last_modified_time),
       Bind(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
-bool FileProxy::SetLength(int64 length, const StatusCallback& callback) {
+bool FileProxy::SetLength(int64_t length, const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&GenericFileHelper::SetLength, Unretained(helper), length),
       Bind(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
 bool FileProxy::Flush(const StatusCallback& callback) {
   DCHECK(file_.IsValid());
   GenericFileHelper* helper = new GenericFileHelper(this, std::move(file_));
   return task_runner_->PostTaskAndReply(
       FROM_HERE,
       Bind(&GenericFileHelper::Flush, Unretained(helper)),
       Bind(&GenericFileHelper::Reply, Owned(helper), callback));
 }
 
 }  // namespace base