Remove kint32max.

net/disk_cache/blockfile/entry_impl.cc

 // 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.
 
 #include "net/disk_cache/blockfile/entry_impl.h"
 
+#include <limits>
+
 #include "base/hash.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/bitmap.h"
 #include "net/disk_cache/blockfile/disk_format.h"
 #include "net/disk_cache/blockfile/histogram_macros.h"
 #include "net/disk_cache/blockfile/sparse_control.h"
@@ skipping 326 matching lines @@
                                  truncate);
 
   if (result != net::ERR_IO_PENDING && net_log_.IsCapturing()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
         CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
-int EntryImpl::ReadSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::ReadSparseDataImpl(int64_t offset,
+                                  IOBuffer* buf,
+                                  int buf_len,
                                   const CompletionCallback& callback) {
   DCHECK(node_.Data()->dirty || read_only_);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   TimeTicks start = TimeTicks::Now();
   result = sparse_->StartIO(SparseControl::kReadOperation, offset, buf, buf_len,
                             callback);
   ReportIOTime(kSparseRead, start);
   return result;
 }
 
-int EntryImpl::WriteSparseDataImpl(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::WriteSparseDataImpl(int64_t offset,
+                                   IOBuffer* buf,
+                                   int buf_len,
                                    const CompletionCallback& callback) {
   DCHECK(node_.Data()->dirty || read_only_);
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   TimeTicks start = TimeTicks::Now();
   result = sparse_->StartIO(SparseControl::kWriteOperation, offset, buf,
                             buf_len, callback);
   ReportIOTime(kSparseWrite, start);
   return result;
 }
 
-int EntryImpl::GetAvailableRangeImpl(int64 offset, int len, int64* start) {
+int EntryImpl::GetAvailableRangeImpl(int64_t offset, int len, int64_t* start) {
   int result = InitSparseData();
   if (net::OK != result)
     return result;
 
   return sparse_->GetAvailableRange(offset, len, start);
 }
 
 void EntryImpl::CancelSparseIOImpl() {
   if (!sparse_.get())
     return;
 
   sparse_->CancelIO();
 }
 
 int EntryImpl::ReadyForSparseIOImpl(const CompletionCallback& callback) {
   DCHECK(sparse_.get());
   return sparse_->ReadyToUse(callback);
 }
 
-uint32 EntryImpl::GetHash() {
+uint32_t EntryImpl::GetHash() {
   return entry_.Data()->hash;
 }
 
-bool EntryImpl::CreateEntry(Addr node_address, const std::string& key,
-                            uint32 hash) {
+bool EntryImpl::CreateEntry(Addr node_address,
+                            const std::string& key,
+                            uint32_t hash) {
   Trace("Create entry In");
   EntryStore* entry_store = entry_.Data();
   RankingsNode* node = node_.Data();
   memset(entry_store, 0, sizeof(EntryStore) * entry_.address().num_blocks());
   memset(node, 0, sizeof(RankingsNode));
   if (!node_.LazyInit(backend_->File(node_address), node_address))
     return false;
 
   entry_store->rankings_node = node_address.value();
   node->contents = entry_.address().value();
 
   entry_store->hash = hash;
   entry_store->creation_time = Time::Now().ToInternalValue();
-  entry_store->key_len = static_cast<int32>(key.size());
+  entry_store->key_len = static_cast<int32_t>(key.size());
   if (entry_store->key_len > kMaxInternalKeyLength) {
     Addr address(0);
     if (!CreateBlock(entry_store->key_len + 1, &address))
       return false;
 
     entry_store->long_key = address.value();
     File* key_file = GetBackingFile(address, kKeyFileIndex);
     key_ = key;
 
     size_t offset = 0;
     if (address.is_block_file())
       offset = address.start_block() * address.BlockSize() + kBlockHeaderSize;
 
     if (!key_file || !key_file->Write(key.data(), key.size(), offset)) {
       DeleteData(address, kKeyFileIndex);
       return false;
     }
 
     if (address.is_separate_file())
       key_file->SetLength(key.size() + 1);
   } else {
     memcpy(entry_store->key, key.data(), key.size());
     entry_store->key[key.size()] = '\0';
   }
-  backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
-  CACHE_UMA(COUNTS, "KeySize", 0, static_cast<int32>(key.size()));
+  backend_->ModifyStorageSize(0, static_cast<int32_t>(key.size()));
+  CACHE_UMA(COUNTS, "KeySize", 0, static_cast<int32_t>(key.size()));
   node->dirty = backend_->GetCurrentEntryId();
   Log("Create Entry ");
   return true;
 }
 
-bool EntryImpl::IsSameEntry(const std::string& key, uint32 hash) {
+bool EntryImpl::IsSameEntry(const std::string& key, uint32_t hash) {
   if (entry_.Data()->hash != hash ||
       static_cast<size_t>(entry_.Data()->key_len) != key.size())
     return false;
 
   return (key.compare(GetKey()) == 0);
 }
 
 void EntryImpl::InternalDoom() {
   net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   DCHECK(node_.HasData());
@@ skipping 76 matching lines @@
 
   RankingsNode* rankings = node_.Data();
   if (!rankings->dirty) {
     rankings->dirty = backend_->GetCurrentEntryId();
     if (!node_.Store())
       return false;
   }
   return true;
 }
 
-void EntryImpl::SetDirtyFlag(int32 current_id) {
+void EntryImpl::SetDirtyFlag(int32_t current_id) {
   DCHECK(node_.HasData());
   if (node_.Data()->dirty && current_id != node_.Data()->dirty)
     dirty_ = true;
 
   if (!current_id)
     dirty_ = true;
 }
 
-void EntryImpl::SetPointerForInvalidEntry(int32 new_id) {
+void EntryImpl::SetPointerForInvalidEntry(int32_t new_id) {
   node_.Data()->dirty = new_id;
   node_.Store();
 }
 
 bool EntryImpl::LeaveRankingsBehind() {
   return !node_.Data()->contents;
 }
 
 // This only includes checks that relate to the first block of the entry (the
 // first 256 bytes), and values that should be set from the entry creation.
@@ skipping 224 matching lines @@
 Time EntryImpl::GetLastUsed() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_used);
 }
 
 Time EntryImpl::GetLastModified() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_modified);
 }
 
-int32 EntryImpl::GetDataSize(int index) const {
+int32_t EntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= kNumStreams)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
 int EntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
                         const CompletionCallback& callback) {
   if (callback.is_null())
@@ skipping 30 matching lines @@
     return net::ERR_INVALID_ARGUMENT;
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->WriteData(this, index, offset, buf, buf_len, truncate,
                                callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::ReadSparseData(int64_t offset,
+                              IOBuffer* buf,
+                              int buf_len,
                               const CompletionCallback& callback) {
   if (callback.is_null())
     return ReadSparseDataImpl(offset, buf, buf_len, callback);
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImpl::WriteSparseData(int64_t offset,
+                               IOBuffer* buf,
+                               int buf_len,
                                const CompletionCallback& callback) {
   if (callback.is_null())
     return WriteSparseDataImpl(offset, buf, buf_len, callback);
 
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->WriteSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-int EntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
+int EntryImpl::GetAvailableRange(int64_t offset,
+                                 int len,
+                                 int64_t* start,
                                  const CompletionCallback& callback) {
   if (!background_queue_.get())
     return net::ERR_UNEXPECTED;
 
   background_queue_->GetAvailableRange(this, offset, len, start, callback);
   return net::ERR_IO_PENDING;
 }
 
 bool EntryImpl::CouldBeSparse() const {
   if (sparse_.get())
@@ skipping 181 matching lines @@
   if (!backend_.get())
     return net::ERR_UNEXPECTED;
 
   int max_file_size = backend_->MaxFileSize();
 
   // offset or buf_len could be negative numbers.
   if (offset > max_file_size || buf_len > max_file_size ||
       offset + buf_len > max_file_size) {
     int size = offset + buf_len;
     if (size <= max_file_size)
-      size = kint32max;
+      size = std::numeric_limits<int32_t>::max();
     backend_->TooMuchStorageRequested(size);
     return net::ERR_FAILED;
   }
 
   TimeTicks start = TimeTicks::Now();
 
   // Read the size at this point (it may change inside prepare).
   int entry_size = entry_.Data()->data_size[index];
   bool extending = entry_size < offset + buf_len;
   truncate = truncate && entry_size > offset + buf_len;
@@ skipping 401 matching lines @@
 
   // Use a local variable so that sparse_ never goes from 'valid' to NULL.
   scoped_ptr<SparseControl> sparse(new SparseControl(this));
   int result = sparse->Init();
   if (net::OK == result)
     sparse_.swap(sparse);
 
   return result;
 }
 
-void EntryImpl::SetEntryFlags(uint32 flags) {
+void EntryImpl::SetEntryFlags(uint32_t flags) {
   entry_.Data()->flags |= flags;
   entry_.set_modified();
 }
 
-uint32 EntryImpl::GetEntryFlags() {
+uint32_t EntryImpl::GetEntryFlags() {
   return entry_.Data()->flags;
 }
 
 void EntryImpl::GetData(int index, char** buffer, Addr* address) {
   DCHECK(backend_.get());
   if (user_buffers_[index].get() && user_buffers_[index]->Size() &&
       !user_buffers_[index]->Start()) {
     // The data is already in memory, just copy it and we're done.
     int data_len = entry_.Data()->data_size[index];
     if (data_len <= user_buffers_[index]->Size()) {
@@ skipping 26 matching lines @@
   Trace("%s 0x%p 0x%x 0x%x", msg, reinterpret_cast<void*>(this),
         entry_.address().value(), node_.address().value());
 
   Trace("  data: 0x%x 0x%x 0x%x", entry_.Data()->data_addr[0],
         entry_.Data()->data_addr[1], entry_.Data()->long_key);
 
   Trace("  doomed: %d 0x%x", doomed_, dirty);
 }
 
 }  // namespace disk_cache