Remove kint64max.

net/base/backoff_entry.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/base/backoff_entry.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/rand_util.h"
 #include "base/time/tick_clock.h"
 
 namespace net {
 
 BackoffEntry::BackoffEntry(const BackoffEntry::Policy* policy)
     : BackoffEntry(policy, nullptr) {}
 
@@ skipping 116 matching lines @@
   // accounted for. Both cases are handled by using CheckedNumeric<int64_t> to
   // perform the conversion to integers.
   double delay_ms = policy_->initial_delay_ms;
   delay_ms *= pow(policy_->multiply_factor, effective_failure_count - 1);
   delay_ms -= base::RandDouble() * policy_->jitter_factor * delay_ms;
 
   // Do overflow checking in microseconds, the internal unit of TimeTicks.
   base::internal::CheckedNumeric<int64_t> backoff_duration_us = delay_ms + 0.5;
   backoff_duration_us *= base::Time::kMicrosecondsPerMillisecond;
   base::TimeDelta backoff_duration = base::TimeDelta::FromMicroseconds(
-      backoff_duration_us.ValueOrDefault(kint64max));
+      backoff_duration_us.ValueOrDefault(std::numeric_limits<int64_t>::max()));
   base::TimeTicks release_time = BackoffDurationToReleaseTime(backoff_duration);
 
   // Never reduce previously set release horizon, e.g. due to Retry-After
   // header.
   return std::max(release_time, exponential_backoff_release_time_);
 }
 
 base::TimeTicks BackoffEntry::BackoffDurationToReleaseTime(
     base::TimeDelta backoff_duration) const {
   const int64_t kTimeTicksNowUs =
       (GetTimeTicksNow() - base::TimeTicks()).InMicroseconds();
   // Do overflow checking in microseconds, the internal unit of TimeTicks.
   base::internal::CheckedNumeric<int64_t> calculated_release_time_us =
       backoff_duration.InMicroseconds();
   calculated_release_time_us += kTimeTicksNowUs;
 
-  base::internal::CheckedNumeric<int64_t> maximum_release_time_us = kint64max;
+  base::internal::CheckedNumeric<int64_t> maximum_release_time_us =
+      std::numeric_limits<int64_t>::max();
   if (policy_->maximum_backoff_ms >= 0) {
     maximum_release_time_us = policy_->maximum_backoff_ms;
     maximum_release_time_us *= base::Time::kMicrosecondsPerMillisecond;
     maximum_release_time_us += kTimeTicksNowUs;
   }
 
   // Decide between maximum release time and calculated release time, accounting
   // for overflow with both.
-  int64_t release_time_us =
-      std::min(calculated_release_time_us.ValueOrDefault(kint64max),
-               maximum_release_time_us.ValueOrDefault(kint64max));
+  int64_t release_time_us = std::min(calculated_release_time_us.ValueOrDefault(
+                                         std::numeric_limits<int64_t>::max()),
+                                     maximum_release_time_us.ValueOrDefault(
+                                         std::numeric_limits<int64_t>::max()));
 
   return base::TimeTicks() + base::TimeDelta::FromMicroseconds(release_time_us);
 }
 
 base::TimeTicks BackoffEntry::GetTimeTicksNow() const {
   return clock_ ? clock_->NowTicks() : base::TimeTicks::Now();
 }
 
 }  // namespace net