Switch to standard integer types in net/.

net/quic/quic_received_packet_manager.cc

 // Copyright 2013 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/quic_received_packet_manager.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 145 matching lines @@
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing " << packet_number << " from missing list";
     ack_frame_.missing_packets.Remove(packet_number);
 
     // Record how out of order stats.
     ++stats_->packets_reordered;
     stats_->max_sequence_reordering =
         max(stats_->max_sequence_reordering,
             ack_frame_.largest_observed - packet_number);
-    int64 reordering_time_us =
+    int64_t reordering_time_us =
         receipt_time.Subtract(time_largest_observed_).ToMicroseconds();
     stats_->max_time_reordering_us =
         max(stats_->max_time_reordering_us, reordering_time_us);
   }
   if (packet_number > ack_frame_.largest_observed) {
     ack_frame_.largest_observed = packet_number;
     time_largest_observed_ = receipt_time;
   }
   entropy_tracker_.RecordPacketEntropyHash(packet_number, header.entropy_hash);
 
@@ skipping 22 matching lines @@
 }
 
 namespace {
 struct isTooLarge {
   explicit isTooLarge(QuicPacketNumber n) : largest_observed_(n) {}
   QuicPacketNumber largest_observed_;
 
   // Return true if the packet in p is too different from largest_observed_
   // to express.
   bool operator()(const std::pair<QuicPacketNumber, QuicTime>& p) const {
-    return largest_observed_ - p.first >= numeric_limits<uint8>::max();
+    return largest_observed_ - p.first >= numeric_limits<uint8_t>::max();
   }
 };
 }  // namespace
 
 void QuicReceivedPacketManager::UpdateReceivedPacketInfo(
     QuicAckFrame* ack_frame,
     QuicTime approximate_now) {
   ack_frame_updated_ = false;
   *ack_frame = ack_frame_;
   ack_frame->entropy_hash = EntropyHash(ack_frame_.largest_observed);
 
   if (time_largest_observed_ == QuicTime::Zero()) {
     // We have received no packets.
     ack_frame->delta_time_largest_observed = QuicTime::Delta::Infinite();
     return;
   }
 
   // Ensure the delta is zero if approximate now is "in the past".
   ack_frame->delta_time_largest_observed =
       approximate_now < time_largest_observed_
           ? QuicTime::Delta::Zero()
           : approximate_now.Subtract(time_largest_observed_);
 
   // Clear all packet times if any are too far from largest observed.
   // It's expected this is extremely rare.
   for (PacketTimeVector::iterator it = ack_frame_.received_packet_times.begin();
        it != ack_frame_.received_packet_times.end();) {
     if (ack_frame_.largest_observed - it->first >=
-        numeric_limits<uint8>::max()) {
+        numeric_limits<uint8_t>::max()) {
       it = ack_frame_.received_packet_times.erase(it);
     } else {
       ++it;
     }
   }
 
   // TODO(ianswett): Instead of transferring all the information over,
   // consider giving the QuicPacketGenerator a reference to this ack frame
   // and clear it afterwards.
   ack_frame->received_packet_times.clear();
@@ skipping 39 matching lines @@
   return !ack_frame_.missing_packets.Empty() &&
          (ack_frame_.largest_observed - ack_frame_.missing_packets.Max()) <=
              kMaxPacketsAfterNewMissing;
 }
 
 size_t QuicReceivedPacketManager::NumTrackedPackets() const {
   return entropy_tracker_.size();
 }
 
 }  // namespace net