Switch to standard integer types in net/.

net/disk_cache/disk_cache.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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://dev.chromium.org/developers/design-documents/network-stack/disk-cache
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H_
 #define NET_DISK_CACHE_DISK_CACHE_H_
 
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 
 namespace base {
 class FilePath;
@@ skipping 66 matching lines @@
   // operations so the callbacks are not invoked, possibly leaving the work
   // half way (for instance, dooming just a few entries). Note that pending IO
   // for a given Entry (as opposed to the Backend) will still generate a
   // callback from within this method.
   virtual ~Backend() {}
 
   // Returns the type of this cache.
   virtual net::CacheType GetCacheType() const = 0;
 
   // Returns the number of entries in the cache.
-  virtual int32 GetEntryCount() const = 0;
+  virtual int32_t GetEntryCount() const = 0;
 
   // Opens an existing entry. Upon success, |entry| holds a pointer to an Entry
   // object representing the specified disk cache entry. When the entry pointer
   // is no longer needed, its Close method should be called. The return value is
   // a net error code. If this method returns ERR_IO_PENDING, the |callback|
   // will be invoked when the entry is available. The pointer to receive the
   // |entry| must remain valid until the operation completes.
   virtual int OpenEntry(const std::string& key, Entry** entry,
                         const CompletionCallback& callback) = 0;
 
@@ skipping 68 matching lines @@
   // Returns the key associated with this cache entry.
   virtual std::string GetKey() const = 0;
 
   // Returns the time when this cache entry was last used.
   virtual base::Time GetLastUsed() const = 0;
 
   // Returns the time when this cache entry was last modified.
   virtual base::Time GetLastModified() const = 0;
 
   // Returns the size of the cache data with the given index.
-  virtual int32 GetDataSize(int index) const = 0;
+  virtual int32_t GetDataSize(int index) const = 0;
 
   // Copies cached data into the given buffer of length |buf_len|. Returns the
   // number of bytes read or a network error code. If this function returns
   // ERR_IO_PENDING, the completion callback will be called on the current
   // thread when the operation completes, and a reference to |buf| will be
   // retained until the callback is called. Note that as long as the function
   // does not complete immediately, the callback will always be invoked, even
   // after Close has been called; in other words, the caller may close this
   // entry without having to wait for all the callbacks, and still rely on the
   // cleanup performed from the callback code.
@@ skipping 52 matching lines @@
   // requirement includes the case when an entry is closed while some operation
   // is in progress and another object is instantiated; any IO operation will
   // fail while the previous operation is still in-flight. In order to deal with
   // this requirement, the caller could either wait until the operation
   // completes before closing the entry, or call CancelSparseIO() before closing
   // the entry, and call ReadyForSparseIO() on the new entry and wait for the
   // callback before issuing new operations.
 
   // Behaves like ReadData() except that this method is used to access sparse
   // entries.
-  virtual int ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+  virtual int ReadSparseData(int64_t offset,
+                             IOBuffer* buf,
+                             int buf_len,
                              const CompletionCallback& callback) = 0;
 
   // Behaves like WriteData() except that this method is used to access sparse
   // entries. |truncate| is not part of this interface because a sparse entry
   // is not expected to be reused with new data. To delete the old data and
   // start again, or to reduce the total size of the stream data (which implies
   // that the content has changed), the whole entry should be doomed and
   // re-created.
-  virtual int WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+  virtual int WriteSparseData(int64_t offset,
+                              IOBuffer* buf,
+                              int buf_len,
                               const CompletionCallback& callback) = 0;
 
   // Returns information about the currently stored portion of a sparse entry.
   // |offset| and |len| describe a particular range that should be scanned to
   // find out if it is stored or not. |start| will contain the offset of the
   // first byte that is stored within this range, and the return value is the
   // minimum number of consecutive stored bytes. Note that it is possible that
   // this entry has stored more than the returned value. This method returns a
   // net error code whenever the request cannot be completed successfully. If
   // this method returns ERR_IO_PENDING, the |callback| will be invoked when the
   // operation completes, and |start| must remain valid until that point.
-  virtual int GetAvailableRange(int64 offset, int len, int64* start,
+  virtual int GetAvailableRange(int64_t offset,
+                                int len,
+                                int64_t* start,
                                 const CompletionCallback& callback) = 0;
 
   // Returns true if this entry could be a sparse entry or false otherwise. This
   // is a quick test that may return true even if the entry is not really
   // sparse. This method doesn't modify the state of this entry (it will not
   // create sparse tracking data). GetAvailableRange or ReadSparseData can be
   // used to perform a definitive test of whether an existing entry is sparse or
   // not, but that method may modify the current state of the entry (making it
   // sparse, for instance). The purpose of this method is to test an existing
   // entry, but without generating actual IO to perform a thorough check.
@@ skipping 29 matching lines @@
     entry->Close();
   }
 };
 
 // Automatically closes an entry when it goes out of scope.
 typedef scoped_ptr<Entry, EntryDeleter> ScopedEntryPtr;
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_