Switch to standard integer types in net/.

net/quic/quic_packet_creator.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/quic/quic_packet_creator.h"
 
 #include <algorithm>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::make_pair;
 using std::max;
 using std::min;
@@ skipping 14 matching lines @@
 // expect to be able to recover from any loss in about an RTT. We resolve this
 // tradeoff by sending an FEC packet atmost half an RTT, or equivalently, half
 // the max number of in-flight packets,  the first protected packet. Since we
 // don't want to delay an FEC packet past half an RTT, we set the max FEC group
 // size to be half the current congestion window.
 const float kMaxPacketsInFlightMultiplierForFecGroupSize = 0.5;
 const float kRttMultiplierForFecTimeout = 0.5;
 
 // Minimum timeout for FEC alarm, set to half the minimum Tail Loss Probe
 // timeout of 10ms.
-const int64 kMinFecTimeoutMs = 5u;
+const int64_t kMinFecTimeoutMs = 5u;
 
 }  // namespace
 
 // A QuicRandom wrapper that gets a bucket of entropy and distributes it
 // bit-by-bit. Replenishes the bucket as needed. Not thread-safe. Expose this
 // class if single bit randomness is needed elsewhere.
 class QuicRandomBoolSource {
  public:
   // random: Source of entropy. Not owned.
   explicit QuicRandomBoolSource(QuicRandom* random)
       : random_(random), bit_bucket_(0), bit_mask_(0) {}
 
   ~QuicRandomBoolSource() {}
 
   // Returns the next random bit from the bucket.
   bool RandBool() {
     if (bit_mask_ == 0) {
       bit_bucket_ = random_->RandUint64();
       bit_mask_ = 1;
     }
     bool result = ((bit_bucket_ & bit_mask_) != 0);
     bit_mask_ <<= 1;
     return result;
   }
 
  private:
   // Source of entropy.
   QuicRandom* random_;
   // Stored random bits.
-  uint64 bit_bucket_;
+  uint64_t bit_bucket_;
   // The next available bit has "1" in the mask. Zero means empty bucket.
-  uint64 bit_mask_;
+  uint64_t bit_mask_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicRandomBoolSource);
 };
 
 QuicPacketCreator::QuicPacketCreator(QuicConnectionId connection_id,
                                      QuicFramer* framer,
                                      QuicRandom* random_generator,
                                      DelegateInterface* delegate)
     : delegate_(delegate),
       debug_delegate_(nullptr),
@@ skipping 147 matching lines @@
 
 void QuicPacketCreator::UpdatePacketNumberLength(
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
   DCHECK_LE(least_packet_awaited_by_peer, packet_number_ + 1);
   // Since the packet creator will not change packet number length mid FEC
   // group, include the size of an FEC group to be safe.
   const QuicPacketNumber current_delta = max_packets_per_fec_group_ +
                                          packet_number_ + 1 -
                                          least_packet_awaited_by_peer;
-  const uint64 delta = max(current_delta, max_packets_in_flight);
+  const uint64_t delta = max(current_delta, max_packets_in_flight);
   next_packet_number_length_ =
       QuicFramer::GetMinSequenceNumberLength(delta * 4);
 }
 
 bool QuicPacketCreator::ConsumeData(QuicStreamId id,
                                     QuicIOVector iov,
                                     size_t iov_offset,
                                     QuicStreamOffset offset,
                                     bool fin,
                                     bool needs_padding,
@@ skipping 604 matching lines @@
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net