Switch to standard integer types in net/.

net/disk_cache/blockfile/in_flight_backend_io.cc

 // Copyright (c) 2012 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 "net/disk_cache/blockfile/in_flight_backend_io.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 158 matching lines @@
                           net::IOBuffer* buf, int buf_len, bool truncate) {
   operation_ = OP_WRITE;
   entry_ = entry;
   index_ = index;
   offset_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
   truncate_ = truncate;
 }
 
-void BackendIO::ReadSparseData(EntryImpl* entry, int64 offset,
-                               net::IOBuffer* buf, int buf_len) {
+void BackendIO::ReadSparseData(EntryImpl* entry,
+                               int64_t offset,
+                               net::IOBuffer* buf,
+                               int buf_len) {
   operation_ = OP_READ_SPARSE;
   entry_ = entry;
   offset64_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
 }
 
-void BackendIO::WriteSparseData(EntryImpl* entry, int64 offset,
-                                net::IOBuffer* buf, int buf_len) {
+void BackendIO::WriteSparseData(EntryImpl* entry,
+                                int64_t offset,
+                                net::IOBuffer* buf,
+                                int buf_len) {
   operation_ = OP_WRITE_SPARSE;
   entry_ = entry;
   offset64_ = offset;
   buf_ = buf;
   buf_len_ = buf_len;
 }
 
-void BackendIO::GetAvailableRange(EntryImpl* entry, int64 offset, int len,
-                                  int64* start) {
+void BackendIO::GetAvailableRange(EntryImpl* entry,
+                                  int64_t offset,
+                                  int len,
+                                  int64_t* start) {
   operation_ = OP_GET_RANGE;
   entry_ = entry;
   offset64_ = offset;
   buf_len_ = len;
   start_ = start;
 }
 
 void BackendIO::CancelSparseIO(EntryImpl* entry) {
   operation_ = OP_CANCEL_IO;
   entry_ = entry;
@@ skipping 248 matching lines @@
 void InFlightBackendIO::WriteData(EntryImpl* entry, int index, int offset,
                                   net::IOBuffer* buf, int buf_len,
                                   bool truncate,
                                   const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteData(entry, index, offset, buf, buf_len, truncate);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::ReadSparseData(
-    EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
+    EntryImpl* entry,
+    int64_t offset,
+    net::IOBuffer* buf,
+    int buf_len,
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->ReadSparseData(entry, offset, buf, buf_len);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::WriteSparseData(
-    EntryImpl* entry, int64 offset, net::IOBuffer* buf, int buf_len,
+    EntryImpl* entry,
+    int64_t offset,
+    net::IOBuffer* buf,
+    int buf_len,
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->WriteSparseData(entry, offset, buf, buf_len);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::GetAvailableRange(
-    EntryImpl* entry, int64 offset, int len, int64* start,
+    EntryImpl* entry,
+    int64_t offset,
+    int len,
+    int64_t* start,
     const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->GetAvailableRange(entry, offset, len, start);
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::CancelSparseIO(EntryImpl* entry) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->CancelSparseIO(entry);
@@ skipping 24 matching lines @@
   background_thread_->PostTask(
       FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation));
   OnOperationPosted(operation);
 }
 
 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace