Remove kint32max.

net/disk_cache/blockfile/entry_impl_v3.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_v3.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_v3.h"
 #include "net/disk_cache/blockfile/bitmap.h"
 #include "net/disk_cache/blockfile/disk_format_v3.h"
 #include "net/disk_cache/blockfile/histogram_macros_v3.h"
 #include "net/disk_cache/cache_util.h"
@@ skipping 233 matching lines @@
       read_only_(read_only),
       dirty_(true),
       modified_(false) {
   for (int i = 0; i < kNumStreams; i++) {
     unreported_size_[i] = 0;
   }
 }
 
 #if defined(V3_NOT_JUST_YET_READY)
 
-bool EntryImplV3::CreateEntry(Addr node_address, const std::string& key,
-                              uint32 hash) {
+bool EntryImplV3::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;
 }
 
-uint32 EntryImplV3::GetHash() {
+uint32_t EntryImplV3::GetHash() {
   return entry_.Data()->hash;
 }
 
-bool EntryImplV3::IsSameEntry(const std::string& key, uint32 hash) {
+bool EntryImplV3::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 EntryImplV3::InternalDoom() {
   net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   DCHECK(node_.HasData());
@@ skipping 184 matching lines @@
 Time EntryImplV3::GetLastUsed() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_used);
 }
 
 Time EntryImplV3::GetLastModified() const {
   CacheRankingsBlock* node = const_cast<CacheRankingsBlock*>(&node_);
   return Time::FromInternalValue(node->Data()->last_modified);
 }
 
-int32 EntryImplV3::GetDataSize(int index) const {
+int32_t EntryImplV3::GetDataSize(int index) const {
   if (index < 0 || index >= kNumStreams)
     return 0;
 
   CacheEntryBlock* entry = const_cast<CacheEntryBlock*>(&entry_);
   return entry->Data()->data_size[index];
 }
 
 int EntryImplV3::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
                           const CompletionCallback& callback) {
   if (callback.is_null())
@@ skipping 68 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 EntryImplV3::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImplV3::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_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->ReadSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-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 EntryImplV3::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImplV3::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_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->WriteSparseData(this, offset, buf, buf_len, callback);
   return net::ERR_IO_PENDING;
 }
 
-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 EntryImplV3::GetAvailableRange(int64 offset, int len, int64* start,
+int EntryImplV3::GetAvailableRange(int64_t offset,
+                                   int len,
+                                   int64_t* start,
                                    const CompletionCallback& callback) {
   if (!background_queue_)
     return net::ERR_UNEXPECTED;
 
   background_queue_->GetAvailableRange(this, offset, len, start, callback);
   return net::ERR_IO_PENDING;
 }
 
-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);
 }
 
 bool EntryImplV3::CouldBeSparse() const {
   if (sparse_.get())
     return true;
@@ skipping 191 matching lines @@
   if (!backend_)
     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 424 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_);
   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 69 matching lines @@
 }
 
 Time EntryImplV3::GetLastUsed() const {
   return Time();
 }
 
 Time EntryImplV3::GetLastModified() const {
   return Time();
 }
 
-int32 EntryImplV3::GetDataSize(int index) const {
+int32_t EntryImplV3::GetDataSize(int index) const {
   return 0;
 }
 
 int EntryImplV3::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
                           const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int EntryImplV3::WriteData(int index, int offset, IOBuffer* buf, int buf_len,
                            const CompletionCallback& callback, bool truncate) {
   return net::ERR_FAILED;
 }
 
-int EntryImplV3::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImplV3::ReadSparseData(int64_t offset,
+                                IOBuffer* buf,
+                                int buf_len,
                                 const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
-int EntryImplV3::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int EntryImplV3::WriteSparseData(int64_t offset,
+                                 IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
-int EntryImplV3::GetAvailableRange(int64 offset, int len, int64* start,
+int EntryImplV3::GetAvailableRange(int64_t offset,
+                                   int len,
+                                   int64_t* start,
                                    const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 bool EntryImplV3::CouldBeSparse() const {
   return false;
 }
 
 void EntryImplV3::CancelSparseIO() {
   NOTIMPLEMENTED();
 }
 
 int EntryImplV3::ReadyForSparseIO(const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 EntryImplV3::~EntryImplV3() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace disk_cache