Switch to standard integer types in chrome/browser/, part 2 of 4.

chrome/browser/media_galleries/fileapi/mtp_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/media_galleries/fileapi/mtp_file_stream_reader.h"
 
 #include <algorithm>
 
 #include "base/numerics/safe_conversions.h"
 #include "chrome/browser/media_galleries/fileapi/mtp_device_async_delegate.h"
@@ skipping 25 matching lines @@
 
 void CallInt64CompletionCallbackWithPlatformFileError(
     const net::Int64CompletionCallback& callback,
     base::File::Error file_error) {
   callback.Run(net::FileErrorToNetError(file_error));
 }
 
 void ReadBytes(
     const storage::FileSystemURL& url,
     const scoped_refptr<net::IOBuffer>& buf,
-    int64 offset,
+    int64_t offset,
     int buf_len,
     const MTPDeviceAsyncDelegate::ReadBytesSuccessCallback& success_callback,
     const net::CompletionCallback& error_callback) {
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
     error_callback.Run(net::ERR_FAILED);
     return;
   }
 
   delegate->ReadBytes(
       url.path(),
       buf,
       offset,
       buf_len,
       success_callback,
       base::Bind(&CallCompletionCallbackWithPlatformFileError, error_callback));
 }
 
 }  // namespace
 
 MTPFileStreamReader::MTPFileStreamReader(
     storage::FileSystemContext* file_system_context,
     const storage::FileSystemURL& url,
-    int64 initial_offset,
+    int64_t initial_offset,
     const base::Time& expected_modification_time,
     bool do_media_header_validation)
     : file_system_context_(file_system_context),
       url_(url),
       current_offset_(initial_offset),
       expected_modification_time_(expected_modification_time),
       media_header_validated_(!do_media_header_validation),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 MTPFileStreamReader::~MTPFileStreamReader() {
 }
 
 int MTPFileStreamReader::Read(net::IOBuffer* buf, int buf_len,
                               const net::CompletionCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url_);
   if (!delegate)
@@ skipping 29 matching lines @@
   }
 
   ReadBytes(url_, buf, current_offset_, buf_len,
             base::Bind(&MTPFileStreamReader::FinishRead,
                        weak_factory_.GetWeakPtr(), callback),
             callback);
 
   return net::ERR_IO_PENDING;
 }
 
-int64 MTPFileStreamReader::GetLength(
+int64_t MTPFileStreamReader::GetLength(
     const net::Int64CompletionCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url_);
   if (!delegate)
     return net::ERR_FAILED;
 
   delegate->GetFileInfo(
         url_.path(),
         base::Bind(&MTPFileStreamReader::FinishGetLength,
@@ skipping 54 matching lines @@
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   if (!VerifySnapshotTime(expected_modification_time_, file_info)) {
     callback.Run(net::ERR_UPLOAD_FILE_CHANGED);
     return;
   }
 
   callback.Run(file_info.size);
 }