Switch to standard integer types in net/.

net/quic/congestion_control/tcp_cubic_bytes_sender_test.cc

 // Copyright (c) 2015 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/tcp_cubic_bytes_sender.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
 // TODO(ianswett): A number of theses tests were written with the assumption of
 // an initial CWND of 10. They have carefully calculated values which should be
 // updated to be based on kInitialCongestionWindowInsecure.
-const uint32 kInitialCongestionWindowPackets = 10;
-const uint32 kDefaultWindowTCP =
+const uint32_t kInitialCongestionWindowPackets = 10;
+const uint32_t kDefaultWindowTCP =
     kInitialCongestionWindowPackets * kDefaultTCPMSS;
 const float kRenoBeta = 0.7f;  // Reno backoff factor.
 
 class TcpCubicBytesSenderPeer : public TcpCubicBytesSender {
  public:
   TcpCubicBytesSenderPeer(const QuicClock* clock, bool reno)
       : TcpCubicBytesSender(clock,
                             &rtt_stats_,
                             reno,
                             kInitialCongestionWindowPackets,
@@ skipping 324 matching lines @@
 TEST_F(TcpCubicBytesSenderTest, RTOCongestionWindowNoRetransmission) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
 
   // Expect the window to remain unchanged if the RTO fires but no packets are
   // retransmitted.
   sender_->OnRetransmissionTimeout(false);
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicBytesSenderTest, RetransmissionDelay) {
-  const int64 kRttMs = 10;
-  const int64 kDeviationMs = 3;
+  const int64_t kRttMs = 10;
+  const int64_t kDeviationMs = 3;
   EXPECT_EQ(QuicTime::Delta::Zero(), sender_->RetransmissionDelay());
 
   sender_->rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs),
                                 QuicTime::Delta::Zero(), clock_.Now());
 
   // Initial value is to set the median deviation to half of the initial rtt,
   // the median in then multiplied by a factor of 4 and finally the smoothed rtt
   // is added which is the initial rtt.
   QuicTime::Delta expected_delay =
       QuicTime::Delta::FromMilliseconds(kRttMs + kRttMs / 2 * 4);
   EXPECT_EQ(expected_delay, sender_->RetransmissionDelay());
 
   for (int i = 0; i < 100; ++i) {
     // Run to make sure that we converge.
     sender_->rtt_stats_.UpdateRtt(
         QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs),
         QuicTime::Delta::Zero(), clock_.Now());
     sender_->rtt_stats_.UpdateRtt(
         QuicTime::Delta::FromMilliseconds(kRttMs - kDeviationMs),
         QuicTime::Delta::Zero(), clock_.Now());
   }
   expected_delay = QuicTime::Delta::FromMilliseconds(kRttMs + kDeviationMs * 4);
 
   EXPECT_NEAR(kRttMs, sender_->rtt_stats_.smoothed_rtt().ToMilliseconds(), 1);
   EXPECT_NEAR(expected_delay.ToMilliseconds(),
               sender_->RetransmissionDelay().ToMilliseconds(), 1);
-  EXPECT_EQ(
-      static_cast<int64>(sender_->GetCongestionWindow() * kNumMicrosPerSecond /
-                         sender_->rtt_stats_.smoothed_rtt().ToMicroseconds()),
-      sender_->BandwidthEstimate().ToBytesPerSecond());
+  EXPECT_EQ(static_cast<int64_t>(
+                sender_->GetCongestionWindow() * kNumMicrosPerSecond /
+                sender_->rtt_stats_.smoothed_rtt().ToMicroseconds()),
+            sender_->BandwidthEstimate().ToBytesPerSecond());
 }
 
 TEST_F(TcpCubicBytesSenderTest, TcpCubicResetEpochOnQuiescence) {
   const int kMaxCongestionWindow = 50;
   const QuicByteCount kMaxCongestionWindowBytes =
       kMaxCongestionWindow * kDefaultTCPMSS;
   int num_sent = SendAvailableSendWindow();
 
   // Make sure we fall out of slow start.
   QuicByteCount saved_cwnd = sender_->GetCongestionWindow();
@@ skipping 148 matching lines @@
   for (int i = 0; i < 10; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     EXPECT_TRUE(sender_->InRecovery());
     AckNPackets(2);
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   }
   EXPECT_FALSE(sender_->InRecovery());
 
   // Out of recovery now. Congestion window should not grow during RTT.
-  for (uint64 i = 0; i < expected_send_window / kDefaultTCPMSS - 2; i += 2) {
+  for (uint64_t i = 0; i < expected_send_window / kDefaultTCPMSS - 2; i += 2) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   }
 
   // Next ack should cause congestion window to grow by 1MSS.
   SendAvailableSendWindow();
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
@@ skipping 92 matching lines @@
   // Resets cwnd and slow start threshold on connection migrations.
   sender_->OnConnectionMigration();
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   EXPECT_EQ(kMaxCongestionWindow * kDefaultTCPMSS,
             sender_->GetSlowStartThreshold());
   EXPECT_FALSE(sender_->hybrid_slow_start().started());
 }
 
 }  // namespace test
 }  // namespace net