Remove kint64max.

net/disk_cache/simple/simple_entry_impl.h

 // Copyright (c) 2013 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_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 
+#include <stdint.h>
+
 #include <queue>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/disk_cache/disk_cache.h"
@@ skipping 32 matching lines @@
   // The Backend provides an |ActiveEntryProxy| instance to this entry when it
   // is active, meaning it's the canonical entry for this |entry_hash_|. The
   // entry can make itself inactive by deleting its proxy.
   class ActiveEntryProxy {
    public:
     virtual ~ActiveEntryProxy() = 0;
   };
 
   SimpleEntryImpl(net::CacheType cache_type,
                   const base::FilePath& path,
-                  uint64 entry_hash,
+                  uint64_t entry_hash,
                   OperationsMode operations_mode,
                   SimpleBackendImpl* backend,
                   net::NetLog* net_log);
 
   void SetActiveEntryProxy(
       scoped_ptr<ActiveEntryProxy> active_entry_proxy);
 
   // Adds another reader/writer to this entry, if possible, returning |this| to
   // |entry|.
   int OpenEntry(Entry** entry, const CompletionCallback& callback);
 
   // Creates this entry, if possible. Returns |this| to |entry|.
   int CreateEntry(Entry** entry, const CompletionCallback& callback);
 
   // Identical to Backend::Doom() except that it accepts a CompletionCallback.
   int DoomEntry(const CompletionCallback& callback);
 
   const std::string& key() const { return key_; }
-  uint64 entry_hash() const { return entry_hash_; }
+  uint64_t entry_hash() const { return entry_hash_; }
   void SetKey(const std::string& key);
 
   // From Entry:
   void Doom() override;
   void Close() override;
   std::string GetKey() const override;
   base::Time GetLastUsed() const override;
   base::Time GetLastModified() const override;
-  int32 GetDataSize(int index) const override;
+  int32_t GetDataSize(int index) const override;
   int ReadData(int stream_index,
                int offset,
                net::IOBuffer* buf,
                int buf_len,
                const CompletionCallback& callback) override;
   int WriteData(int stream_index,
                 int offset,
                 net::IOBuffer* buf,
                 int buf_len,
                 const CompletionCallback& callback,
                 bool truncate) override;
-  int ReadSparseData(int64 offset,
+  int ReadSparseData(int64_t offset,
                      net::IOBuffer* buf,
                      int buf_len,
                      const CompletionCallback& callback) override;
-  int WriteSparseData(int64 offset,
+  int WriteSparseData(int64_t offset,
                       net::IOBuffer* buf,
                       int buf_len,
                       const CompletionCallback& callback) override;
-  int GetAvailableRange(int64 offset,
+  int GetAvailableRange(int64_t offset,
                         int len,
-                        int64* start,
+                        int64_t* start,
                         const CompletionCallback& callback) override;
   bool CouldBeSparse() const override;
   void CancelSparseIO() override;
   int ReadyForSparseIO(const CompletionCallback& callback) override;
 
  private:
   class ScopedOperationRunner;
   friend class ScopedOperationRunner;
 
   enum State {
@@ skipping 65 matching lines @@
                         int buf_len,
                         const CompletionCallback& callback);
 
   void WriteDataInternal(int index,
                          int offset,
                          net::IOBuffer* buf,
                          int buf_len,
                          const CompletionCallback& callback,
                          bool truncate);
 
-  void ReadSparseDataInternal(int64 sparse_offset,
+  void ReadSparseDataInternal(int64_t sparse_offset,
                               net::IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback);
 
-  void WriteSparseDataInternal(int64 sparse_offset,
+  void WriteSparseDataInternal(int64_t sparse_offset,
                                net::IOBuffer* buf,
                                int buf_len,
                                const CompletionCallback& callback);
 
-  void GetAvailableRangeInternal(int64 sparse_offset,
+  void GetAvailableRangeInternal(int64_t sparse_offset,
                                  int len,
-                                 int64* out_start,
+                                 int64_t* out_start,
                                  const CompletionCallback& callback);
 
   void DoomEntryInternal(const CompletionCallback& callback);
 
   // Called after a SimpleSynchronousEntry has completed CreateEntry() or
   // OpenEntry(). If |in_sync_entry| is non-NULL, creation is successful and we
   // can return |this| SimpleEntryImpl to |*out_entry|. Runs
   // |completion_callback|.
   void CreationOperationComplete(
       const CompletionCallback& completion_callback,
@@ skipping 10 matching lines @@
   // Internal utility method used by other completion methods. Calls
   // |completion_callback| after updating state and dooming on errors.
   void EntryOperationComplete(const CompletionCallback& completion_callback,
                               const SimpleEntryStat& entry_stat,
                               scoped_ptr<int> result);
 
   // Called after an asynchronous read. Updates |crc32s_| if possible.
   void ReadOperationComplete(int stream_index,
                              int offset,
                              const CompletionCallback& completion_callback,
-                             scoped_ptr<uint32> read_crc32,
+                             scoped_ptr<uint32_t> read_crc32,
                              scoped_ptr<SimpleEntryStat> entry_stat,
                              scoped_ptr<int> result);
 
   // Called after an asynchronous write completes.
   void WriteOperationComplete(int stream_index,
                               const CompletionCallback& completion_callback,
                               scoped_ptr<SimpleEntryStat> entry_stat,
                               scoped_ptr<int> result);
 
   void ReadSparseOperationComplete(
@@ skipping 22 matching lines @@
       int stream_index,
       int orig_result,
       const CompletionCallback& completion_callback,
       scoped_ptr<int> result);
 
   // Called after completion of asynchronous IO and receiving file metadata for
   // the entry in |entry_stat|. Updates the metadata in the entry and in the
   // index to make them available on next IO operations.
   void UpdateDataFromEntryStat(const SimpleEntryStat& entry_stat);
 
-  int64 GetDiskUsage() const;
+  int64_t GetDiskUsage() const;
 
   // Used to report histograms.
   void RecordReadIsParallelizable(const SimpleEntryOperation& operation) const;
   void RecordWriteDependencyType(const SimpleEntryOperation& operation) const;
 
   // Reads from the stream 0 data kept in memory.
   int ReadStream0Data(net::IOBuffer* buf, int offset, int buf_len);
 
   // Copies data from |buf| to the internal in-memory buffer for stream 0. If
   // |truncate| is set to true, the target buffer will be truncated at |offset|
@@ skipping 12 matching lines @@
   scoped_ptr<ActiveEntryProxy> active_entry_proxy_;
 
   // All nonstatic SimpleEntryImpl methods should always be called on the IO
   // thread, in all cases. |io_thread_checker_| documents and enforces this.
   base::ThreadChecker io_thread_checker_;
 
   const base::WeakPtr<SimpleBackendImpl> backend_;
   const net::CacheType cache_type_;
   const scoped_refptr<base::TaskRunner> worker_pool_;
   const base::FilePath path_;
-  const uint64 entry_hash_;
+  const uint64_t entry_hash_;
   const bool use_optimistic_operations_;
   std::string key_;
 
   // |last_used_|, |last_modified_| and |data_size_| are copied from the
   // synchronous entry at the completion of each item of asynchronous IO.
   // TODO(clamy): Unify last_used_ with data in the index.
   base::Time last_used_;
   base::Time last_modified_;
-  int32 data_size_[kSimpleEntryStreamCount];
-  int32 sparse_data_size_;
+  int32_t data_size_[kSimpleEntryStreamCount];
+  int32_t sparse_data_size_;
 
   // Number of times this object has been returned from Backend::OpenEntry() and
   // Backend::CreateEntry() without subsequent Entry::Close() calls. Used to
   // notify the backend when this entry not used by any callers.
   int open_count_;
 
   bool doomed_;
 
   State state_;
 
   // When possible, we compute a crc32, for the data in each entry as we read or
   // write. For each stream, |crc32s_[index]| is the crc32 of that stream from
   // [0 .. |crc32s_end_offset_|). If |crc32s_end_offset_[index] == 0| then the
   // value of |crc32s_[index]| is undefined.
   // Note at this can only be done in the current implementation in the case of
   // a single entry reader that reads serially through the entire file.
   // Extending this to multiple readers is possible, but isn't currently worth
   // it; see http://crbug.com/488076#c3 for details.
-  int32 crc32s_end_offset_[kSimpleEntryStreamCount];
-  uint32 crc32s_[kSimpleEntryStreamCount];
+  int32_t crc32s_end_offset_[kSimpleEntryStreamCount];
+  uint32_t crc32s_[kSimpleEntryStreamCount];
 
   // If |have_written_[index]| is true, we have written to the file that
   // contains stream |index|.
   bool have_written_[kSimpleEntryStreamCount];
 
   // Reflects how much CRC checking has been done with the entry. This state is
   // reported on closing each entry stream.
   CheckCrcResult crc_check_state_[kSimpleEntryStreamCount];
 
   // The |synchronous_entry_| is the worker thread object that performs IO on
@@ skipping 18 matching lines @@
   // 1 on disk, to reduce the number of file descriptors and save disk space.
   // This strategy allows stream 1 to change size easily. Since stream 0 is only
   // used to write HTTP headers, the memory consumption of keeping it in memory
   // is acceptable.
   scoped_refptr<net::GrowableIOBuffer> stream_0_data_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_