Switch to standard integer types in net/.

net/disk_cache/blockfile/sparse_control_v3.h

 // 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.
 
 #ifndef NET_DISK_CACHE_BLOCKFILE_SPARSE_CONTROL_V3_H_
 #define NET_DISK_CACHE_BLOCKFILE_SPARSE_CONTROL_V3_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "net/base/completion_callback.h"
 #include "net/disk_cache/blockfile/bitmap.h"
 #include "net/disk_cache/disk_format.h"
 
 namespace net {
 class IOBuffer;
 class DrainableIOBuffer;
 }
 
 namespace disk_cache {
@@ skipping 24 matching lines @@
   // Performs a quick test to see if the entry is sparse or not, without
   // generating disk IO (so the answer provided is only a best effort).
   bool CouldBeSparse() const;
 
   // Performs an actual sparse read or write operation for this entry. |op| is
   // the operation to perform, |offset| is the desired sparse offset, |buf| and
   // |buf_len| specify the actual data to use and |callback| is the callback
   // to use for asynchronous operations. See the description of the Read /
   // WriteSparseData for details about the arguments. The return value is the
   // number of bytes read or written, or a net error code.
-  int StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
-              int buf_len, const CompletionCallback& callback);
+  int StartIO(SparseOperation op,
+              int64_t offset,
+              net::IOBuffer* buf,
+              int buf_len,
+              const CompletionCallback& callback);
 
   // Implements Entry::GetAvailableRange().
-  int GetAvailableRange(int64 offset, int len, int64* start);
+  int GetAvailableRange(int64_t offset, int len, int64_t* start);
 
   // Cancels the current sparse operation (if any).
   void CancelIO();
 
   // Returns OK if the entry can be used for new IO or ERR_IO_PENDING if we are
   // busy. If the entry is busy, we'll invoke the callback when we are ready
   // again. See disk_cache::Entry::ReadyToUse() for more info.
   int ReadyToUse(const CompletionCallback& completion_callback);
 
   // Deletes the children entries of |entry|.
@@ skipping 81 matching lines @@
   bool range_found_;  // True if GetAvailableRange found something.
   bool abort_;  // True if we should abort the current operation ASAP.
 
   SparseHeader sparse_header_;  // Data about the children of entry_.
   Bitmap children_map_;  // The actual bitmap of children.
   SparseData child_data_;  // Parent and allocation map of child_.
   Bitmap child_map_;  // The allocation map as a bitmap.
 
   CompletionCallback user_callback_;
   std::vector<CompletionCallback> abort_callbacks_;
-  int64 offset_;  // Current sparse offset.
+  int64_t offset_;  // Current sparse offset.
   scoped_refptr<net::DrainableIOBuffer> user_buf_;
   int buf_len_;  // Bytes to read or write.
   int child_offset_;  // Offset to use for the current child.
   int child_len_;  // Bytes to read or write for this child.
   int result_;
 
   DISALLOW_COPY_AND_ASSIGN(SparseControl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_SPARSE_CONTROL_V3_H_