Remove kuint32max.

net/disk_cache/blockfile/backend_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/backend_impl.h"
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/hash.h"
 #include "base/location.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
@@ skipping 29 matching lines @@
 
 // Seems like ~240 MB correspond to less than 50k entries for 99% of the people.
 // Note that the actual target is to keep the index table load factor under 55%
 // for most users.
 const int k64kEntriesStore = 240 * 1000 * 1000;
 const int kBaseTableLen = 64 * 1024;
 
 // Avoid trimming the cache for the first 5 minutes (10 timer ticks).
 const int kTrimDelay = 10;
 
-int DesiredIndexTableLen(int32 storage_size) {
+int DesiredIndexTableLen(int32_t storage_size) {
   if (storage_size <= k64kEntriesStore)
     return kBaseTableLen;
   if (storage_size <= k64kEntriesStore * 2)
     return kBaseTableLen * 2;
   if (storage_size <= k64kEntriesStore * 4)
     return kBaseTableLen * 4;
   if (storage_size <= k64kEntriesStore * 8)
     return kBaseTableLen * 8;
 
-  // The biggest storage_size for int32 requires a 4 MB table.
+  // The biggest storage_size for int32_t requires a 4 MB table.
   return kBaseTableLen * 16;
 }
 
 int MaxStorageSizeForTable(int table_len) {
   return table_len * (k64kEntriesStore / kBaseTableLen);
 }
 
 size_t GetIndexSize(int table_len) {
   size_t table_size = sizeof(disk_cache::CacheAddr) * table_len;
   return sizeof(disk_cache::IndexHeader) + table_size;
@@ skipping 55 matching lines @@
       new_eviction_(false),
       first_timer_(true),
       user_load_(false),
       net_log_(net_log),
       done_(true, false),
       ptr_factory_(this) {
 }
 
 BackendImpl::BackendImpl(
     const base::FilePath& path,
-    uint32 mask,
+    uint32_t mask,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
     net::NetLog* net_log)
     : background_queue_(this, cache_thread),
       path_(path),
       block_files_(path),
       mask_(mask),
       max_size_(0),
       up_ticks_(0),
       cache_type_(net::DISK_CACHE),
       uma_report_(0),
       user_flags_(kMask),
       init_(false),
       restarted_(false),
       unit_test_(false),
       read_only_(false),
       disabled_(false),
       new_eviction_(false),
       first_timer_(true),
       user_load_(false),
       net_log_(net_log),
       done_(true, false),
-      ptr_factory_(this) {
-}
+      ptr_factory_(this) {}
 
 BackendImpl::~BackendImpl() {
   if (user_flags_ & kNoRandom) {
     // This is a unit test, so we want to be strict about not leaking entries
     // and completing all the work.
     background_queue_.WaitForPendingIO();
   } else {
     // This is most likely not a test, so we want to do as little work as
     // possible at this time, at the price of leaving dirty entries behind.
     background_queue_.DropPendingIO();
@@ skipping 275 matching lines @@
 }
 
 void BackendImpl::SyncEndEnumeration(scoped_ptr<Rankings::Iterator> iterator) {
   iterator->Reset();
 }
 
 void BackendImpl::SyncOnExternalCacheHit(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();
   }
 }
 
 EntryImpl* BackendImpl::OpenEntryImpl(const std::string& key) {
   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;
     web_fonts_histogram::RecordEvictedEntry(key);
   } else if (!cache_entry) {
     web_fonts_histogram::RecordCacheMiss(key);
   }
 
   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,
               static_cast<base::HistogramBase::Sample>(total_hours));
     CACHE_UMA(HOURS, "AllOpenByUseHours.Miss", 0,
               static_cast<base::HistogramBase::Sample>(use_hours));
     stats_.OnEvent(Stats::OPEN_MISS);
     return NULL;
@@ skipping 13 matching lines @@
   stats_.OnEvent(Stats::OPEN_HIT);
   web_fonts_histogram::RecordCacheHit(cache_entry);
   return cache_entry;
 }
 
 EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) {
   if (disabled_ || key.empty())
     return NULL;
 
   TimeTicks start = TimeTicks::Now();
-  uint32 hash = base::Hash(key);
+  uint32_t hash = base::Hash(key);
   Trace("Create hash 0x%x", hash);
 
   scoped_refptr<EntryImpl> parent;
   Addr entry_address(data_->table[hash & mask_]);
   if (entry_address.is_initialized()) {
     // We have an entry already. It could be the one we are looking for, or just
     // a hash conflict.
     bool error;
     EntryImpl* old_entry = MatchEntry(key, hash, false, Addr(), &error);
     if (old_entry)
@@ skipping 151 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_ |= kMaxSize;
   max_size_ = max_bytes;
   return true;
 }
 
 void BackendImpl::SetType(net::CacheType type) {
   DCHECK_NE(net::MEMORY_CACHE, type);
   cache_type_ = type;
 }
@@ skipping 73 matching lines @@
 }
 
 void BackendImpl::RecoveredEntry(CacheRankingsBlock* rankings) {
   Addr address(rankings->Data()->contents);
   EntryImpl* cache_entry = NULL;
   if (NewEntry(address, &cache_entry)) {
     STRESS_NOTREACHED();
     return;
   }
 
-  uint32 hash = cache_entry->GetHash();
+  uint32_t hash = cache_entry->GetHash();
   cache_entry->Release();
 
   // Anything on the table means that this entry is there.
   if (data_->table[hash & mask_])
     return;
 
   data_->table[hash & mask_] = address.value();
   FlushIndex();
 }
 
 void BackendImpl::InternalDoomEntry(EntryImpl* 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 26 matching lines @@
   DCHECK(block_files_.IsValid(address));
   DCHECK(!address.is_separate_file() && address.file_type() == BLOCK_256);
 
   CacheEntryBlock entry(File(address), address);
   CHECK(entry.Load());
   return entry.Data()->next;
 }
 
 void BackendImpl::NotLinked(EntryImpl* entry) {
   Addr entry_addr = entry->entry()->address();
-  uint32 i = entry->GetHash() & mask_;
+  uint32_t i = entry->GetHash() & mask_;
   Addr address(data_->table[i]);
   if (!address.is_initialized())
     return;
 
   for (;;) {
     DCHECK(entry_addr.value() != address.value());
     address.set_value(GetNextAddr(address));
     if (!address.is_initialized())
       break;
   }
@@ skipping 34 matching lines @@
   EntriesMap::const_iterator it =
       open_entries_.find(rankings->Data()->contents);
   if (it != open_entries_.end()) {
     // We have this entry in memory.
     return it->second;
   }
 
   return NULL;
 }
 
-int32 BackendImpl::GetCurrentEntryId() const {
+int32_t BackendImpl::GetCurrentEntryId() const {
   return data_->header.this_id;
 }
 
 int BackendImpl::MaxFileSize() const {
   return cache_type() == net::PNACL_CACHE ? max_size_ : max_size_ / 8;
 }
 
-void BackendImpl::ModifyStorageSize(int32 old_size, int32 new_size) {
+void BackendImpl::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);
 
   FlushIndex();
 
   // Update the usage statistics.
   stats_.ModifyStorageStats(old_size, new_size);
 }
 
-void BackendImpl::TooMuchStorageRequested(int32 size) {
+void BackendImpl::TooMuchStorageRequested(int32_t size) {
   stats_.ModifyStorageStats(0, size);
 }
 
 bool BackendImpl::IsAllocAllowed(int current_size, int new_size) {
   DCHECK_GT(new_size, current_size);
   if (user_flags_ & kNoBuffering)
     return false;
 
   int to_add = new_size - current_size;
   if (buffer_bytes_ + to_add > MaxBuffersSize())
@@ skipping 28 matching lines @@
   return ptr_factory_.GetWeakPtr();
 }
 
 // We want to remove biases from some histograms so we only send data once per
 // week.
 bool BackendImpl::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 BackendImpl::FirstEviction() {
   DCHECK(data_->header.create_time);
   if (!GetEntryCount())
     return;  // This is just for unit tests.
 
   Time create_time = Time::FromInternalValue(data_->header.create_time);
   CACHE_UMA(AGE, "FillupAge", 0, create_time);
 
-  int64 use_time = stats_.GetCounter(Stats::TIMER);
+  int64_t use_time = stats_.GetCounter(Stats::TIMER);
   CACHE_UMA(HOURS, "FillupTime", 0, static_cast<int>(use_time / 120));
   CACHE_UMA(PERCENTAGE, "FirstHitRatio", 0, stats_.GetHitRatio());
 
   if (!use_time)
     use_time = 1;
   CACHE_UMA(COUNTS_10000, "FirstEntryAccessRate", 0,
             static_cast<int>(data_->header.num_entries / use_time));
   CACHE_UMA(COUNTS, "FirstByteIORate", 0,
             static_cast<int>((data_->header.num_bytes / 1024) / use_time));
 
@@ skipping 43 matching lines @@
 
   // We transmit positive numbers, instead of direct error codes.
   DCHECK_LE(error, 0);
   CACHE_UMA(CACHE_ERROR, "Error", 0, error * -1);
 }
 
 void BackendImpl::OnEvent(Stats::Counters an_event) {
   stats_.OnEvent(an_event);
 }
 
-void BackendImpl::OnRead(int32 bytes) {
+void BackendImpl::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 BackendImpl::OnWrite(int32 bytes) {
+void BackendImpl::OnWrite(int32_t bytes) {
   // We use the same implementation as OnRead... just log the number of bytes.
   OnRead(bytes);
 }
 
 void BackendImpl::OnStatsTimer() {
   if (disabled_)
     return;
 
   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", 0, num_refs_);
 
   CACHE_UMA(COUNTS_10000, "EntryAccessRate", 0, entry_count_);
@@ skipping 34 matching lines @@
 void BackendImpl::SetUpgradeMode() {
   user_flags_ |= kUpgradeMode;
   read_only_ = true;
 }
 
 void BackendImpl::SetNewEviction() {
   user_flags_ |= kNewEviction;
   new_eviction_ = true;
 }
 
-void BackendImpl::SetFlags(uint32 flags) {
+void BackendImpl::SetFlags(uint32_t flags) {
   user_flags_ |= flags;
 }
 
 void BackendImpl::ClearRefCountForTest() {
   num_refs_ = 0;
 }
 
 int BackendImpl::FlushQueueForTest(const CompletionCallback& callback) {
   background_queue_.FlushQueue(callback);
   return net::ERR_IO_PENDING;
@@ skipping 47 matching lines @@
   if (index_.get() && !disabled_)
     index_->Flush();
 }
 
 // ------------------------------------------------------------------------
 
 net::CacheType BackendImpl::GetCacheType() const {
   return cache_type_;
 }
 
-int32 BackendImpl::GetEntryCount() const {
+int32_t BackendImpl::GetEntryCount() const {
   if (!index_.get() || disabled_)
     return 0;
   // num_entries includes entries already evicted.
-  int32 not_deleted = data_->header.num_entries -
-                      data_->header.lru.sizes[Rankings::DELETED];
+  int32_t not_deleted =
+      data_->header.num_entries - data_->header.lru.sizes[Rankings::DELETED];
 
   if (not_deleted < 0) {
     NOTREACHED();
     not_deleted = 0;
   }
 
   return not_deleted;
 }
 
 int BackendImpl::OpenEntry(const std::string& key, Entry** entry,
@@ skipping 171 matching lines @@
 // The maximum cache size will be either set explicitly by the caller, or
 // calculated by this code.
 void BackendImpl::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_ = PreferredCacheSize(available);
 
@@ skipping 58 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 BackendImpl::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 98 matching lines @@
           address.value());
   }
 
   open_entries_[address.value()] = cache_entry.get();
 
   cache_entry->BeginLogging(net_log_, false);
   cache_entry.swap(entry);
   return 0;
 }
 
-EntryImpl* BackendImpl::MatchEntry(const std::string& key, uint32 hash,
-                                   bool find_parent, Addr entry_addr,
+EntryImpl* BackendImpl::MatchEntry(const std::string& key,
+                                   uint32_t hash,
+                                   bool find_parent,
+                                   Addr entry_addr,
                                    bool* match_error) {
   Addr address(data_->table[hash & mask_]);
   scoped_refptr<EntryImpl> cache_entry, parent_entry;
   EntryImpl* tmp = NULL;
   bool found = false;
   std::set<CacheAddr> visited;
   *match_error = false;
 
   for (;;) {
     if (disabled_)
@@ skipping 183 matching lines @@
   entry->SetPointerForInvalidEntry(GetCurrentEntryId());
 
   eviction_.OnDoomEntry(entry);
   entry->InternalDoom();
 
   if (!new_eviction_)
     DecreaseNumEntries();
   stats_.OnEvent(Stats::INVALID_ENTRY);
 }
 
-void BackendImpl::AddStorageSize(int32 bytes) {
+void BackendImpl::AddStorageSize(int32_t bytes) {
   data_->header.num_bytes += bytes;
   DCHECK_GE(data_->header.num_bytes, 0);
 }
 
-void BackendImpl::SubstractStorageSize(int32 bytes) {
+void BackendImpl::SubstractStorageSize(int32_t bytes) {
   data_->header.num_bytes -= bytes;
   DCHECK_GE(data_->header.num_bytes, 0);
 }
 
 void BackendImpl::IncreaseNumRefs() {
   num_refs_++;
   if (max_refs_ < num_refs_)
     max_refs_ = num_refs_;
 }
 
@@ skipping 59 matching lines @@
             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);
 
   int age = (Time::Now() -
              Time::FromInternalValue(data_->header.create_time)).InHours();
   if (age)
     CACHE_UMA(HOURS, "FilesAge", 0, age);
 
-  int64 total_hours = stats_.GetCounter(Stats::TIMER) / 120;
+  int64_t total_hours = stats_.GetCounter(Stats::TIMER) / 120;
   if (!data_->header.create_time || !data_->header.lru.filled) {
     int cause = data_->header.create_time ? 0 : 1;
     if (!data_->header.lru.filled)
       cause |= 2;
     CACHE_UMA(CACHE_ERROR, "ShortReport", 0, cause);
     CACHE_UMA(HOURS, "TotalTimeNotFull", 0, 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", 0, static_cast<int>(total_hours));
   // For any bin in HitRatioByTotalTime, the hit ratio of caches of that total
   // time is the ratio of that bin's total count to the count in the same bin in
   // the TotalTime histogram.
   if (base::RandInt(0, 99) < hit_ratio_as_percentage)
     CACHE_UMA(HOURS, "HitRatioByTotalTime", 0, 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() || !data_->header.num_bytes)
     return;
 
   CACHE_UMA(HOURS, "UseTime", 0, static_cast<int>(use_hours));
   // For any bin in HitRatioByUseTime, the hit ratio of caches of that use time
   // is the ratio of that bin's total count to the count in the same bin in the
   // UseTime histogram.
   if (base::RandInt(0, 99) < hit_ratio_as_percentage)
     CACHE_UMA(HOURS, "HitRatioByUseTime", 0, static_cast<int>(use_hours));
   CACHE_UMA(PERCENTAGE, "HitRatio", 0, hit_ratio_as_percentage);
 
-  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", 0, static_cast<int>(trim_rate));
 
   int avg_size = data_->header.num_bytes / GetEntryCount();
   CACHE_UMA(COUNTS, "EntrySize", 0, avg_size);
   CACHE_UMA(COUNTS, "EntriesFull", 0, data_->header.num_entries);
 
   CACHE_UMA(PERCENTAGE, "IndexLoad", 0,
             data_->header.num_entries * 100 / (mask_ + 1));
 
   int large_entries_bytes = stats_.GetLargeEntriesSize();
@@ skipping 63 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.
   return index_->Preload();
 }
 
 int BackendImpl::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 BackendImpl::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);
 }
 
 }  // namespace disk_cache