Switch to standard integer types in net/.

net/disk_cache/blockfile/in_flight_backend_io.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_IN_FLIGHT_BACKEND_IO_H_
 #define NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_
 
+#include <stdint.h>
+
 #include <list>
 #include <string>
 
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/blockfile/in_flight_io.h"
 #include "net/disk_cache/blockfile/rankings.h"
 
 namespace disk_cache {
 
@@ skipping 40 matching lines @@
   void EndEnumeration(scoped_ptr<Rankings::Iterator> iterator);
   void OnExternalCacheHit(const std::string& key);
   void CloseEntryImpl(EntryImpl* entry);
   void DoomEntryImpl(EntryImpl* entry);
   void FlushQueue();  // Dummy operation.
   void RunTask(const base::Closure& task);
   void ReadData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                 int buf_len);
   void WriteData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                  int buf_len, bool truncate);
-  void ReadSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
+  void ReadSparseData(EntryImpl* entry,
+                      int64_t offset,
+                      net::IOBuffer* buf,
                       int buf_len);
-  void WriteSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
+  void WriteSparseData(EntryImpl* entry,
+                       int64_t offset,
+                       net::IOBuffer* buf,
                        int buf_len);
-  void GetAvailableRange(EntryImpl* entry, int64 offset, int len, int64* start);
+  void GetAvailableRange(EntryImpl* entry,
+                         int64_t offset,
+                         int len,
+                         int64_t* start);
   void CancelSparseIO(EntryImpl* entry);
   void ReadyForSparseIO(EntryImpl* entry);
 
  private:
   // There are two types of operations to proxy: regular backend operations are
   // executed sequentially (queued by the message loop). On the other hand,
   // operations targeted to a given entry can be long lived and support multiple
   // simultaneous users (multiple reads or writes to the same entry), and they
   // are subject to throttling, so we keep an explicit queue.
   enum Operation {
@@ skipping 44 matching lines @@
   base::Time initial_time_;
   base::Time end_time_;
   Rankings::Iterator* iterator_;
   scoped_ptr<Rankings::Iterator> scoped_iterator_;
   EntryImpl* entry_;
   int index_;
   int offset_;
   scoped_refptr<net::IOBuffer> buf_;
   int buf_len_;
   bool truncate_;
-  int64 offset64_;
-  int64* start_;
+  int64_t offset64_;
+  int64_t* start_;
   base::TimeTicks start_time_;
   base::Closure task_;
 
   DISALLOW_COPY_AND_ASSIGN(BackendIO);
 };
 
 // The specialized controller that keeps track of current operations.
 class InFlightBackendIO : public InFlightIO {
  public:
   InFlightBackendIO(
@@ skipping 23 matching lines @@
   void CloseEntryImpl(EntryImpl* entry);
   void DoomEntryImpl(EntryImpl* entry);
   void FlushQueue(const net::CompletionCallback& callback);
   void RunTask(const base::Closure& task,
                const net::CompletionCallback& callback);
   void ReadData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                 int buf_len, const net::CompletionCallback& callback);
   void WriteData(
       EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
       int buf_len, bool truncate, const net::CompletionCallback& callback);
-  void ReadSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
-                      int buf_len, const net::CompletionCallback& callback);
-  void WriteSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
-                       int buf_len, const net::CompletionCallback& callback);
-  void GetAvailableRange(EntryImpl* entry, int64 offset, int len, int64* start,
+  void ReadSparseData(EntryImpl* entry,
+                      int64_t offset,
+                      net::IOBuffer* buf,
+                      int buf_len,
+                      const net::CompletionCallback& callback);
+  void WriteSparseData(EntryImpl* entry,
+                       int64_t offset,
+                       net::IOBuffer* buf,
+                       int buf_len,
+                       const net::CompletionCallback& callback);
+  void GetAvailableRange(EntryImpl* entry,
+                         int64_t offset,
+                         int len,
+                         int64_t* start,
                          const net::CompletionCallback& callback);
   void CancelSparseIO(EntryImpl* entry);
   void ReadyForSparseIO(EntryImpl* entry,
                         const net::CompletionCallback& callback);
 
   // Blocks until all operations are cancelled or completed.
   void WaitForPendingIO();
 
   scoped_refptr<base::SingleThreadTaskRunner> background_thread() {
     return background_thread_;
@@ skipping 15 matching lines @@
   BackendImpl* backend_;
   scoped_refptr<base::SingleThreadTaskRunner> background_thread_;
   base::WeakPtrFactory<InFlightBackendIO> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightBackendIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_