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

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_reader.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_reader.h"
 
 #include "base/files/file.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/chromeos/file_system_provider/abort_callback.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/scoped_file_opener.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 namespace file_system_provider {
 
 // Converts net::CompletionCallback to net::Int64CompletionCallback.
 void Int64ToIntCompletionCallback(net::CompletionCallback callback,
-                                  int64 result) {
+                                  int64_t result) {
   callback.Run(static_cast<int>(result));
 }
 
 class FileStreamReader::OperationRunner
     : public base::RefCountedThreadSafe<
           FileStreamReader::OperationRunner,
           content::BrowserThread::DeleteOnUIThread> {
  public:
   OperationRunner() : file_handle_(0) {}
 
@@ skipping 21 matching lines @@
         base::Bind(&OperationRunner::OnOpenFileCompletedOnUIThread, this,
                    callback)));
   }
 
   // Requests reading contents of a file. In case of either success or a failure
   // |callback| is executed. It can be called many times, until |has_more| is
   // set to false. This function guarantees that it will succeed only if the
   // file has not been changed while reading. Must be called on UI thread.
   void ReadFileOnUIThread(
       scoped_refptr<net::IOBuffer> buffer,
-      int64 offset,
+      int64_t offset,
       int length,
       const ProvidedFileSystemInterface::ReadChunkReceivedCallback& callback) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(abort_callback_.is_null());
 
     // If the file system got unmounted, then abort the reading operation.
     if (!file_system_.get()) {
       BrowserThread::PostTask(
           BrowserThread::IO,
           FROM_HERE,
@@ skipping 110 matching lines @@
   base::WeakPtr<ProvidedFileSystemInterface> file_system_;
   base::FilePath file_path_;
   scoped_ptr<ScopedFileOpener> file_opener_;
   int file_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(OperationRunner);
 };
 
 FileStreamReader::FileStreamReader(storage::FileSystemContext* context,
                                    const storage::FileSystemURL& url,
-                                   int64 initial_offset,
+                                   int64_t initial_offset,
                                    const base::Time& expected_modification_time)
     : url_(url),
       current_offset_(initial_offset),
       current_length_(0),
       expected_modification_time_(expected_modification_time),
       runner_(new OperationRunner),
       state_(NOT_INITIALIZED),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 FileStreamReader::~FileStreamReader() {
   // FileStreamReader doesn't have a Cancel() method like in FileStreamWriter.
   // Therefore, aborting and/or closing an opened file is done from the
   // destructor.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&OperationRunner::CloseRunnerOnUIThread, runner_));
 
   // If a read is in progress, mark it as completed.
@@ skipping 127 matching lines @@
 }
 
 void FileStreamReader::OnReadCompleted(net::CompletionCallback callback,
                                        int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   callback.Run(static_cast<int>(result));
   TRACE_EVENT_ASYNC_END0(
       "file_system_provider", "FileStreamReader::Read", this);
 }
 
-int64 FileStreamReader::GetLength(
+int64_t FileStreamReader::GetLength(
     const net::Int64CompletionCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   switch (state_) {
     case NOT_INITIALIZED:
       // Lazily initialize with the first call to GetLength().
     Initialize(base::Bind(&FileStreamReader::GetLengthAfterInitialized,
                           weak_ptr_factory_.GetWeakPtr(),
                           callback),
                callback);
@@ skipping 103 matching lines @@
     callback.Run(net::ERR_UPLOAD_FILE_CHANGED);
     return;
   }
 
   DCHECK_EQ(base::File::FILE_OK, result);
   callback.Run(*metadata->size);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos