Remove kint32max.

net/disk_cache/blockfile/eviction.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.
 
 // The eviction policy is a very simple pure LRU, so the elements at the end of
 // the list are evicted until kCleanUpMargin free space is available. There is
 // only one list in use (Rankings::NO_USE), and elements are sent to the front
 // of the list whenever they are accessed.
 
 // The new (in-development) eviction policy adds re-use as a factor to evict
@@ skipping 10 matching lines @@
 // When we have to evict an element, first we try to use the last element from
 // the NO_USE list, then we move to the LOW_USE and only then we evict an entry
 // from the HIGH_USE. We attempt to keep entries on the cache for at least
 // kTargetTime hours (with frequently accessed items stored for longer periods),
 // but if we cannot do that, we fall-back to keep each list roughly the same
 // size so that we have a chance to see an element again and move it to another
 // list.
 
 #include "net/disk_cache/blockfile/eviction.h"
 
+#include <stdint.h>
+
+#include <limits>
+
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/disk_format.h"
@@ skipping 360 matching lines @@
 }
 
 void Eviction::UpdateRankV2(EntryImpl* entry, bool modified) {
   rankings_->UpdateRank(entry->rankings(), modified, GetListForEntryV2(entry));
 }
 
 void Eviction::OnOpenEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
   DCHECK_EQ(ENTRY_NORMAL, info->state);
 
-  if (info->reuse_count < kint32max) {
+  if (info->reuse_count < std::numeric_limits<int32_t>::max()) {
     info->reuse_count++;
     entry->entry()->set_modified();
 
     // We may need to move this to a new list.
     if (1 == info->reuse_count) {
       rankings_->Remove(entry->rankings(), Rankings::NO_USE, true);
       rankings_->Insert(entry->rankings(), false, Rankings::LOW_USE);
       entry->entry()->Store();
     } else if (kHighUse == info->reuse_count) {
       rankings_->Remove(entry->rankings(), Rankings::LOW_USE, true);
       rankings_->Insert(entry->rankings(), false, Rankings::HIGH_USE);
       entry->entry()->Store();
     }
   }
 }
 
 void Eviction::OnCreateEntryV2(EntryImpl* entry) {
   EntryStore* info = entry->entry()->Data();
   switch (info->state) {
     case ENTRY_NORMAL: {
       DCHECK(!info->reuse_count);
       DCHECK(!info->refetch_count);
       break;
     };
     case ENTRY_EVICTED: {
-      if (info->refetch_count < kint32max)
+      if (info->refetch_count < std::numeric_limits<int32_t>::max())
         info->refetch_count++;
 
       if (info->refetch_count > kHighUse && info->reuse_count < kHighUse) {
         info->reuse_count = kHighUse;
       } else {
         info->reuse_count++;
       }
       info->state = ENTRY_NORMAL;
       entry->entry()->Store();
       rankings_->Remove(entry->rankings(), Rankings::DELETED, true);
@@ skipping 146 matching lines @@
               Time::FromInternalValue(last2.get()->Data()->last_used));
   if (last3.get())
     CACHE_UMA(AGE, "HighUseAge", 0,
               Time::FromInternalValue(last3.get()->Data()->last_used));
   if (last4.get())
     CACHE_UMA(AGE, "DeletedAge", 0,
               Time::FromInternalValue(last4.get()->Data()->last_used));
 }
 
 }  // namespace disk_cache