Remove kint32max.

net/disk_cache/blockfile/entry_impl.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_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_BLOCKFILE_ENTRY_IMPL_H_
 
+#include <stdint.h>
+
 #include "base/memory/scoped_ptr.h"
 #include "net/disk_cache/blockfile/disk_format.h"
 #include "net/disk_cache/blockfile/storage_block-inl.h"
 #include "net/disk_cache/blockfile/storage_block.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/log/net_log.h"
 
 namespace disk_cache {
 
 class BackendImpl;
@@ skipping 21 matching lines @@
   };
 
   EntryImpl(BackendImpl* backend, Addr address, bool read_only);
 
   // Background implementation of the Entry interface.
   void DoomImpl();
   int ReadDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
                    const CompletionCallback& callback);
   int WriteDataImpl(int index, int offset, IOBuffer* buf, int buf_len,
                     const CompletionCallback& callback, bool truncate);
-  int ReadSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+  int ReadSparseDataImpl(int64_t offset,
+                         IOBuffer* buf,
+                         int buf_len,
                          const CompletionCallback& callback);
-  int WriteSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+  int WriteSparseDataImpl(int64_t offset,
+                          IOBuffer* buf,
+                          int buf_len,
                           const CompletionCallback& callback);
-  int GetAvailableRangeImpl(int64 offset, int len, int64* start);
+  int GetAvailableRangeImpl(int64_t offset, int len, int64_t* start);
   void CancelSparseIOImpl();
   int ReadyForSparseIOImpl(const CompletionCallback& callback);
 
   inline CacheEntryBlock* entry() {
     return &entry_;
   }
 
   inline CacheRankingsBlock* rankings() {
     return &node_;
   }
 
-  uint32 GetHash();
+  uint32_t GetHash();
 
   // Performs the initialization of a EntryImpl that will be added to the
   // cache.
-  bool CreateEntry(Addr node_address, const std::string& key, uint32 hash);
+  bool CreateEntry(Addr node_address, const std::string& key, uint32_t hash);
 
   // Returns true if this entry matches the lookup arguments.
-  bool IsSameEntry(const std::string& key, uint32 hash);
+  bool IsSameEntry(const std::string& key, uint32_t hash);
 
   // Permamently destroys this entry.
   void InternalDoom();
 
   // Deletes this entry from disk. If |everything| is false, only the user data
   // will be removed, leaving the key and control data intact.
   void DeleteEntryData(bool everything);
 
   // Returns the address of the next entry on the list of entries with the same
   // hash.
@@ skipping 14 matching lines @@
   bool dirty() {
     return dirty_;
   }
 
   bool doomed() {
     return doomed_;
   }
 
   // Marks this entry as dirty (in memory) if needed. This is intended only for
   // entries that are being read from disk, to be called during loading.
-  void SetDirtyFlag(int32 current_id);
+  void SetDirtyFlag(int32_t current_id);
 
   // Fixes this entry so it can be treated as valid (to delete it).
-  void SetPointerForInvalidEntry(int32 new_id);
+  void SetPointerForInvalidEntry(int32_t new_id);
 
   // Returns true if this entry is so meesed up that not everything is going to
   // be removed.
   bool LeaveRankingsBehind();
 
   // Returns false if the entry is clearly invalid.
   bool SanityCheck();
   bool DataSanityCheck();
 
   // Attempts to make this entry reachable though the key.
@@ skipping 24 matching lines @@
 
   // Returns the number of blocks needed to store an EntryStore.
   static int NumBlocksForEntry(int key_size);
 
   // Entry interface.
   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 index,
                int offset,
                IOBuffer* buf,
                int buf_len,
                const CompletionCallback& callback) override;
   int WriteData(int index,
                 int offset,
                 IOBuffer* buf,
                 int buf_len,
                 const CompletionCallback& callback,
                 bool truncate) override;
-  int ReadSparseData(int64 offset,
+  int ReadSparseData(int64_t offset,
                      IOBuffer* buf,
                      int buf_len,
                      const CompletionCallback& callback) override;
-  int WriteSparseData(int64 offset,
+  int WriteSparseData(int64_t offset,
                       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:
   enum {
      kNumStreams = 3
   };
   class UserBuffer;
@@ skipping 53 matching lines @@
   // is determined based on the current data length and |min_len|.
   bool Flush(int index, int min_len);
 
   // Updates the size of a given data stream.
   void UpdateSize(int index, int old_size, int new_size);
 
   // Initializes the sparse control object. Returns a net error code.
   int InitSparseData();
 
   // Adds the provided |flags| to the current EntryFlags for this entry.
-  void SetEntryFlags(uint32 flags);
+  void SetEntryFlags(uint32_t flags);
 
   // Returns the current EntryFlags for this entry.
-  uint32 GetEntryFlags();
+  uint32_t GetEntryFlags();
 
   // Gets the data stored at the given index. If the information is in memory,
   // a buffer will be allocated and the data will be copied to it (the caller
   // can find out the size of the buffer before making this call). Otherwise,
   // the cache address of the data will be returned, and that address will be
   // removed from the regular book keeping of this entry so the caller is
   // responsible for deleting the block (or file) from the backing store at some
   // point; there is no need to report any storage-size change, only to do the
   // actual cleanup.
   void GetData(int index, char** buffer, Addr* address);
@@ skipping 16 matching lines @@
   scoped_ptr<SparseControl> sparse_;  // Support for sparse entries.
 
   net::BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(EntryImpl);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_ENTRY_IMPL_H_