Remove kuint32max.

net/disk_cache/blockfile/backend_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/backend_impl_v3.h"
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/hash.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 76 matching lines @@
   static_assert(sizeof(max_bytes) == sizeof(max_size_),
                 "unsupported int model");
   if (max_bytes < 0)
     return false;
 
   // Zero size means use the default.
   if (!max_bytes)
     return true;
 
   // Avoid a DCHECK later on.
-  if (max_bytes >= kint32max - kint32max / 10)
-    max_bytes = kint32max - kint32max / 10 - 1;
+  if (max_bytes >= std::numeric_limits<int32_t>::max() -
+                       std::numeric_limits<int32_t>::max() / 10) {
+    max_bytes = std::numeric_limits<int32_t>::max() -
+                std::numeric_limits<int32_t>::max() / 10 - 1;
+  }
 
   user_flags_ |= MAX_SIZE;
   max_size_ = max_bytes;
   return true;
 }
 
 void BackendImplV3::SetType(net::CacheType type) {
   DCHECK_NE(net::MEMORY_CACHE, type);
   cache_type_ = type;
 }
 
 bool BackendImplV3::CreateBlock(FileType block_type, int block_count,
                                 Addr* block_address) {
   return block_files_.CreateBlock(block_type, block_count, block_address);
 }
 
 #if defined(V3_NOT_JUST_YET_READY)
 void BackendImplV3::UpdateRank(EntryImplV3* entry, bool modified) {
   if (read_only_ || (!modified && cache_type() == net::SHADER_CACHE))
     return;
   eviction_.UpdateRank(entry, modified);
 }
 
 void BackendImplV3::InternalDoomEntry(EntryImplV3* entry) {
-  uint32 hash = entry->GetHash();
+  uint32_t hash = entry->GetHash();
   std::string key = entry->GetKey();
   Addr entry_addr = entry->entry()->address();
   bool error;
   EntryImpl* parent_entry = MatchEntry(key, hash, true, entry_addr, &error);
   CacheAddr child(entry->GetNextAddress());
 
   Trace("Doom entry 0x%p", entry);
 
   if (!entry->doomed()) {
     // We may have doomed this entry from within MatchEntry.
@@ skipping 37 matching lines @@
     return it->second;
   }
 
   return NULL;
 }
 
 int BackendImplV3::MaxFileSize() const {
   return max_size_ / 8;
 }
 
-void BackendImplV3::ModifyStorageSize(int32 old_size, int32 new_size) {
+void BackendImplV3::ModifyStorageSize(int32_t old_size, int32_t new_size) {
   if (disabled_ || old_size == new_size)
     return;
   if (old_size > new_size)
     SubstractStorageSize(old_size - new_size);
   else
     AddStorageSize(new_size - old_size);
 
   // Update the usage statistics.
   stats_.ModifyStorageStats(old_size, new_size);
 }
 
-void BackendImplV3::TooMuchStorageRequested(int32 size) {
+void BackendImplV3::TooMuchStorageRequested(int32_t size) {
   stats_.ModifyStorageStats(0, size);
 }
 
 bool BackendImplV3::IsAllocAllowed(int current_size, int new_size) {
   DCHECK_GT(new_size, current_size);
   if (user_flags_ & NO_BUFFERING)
     return false;
 
   int to_add = new_size - current_size;
   if (buffer_bytes_ + to_add > MaxBuffersSize())
@@ skipping 30 matching lines @@
 }
 
 #if defined(V3_NOT_JUST_YET_READY)
 // We want to remove biases from some histograms so we only send data once per
 // week.
 bool BackendImplV3::ShouldReportAgain() {
   if (uma_report_)
     return uma_report_ == 2;
 
   uma_report_++;
-  int64 last_report = stats_.GetCounter(Stats::LAST_REPORT);
+  int64_t last_report = stats_.GetCounter(Stats::LAST_REPORT);
   Time last_time = Time::FromInternalValue(last_report);
   if (!last_report || (Time::Now() - last_time).InDays() >= 7) {
     stats_.SetCounter(Stats::LAST_REPORT, Time::Now().ToInternalValue());
     uma_report_++;
     return true;
   }
   return false;
 }
 
 void BackendImplV3::FirstEviction() {
   IndexHeaderV3* header = index_.header();
   header->flags |= CACHE_EVICTED;
   DCHECK(header->create_time);
   if (!GetEntryCount())
     return;  // This is just for unit tests.
 
   Time create_time = Time::FromInternalValue(header->create_time);
   CACHE_UMA(AGE, "FillupAge", create_time);
 
-  int64 use_time = stats_.GetCounter(Stats::TIMER);
+  int64_t use_time = stats_.GetCounter(Stats::TIMER);
   CACHE_UMA(HOURS, "FillupTime", static_cast<int>(use_time / 120));
   CACHE_UMA(PERCENTAGE, "FirstHitRatio", stats_.GetHitRatio());
 
   if (!use_time)
     use_time = 1;
   CACHE_UMA(COUNTS_10000, "FirstEntryAccessRate",
             static_cast<int>(header->num_entries / use_time));
   CACHE_UMA(COUNTS, "FirstByteIORate",
             static_cast<int>((header->num_bytes / 1024) / use_time));
 
@@ skipping 14 matching lines @@
               header->num_high_use_entries * 100 / header->num_entries);
   }
 
   stats_.ResetRatios();
 }
 
 void BackendImplV3::OnEvent(Stats::Counters an_event) {
   stats_.OnEvent(an_event);
 }
 
-void BackendImplV3::OnRead(int32 bytes) {
+void BackendImplV3::OnRead(int32_t bytes) {
   DCHECK_GE(bytes, 0);
   byte_count_ += bytes;
   if (byte_count_ < 0)
-    byte_count_ = kint32max;
+    byte_count_ = std::numeric_limits<int32_t>::max();
 }
 
-void BackendImplV3::OnWrite(int32 bytes) {
+void BackendImplV3::OnWrite(int32_t bytes) {
   // We use the same implementation as OnRead... just log the number of bytes.
   OnRead(bytes);
 }
 
 void BackendImplV3::OnTimerTick() {
   stats_.OnEvent(Stats::TIMER);
-  int64 time = stats_.GetCounter(Stats::TIMER);
-  int64 current = stats_.GetCounter(Stats::OPEN_ENTRIES);
+  int64_t time = stats_.GetCounter(Stats::TIMER);
+  int64_t current = stats_.GetCounter(Stats::OPEN_ENTRIES);
 
   // OPEN_ENTRIES is a sampled average of the number of open entries, avoiding
   // the bias towards 0.
   if (num_refs_ && (current != num_refs_)) {
-    int64 diff = (num_refs_ - current) / 50;
+    int64_t diff = (num_refs_ - current) / 50;
     if (!diff)
       diff = num_refs_ > current ? 1 : -1;
     current = current + diff;
     stats_.SetCounter(Stats::OPEN_ENTRIES, current);
     stats_.SetCounter(Stats::MAX_ENTRIES, max_refs_);
   }
 
   CACHE_UMA(COUNTS, "NumberOfReferences", num_refs_);
 
   CACHE_UMA(COUNTS_10000, "EntryAccessRate", entry_count_);
@@ skipping 25 matching lines @@
 void BackendImplV3::SetUpgradeMode() {
   user_flags_ |= UPGRADE_MODE;
   read_only_ = true;
 }
 
 void BackendImplV3::SetNewEviction() {
   user_flags_ |= EVICTION_V2;
   lru_eviction_ = false;
 }
 
-void BackendImplV3::SetFlags(uint32 flags) {
+void BackendImplV3::SetFlags(uint32_t flags) {
   user_flags_ |= flags;
 }
 
 int BackendImplV3::FlushQueueForTest(const CompletionCallback& callback) {
   background_queue_.FlushQueue(callback);
   return net::ERR_IO_PENDING;
 }
 
 void BackendImplV3::TrimForTest(bool empty) {
   eviction_.SetTestMode();
@@ skipping 28 matching lines @@
 
   return CheckAllEntries();
 }
 
 // ------------------------------------------------------------------------
 
 net::CacheType BackendImplV3::GetCacheType() const {
   return cache_type_;
 }
 
-int32 BackendImplV3::GetEntryCount() const {
+int32_t BackendImplV3::GetEntryCount() const {
   if (disabled_)
     return 0;
   DCHECK(init_);
   return index_.header()->num_entries;
 }
 
 int BackendImplV3::OpenEntry(const std::string& key, Entry** entry,
                              const CompletionCallback& callback) {
   if (disabled_)
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
-  uint32 hash = base::Hash(key);
+  uint32_t hash = base::Hash(key);
   Trace("Open hash 0x%x", hash);
 
   bool error;
   EntryImpl* cache_entry = MatchEntry(key, hash, false, Addr(), &error);
   if (cache_entry && ENTRY_NORMAL != cache_entry->entry()->Data()->state) {
     // The entry was already evicted.
     cache_entry->Release();
     cache_entry = NULL;
   }
 
   int current_size = data_->header.num_bytes / (1024 * 1024);
-  int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
-  int64 no_use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
-  int64 use_hours = total_hours - no_use_hours;
+  int64_t total_hours = stats_.GetCounter(Stats::TIMER) / 120;
+  int64_t no_use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
+  int64_t use_hours = total_hours - no_use_hours;
 
   if (!cache_entry) {
     CACHE_UMA(AGE_MS, "OpenTime.Miss", 0, start);
     CACHE_UMA(COUNTS_10000, "AllOpenBySize.Miss", 0, current_size);
     CACHE_UMA(HOURS, "AllOpenByTotalHours.Miss", 0, total_hours);
     CACHE_UMA(HOURS, "AllOpenByUseHours.Miss", 0, use_hours);
     stats_.OnEvent(Stats::OPEN_MISS);
     return NULL;
   }
 
@@ skipping 252 matching lines @@
   item.second = "Blockfile Cache";
   stats->push_back(item);
 
   stats_.GetItems(stats);
 }
 
 void BackendImplV3::OnExternalCacheHit(const std::string& key) {
   if (disabled_)
     return;
 
-  uint32 hash = base::Hash(key);
+  uint32_t hash = base::Hash(key);
   bool error;
   EntryImpl* cache_entry = MatchEntry(key, hash, false, Addr(), &error);
   if (cache_entry) {
     if (ENTRY_NORMAL == cache_entry->entry()->Data()->state) {
       UpdateRank(cache_entry, cache_type() == net::SHADER_CACHE);
     }
     cache_entry->Release();
   }
 }
 
 // ------------------------------------------------------------------------
 
 // The maximum cache size will be either set explicitly by the caller, or
 // calculated by this code.
 void BackendImplV3::AdjustMaxCacheSize(int table_len) {
   if (max_size_)
     return;
 
   // If table_len is provided, the index file exists.
   DCHECK(!table_len || data_->header.magic);
 
   // The user is not setting the size, let's figure it out.
-  int64 available = base::SysInfo::AmountOfFreeDiskSpace(path_);
+  int64_t available = base::SysInfo::AmountOfFreeDiskSpace(path_);
   if (available < 0) {
     max_size_ = kDefaultCacheSize;
     return;
   }
 
   if (table_len)
     available += data_->header.num_bytes;
 
   max_size_ = PreferedCacheSize(available);
 
@@ skipping 61 matching lines @@
   MappedFile* file = File(address);
   if (!file)
     return;
 
   size_t offset = address.start_block() * address.BlockSize() +
                   kBlockHeaderSize;
   file->Write(data.get(), size, offset);  // ignore result.
 }
 
 void BackendImplV3::RestartCache(bool failure) {
-  int64 errors = stats_.GetCounter(Stats::FATAL_ERROR);
-  int64 full_dooms = stats_.GetCounter(Stats::DOOM_CACHE);
-  int64 partial_dooms = stats_.GetCounter(Stats::DOOM_RECENT);
-  int64 last_report = stats_.GetCounter(Stats::LAST_REPORT);
+  int64_t errors = stats_.GetCounter(Stats::FATAL_ERROR);
+  int64_t full_dooms = stats_.GetCounter(Stats::DOOM_CACHE);
+  int64_t partial_dooms = stats_.GetCounter(Stats::DOOM_RECENT);
+  int64_t last_report = stats_.GetCounter(Stats::LAST_REPORT);
 
   PrepareForRestart();
   if (failure) {
     DCHECK(!num_refs_);
     DCHECK(!open_entries_.size());
     DelayedCacheCleanup(path_);
   } else {
     DeleteCache(path_, false);
   }
 
@@ skipping 119 matching lines @@
           address.value());
   }
 
   open_entries_[address.value()] = cache_entry.get();
 
   cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
   return 0;
 }
 
-void BackendImplV3::AddStorageSize(int32 bytes) {
+void BackendImplV3::AddStorageSize(int32_t bytes) {
   data_->header.num_bytes += bytes;
   DCHECK_GE(data_->header.num_bytes, 0);
 }
 
-void BackendImplV3::SubstractStorageSize(int32 bytes) {
+void BackendImplV3::SubstractStorageSize(int32_t bytes) {
   data_->header.num_bytes -= bytes;
   DCHECK_GE(data_->header.num_bytes, 0);
 }
 
 void BackendImplV3::IncreaseNumRefs() {
   num_refs_++;
   if (max_refs_ < num_refs_)
     max_refs_ = num_refs_;
 }
 
@@ skipping 271 matching lines @@
   CACHE_UMA(COUNTS_10000, "TotalFatalErrors",
             static_cast<int>(stats_.GetCounter(Stats::FATAL_ERROR)));
   CACHE_UMA(COUNTS_10000, "TotalDoomCache",
             static_cast<int>(stats_.GetCounter(Stats::DOOM_CACHE)));
   CACHE_UMA(COUNTS_10000, "TotalDoomRecentEntries",
             static_cast<int>(stats_.GetCounter(Stats::DOOM_RECENT)));
   stats_.SetCounter(Stats::FATAL_ERROR, 0);
   stats_.SetCounter(Stats::DOOM_CACHE, 0);
   stats_.SetCounter(Stats::DOOM_RECENT, 0);
 
-  int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
+  int64_t total_hours = stats_.GetCounter(Stats::TIMER) / 120;
   if (!(header->flags & CACHE_EVICTED)) {
     CACHE_UMA(HOURS, "TotalTimeNotFull", static_cast<int>(total_hours));
     return;
   }
 
   // This is an up to date client that will report FirstEviction() data. After
   // that event, start reporting this:
 
   CACHE_UMA(HOURS, "TotalTime", static_cast<int>(total_hours));
 
-  int64 use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
+  int64_t use_hours = stats_.GetCounter(Stats::LAST_REPORT_TIMER) / 120;
   stats_.SetCounter(Stats::LAST_REPORT_TIMER, stats_.GetCounter(Stats::TIMER));
 
   // We may see users with no use_hours at this point if this is the first time
   // we are running this code.
   if (use_hours)
     use_hours = total_hours - use_hours;
 
   if (!use_hours || !GetEntryCount() || !header->num_bytes)
     return;
 
   CACHE_UMA(HOURS, "UseTime", static_cast<int>(use_hours));
 
-  int64 trim_rate = stats_.GetCounter(Stats::TRIM_ENTRY) / use_hours;
+  int64_t trim_rate = stats_.GetCounter(Stats::TRIM_ENTRY) / use_hours;
   CACHE_UMA(COUNTS, "TrimRate", static_cast<int>(trim_rate));
 
   int avg_size = header->num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "EntrySize", avg_size);
   CACHE_UMA(COUNTS, "EntriesFull", header->num_entries);
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
   int large_ratio = large_entries_bytes * 100 / header->num_bytes;
   CACHE_UMA(PERCENTAGE, "LargeEntriesRatio", large_ratio);
 
@@ skipping 61 matching lines @@
   if (current_size < GetIndexSize(data_->header.table_len) ||
       data_->header.table_len & (kBaseTableLen - 1)) {
     LOG(ERROR) << "Corrupt Index file";
     return false;
   }
 
   AdjustMaxCacheSize(data_->header.table_len);
 
 #if !defined(NET_BUILD_STRESS_CACHE)
   if (data_->header.num_bytes < 0 ||
-      (max_size_ < kint32max - kDefaultCacheSize &&
+      (max_size_ < std::numeric_limits<int32_t>::max() - kDefaultCacheSize &&
        data_->header.num_bytes > max_size_ + kDefaultCacheSize)) {
     LOG(ERROR) << "Invalid cache (current) size";
     return false;
   }
 #endif
 
   if (data_->header.num_entries < 0) {
     LOG(ERROR) << "Invalid number of entries";
     return false;
   }
 
   if (!mask_)
     mask_ = data_->header.table_len - 1;
 
   // Load the table into memory with a single read.
   scoped_ptr<char[]> buf(new char[current_size]);
   return index_->Read(buf.get(), current_size, 0);
 }
 
 int BackendImplV3::CheckAllEntries() {
   int num_dirty = 0;
   int num_entries = 0;
-  DCHECK(mask_ < kuint32max);
+  DCHECK(mask_ < std::numeric_limits<uint32_t>::max());
   for (unsigned int i = 0; i <= mask_; i++) {
     Addr address(data_->table[i]);
     if (!address.is_initialized())
       continue;
     for (;;) {
       EntryImpl* tmp;
       int ret = NewEntry(address, &tmp);
       if (ret) {
         STRESS_NOTREACHED();
         return ret;
@@ skipping 35 matching lines @@
       Addr address(data->data_addr[i]);
       if (address.is_block_file())
         ok = ok && block_files_.IsValid(address);
     }
   }
 
   return ok && cache_entry->rankings()->VerifyHash();
 }
 
 int BackendImplV3::MaxBuffersSize() {
-  static int64 total_memory = base::SysInfo::AmountOfPhysicalMemory();
+  static int64_t total_memory = base::SysInfo::AmountOfPhysicalMemory();
   static bool done = false;
 
   if (!done) {
     const int kMaxBuffersSize = 30 * 1024 * 1024;
 
     // We want to use up to 2% of the computer's memory.
     total_memory = total_memory * 2 / 100;
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 #endif  // defined(V3_NOT_JUST_YET_READY).
 
 bool BackendImplV3::IsAllocAllowed(int current_size, int new_size) {
   return false;
 }
 
 net::CacheType BackendImplV3::GetCacheType() const {
   return cache_type_;
 }
 
-int32 BackendImplV3::GetEntryCount() const {
+int32_t BackendImplV3::GetEntryCount() const {
   return 0;
 }
 
 int BackendImplV3::OpenEntry(const std::string& key, Entry** entry,
                              const CompletionCallback& callback) {
   return net::ERR_FAILED;
 }
 
 int BackendImplV3::CreateEntry(const std::string& key, Entry** entry,
                                const CompletionCallback& callback) {
@@ skipping 42 matching lines @@
 }
 
 void BackendImplV3::OnExternalCacheHit(const std::string& key) {
   NOTIMPLEMENTED();
 }
 
 void BackendImplV3::CleanupCache() {
 }
 
 }  // namespace disk_cache