Remove kuint64max.

net/quic/congestion_control/send_algorithm_simulator.cc

 // Copyright 2014 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/quic/congestion_control/send_algorithm_simulator.h"
 
+#include <stdint.h>
+
 #include <limits>
 
 #include "base/logging.h"
 #include "base/rand_util.h"
 #include "net/quic/crypto/quic_random.h"
 
 using std::list;
 using std::max;
 using std::min;
 using std::string;
@@ skipping 45 matching lines @@
     QuicTime::Delta rtt)
     : clock_(clock),
       lose_next_ack_(false),
       forward_loss_rate_(0),
       reverse_loss_rate_(0),
       loss_correlation_(0),
       bandwidth_(bandwidth),
       rtt_(rtt),
       buffer_size_(1000000),
       delayed_ack_timer_(QuicTime::Delta::FromMilliseconds(100)) {
-  uint32 seed = base::RandInt(0, std::numeric_limits<int32>::max());
+  uint32_t seed = base::RandInt(0, std::numeric_limits<int32_t>::max());
   DVLOG(1) << "Seeding SendAlgorithmSimulator with " << seed;
   simple_random_.set_seed(seed);
 }
 
 SendAlgorithmSimulator::~SendAlgorithmSimulator() {}
 
 void SendAlgorithmSimulator::AddTransfer(Sender* sender, size_t num_bytes) {
   AddTransfer(sender, num_bytes, clock_->Now(),
               StringPrintf("#%zu", pending_transfers_.size()));
 }
 
 void SendAlgorithmSimulator::AddTransfer(
     Sender* sender, size_t num_bytes, QuicTime start_time, string name) {
   pending_transfers_.push_back(Transfer(sender, num_bytes, start_time, name));
   // Record initial stats from when the transfer begins.
   pending_transfers_.back().sender->RecordStats();
 }
 
 void SendAlgorithmSimulator::TransferBytes() {
-  TransferBytes(kuint64max, QuicTime::Delta::Infinite());
+  TransferBytes(std::numeric_limits<uint64_t>::max(),
+                QuicTime::Delta::Infinite());
 }
 
 void SendAlgorithmSimulator::TransferBytes(QuicByteCount max_bytes,
                                            QuicTime::Delta max_time) {
   const QuicTime end_time = max_time.IsInfinite() ?
       QuicTime::Zero().Add(QuicTime::Delta::Infinite()) :
       clock_->Now().Add(max_time);
   QuicByteCount bytes_sent = 0;
   while (!pending_transfers_.empty() &&
          clock_->Now() < end_time &&
@@ skipping 76 matching lines @@
     }
   }
 
   return PacketEvent(ack_time, transfer);
 }
 
 QuicTime::Delta SendAlgorithmSimulator::FindNextAcked(Transfer* transfer) {
   Sender* sender = transfer->sender;
   if (sender->next_acked == sender->last_acked) {
     // Determine if the next ack is lost only once, to ensure determinism.
-    lose_next_ack_ =
-        reverse_loss_rate_ * kuint64max > simple_random_.RandUint64();
+    lose_next_ack_ = reverse_loss_rate_ * std::numeric_limits<uint64_t>::max() >
+                     simple_random_.RandUint64();
   }
 
   QuicPacketNumber next_acked = sender->last_acked;
   QuicTime::Delta next_ack_delay =
       FindNextAck(transfer, sender->last_acked, &next_acked);
   if (lose_next_ack_) {
     next_ack_delay = FindNextAck(transfer, next_acked, &next_acked);
   }
   sender->next_acked = next_acked;
   return next_ack_delay;
@@ skipping 149 matching lines @@
            << " cwnd:" << sender->send_algorithm->GetCongestionWindow()
            << " Now():" << (clock_->Now().ToDebuggingValue() / 1000) << "ms";
   sender->send_algorithm->OnPacketSent(
       clock_->Now(), transfer->bytes_in_flight,
       sender->last_sent, kPacketSize, HAS_RETRANSMITTABLE_DATA);
   // Lose the packet immediately if the buffer is full.
   if (sent_packets_.size() * kPacketSize < buffer_size_) {
     // TODO(ianswett): This buffer simulation is an approximation.
     // An ack time of zero means loss.
     bool packet_lost =
-        forward_loss_rate_ * kuint64max > simple_random_.RandUint64();
+        forward_loss_rate_ * std::numeric_limits<uint64_t>::max() >
+        simple_random_.RandUint64();
     // Handle correlated loss.
     if (!sent_packets_.empty() && sent_packets_.back().lost &&
-        loss_correlation_ * kuint64max > simple_random_.RandUint64()) {
+        loss_correlation_ * std::numeric_limits<uint64_t>::max() >
+            simple_random_.RandUint64()) {
       packet_lost = true;
     }
     DVLOG(1) << "losing packet:" << sender->last_sent
              << " name:" << transfer->name << " due to random loss.";
 
     // If the number of bytes in flight are less than the bdp, there's
     // no buffering delay.  Bytes lost from the buffer are not counted.
     QuicByteCount bdp = bandwidth_.ToBytesPerPeriod(rtt_);
     QuicTime ack_time = clock_->Now().Add(rtt_).Add(sender->additional_rtt);
     if (kPacketSize > bdp) {
       ack_time = ack_time.Add(bandwidth_.TransferTime(kPacketSize - bdp));
     }
     QuicTime queue_ack_time = sent_packets_.empty() ? QuicTime::Zero() :
         sent_packets_.back().ack_time.Add(bandwidth_.TransferTime(kPacketSize));
     ack_time = QuicTime::Max(ack_time, queue_ack_time);
     sent_packets_.push_back(SentPacket(
         sender->last_sent, clock_->Now(), ack_time, packet_lost, transfer));
   } else {
     DVLOG(1) << "losing packet:" << sender->last_sent
              << " name:" << transfer->name << " because the buffer was full.";
   }
   transfer->bytes_in_flight += kPacketSize;
 }
 
 }  // namespace net