Update from chromium https://crrev.com/302282

net/quic/congestion_control/tcp_cubic_sender_test.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 <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/congestion_control/tcp_receiver.h"
 #include "net/quic/crypto/crypto_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 "testing/gtest/include/gtest/gtest.h"
 
 using std::make_pair;
 using std::min;
 
 namespace net {
 namespace test {
 
 const int64 kInitialCongestionWindow = 10;
 const uint32 kDefaultWindowTCP = kInitialCongestionWindow * kDefaultTCPMSS;
 
 // TODO(ianswett): Remove 10000 once b/10075719 is fixed.
-const QuicTcpCongestionWindow kDefaultMaxCongestionWindowTCP = 10000;
+const QuicPacketCount kDefaultMaxCongestionWindowTCP = 10000;
 
 class TcpCubicSenderPeer : public TcpCubicSender {
  public:
   TcpCubicSenderPeer(const QuicClock* clock,
                      bool reno,
-                     QuicTcpCongestionWindow max_tcp_congestion_window)
+                     QuicPacketCount max_tcp_congestion_window)
       : TcpCubicSender(
             clock, &rtt_stats_, reno, max_tcp_congestion_window, &stats_) {
   }
 
-  QuicTcpCongestionWindow congestion_window() {
+  QuicPacketCount congestion_window() {
     return congestion_window_;
   }
 
-  QuicTcpCongestionWindow slowstart_threshold() {
+  QuicPacketCount slowstart_threshold() {
     return slowstart_threshold_;
   }
 
   const HybridSlowStart& hybrid_slow_start() const {
     return hybrid_slow_start_;
   }
 
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
-
-  using TcpCubicSender::SendWindow;
 };
 
 class TcpCubicSenderTest : public ::testing::Test {
  protected:
   TcpCubicSenderTest()
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
         sender_(new TcpCubicSenderPeer(&clock_, true,
                                        kDefaultMaxCongestionWindowTCP)),
         receiver_(new TcpReceiver()),
         sequence_number_(1),
@@ skipping 100 matching lines @@
       HAS_RETRANSMITTABLE_DATA).IsZero());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
                                      0,
                                      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   SendAvailableSendWindow();
   for (int i = 0; i < kNumberOfAcks; ++i) {
     AckNPackets(2);
   }
-  QuicByteCount bytes_to_send = sender_->SendWindow();
+  QuicByteCount bytes_to_send = sender_->GetCongestionWindow();
   // It's expected 2 acks will arrive when the bytes_in_flight are greater than
   // half the CWND.
   EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * 2,
             bytes_to_send);
 }
 
 TEST_F(TcpCubicSenderTest, ExponentialSlowStart) {
   const int kNumberOfAcks = 20;
   // At startup make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
       0,
       HAS_RETRANSMITTABLE_DATA).IsZero());
   // Make sure we can send.
   EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
                                      0,
                                      HAS_RETRANSMITTABLE_DATA).IsZero());
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
-  QuicByteCount bytes_to_send = sender_->SendWindow();
+  QuicByteCount bytes_to_send = sender_->GetCongestionWindow();
   EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks,
             bytes_to_send);
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
   sender_->SetNumEmulatedConnections(1);
   EXPECT_EQ(kDefaultMaxCongestionWindowTCP * kDefaultTCPMSS,
             sender_->GetSlowStartThreshold());
 
   // Make sure that we fall out of slow start when we send ACK train longer
@@ skipping 212 matching lines @@
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
   // Exit recovery and return to sending at the new rate.
   for (int i = 0; i < kNumberOfAcks; ++i) {
     AckNPackets(1);
     EXPECT_EQ(1, SendAvailableSendWindow());
   }
 }
 
 TEST_F(TcpCubicSenderTest, RTOCongestionWindowAndRevert) {
-  EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
+  EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   EXPECT_EQ(10000u, sender_->slowstart_threshold());
 
   // Expect the window to decrease to the minimum once the RTO fires
   // and slow start threshold to be set to 1/2 of the CWND.
   sender_->OnRetransmissionTimeout(true);
-  EXPECT_EQ(2 * kDefaultTCPMSS, sender_->SendWindow());
+  EXPECT_EQ(2 * kDefaultTCPMSS, sender_->GetCongestionWindow());
   EXPECT_EQ(5u, sender_->slowstart_threshold());
 
   // Now repair the RTO and ensure the slowstart threshold reverts.
   sender_->RevertRetransmissionTimeout();
-  EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
+  EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   EXPECT_EQ(10000u, sender_->slowstart_threshold());
 }
 
 TEST_F(TcpCubicSenderTest, RTOCongestionWindowNoRetransmission) {
-  EXPECT_EQ(kDefaultWindowTCP, sender_->SendWindow());
+  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_->SendWindow());
+  EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicSenderTest, RetransmissionDelay) {
   const int64 kRttMs = 10;
   const int64 kDeviationMs = 3;
   EXPECT_EQ(QuicTime::Delta::Zero(), sender_->RetransmissionDelay());
 
   sender_->rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(kRttMs),
                                 QuicTime::Delta::Zero(), clock_.Now());
 
@@ skipping 19 matching lines @@
   EXPECT_NEAR(expected_delay.ToMilliseconds(),
               sender_->RetransmissionDelay().ToMilliseconds(),
               1);
   EXPECT_EQ(static_cast<int64>(
                 sender_->GetCongestionWindow() * kNumMicrosPerSecond /
                 sender_->rtt_stats_.SmoothedRtt().ToMicroseconds()),
             sender_->BandwidthEstimate().ToBytesPerSecond());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
-  const QuicTcpCongestionWindow kMaxCongestionWindowTCP = 50;
+  const QuicPacketCount kMaxCongestionWindowTCP = 50;
   const int kNumberOfAcks = 100;
   sender_.reset(
       new TcpCubicSenderPeer(&clock_, false, kMaxCongestionWindowTCP));
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   QuicByteCount expected_send_window =
       kMaxCongestionWindowTCP * kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicSenderTest, TcpRenoMaxCongestionWindow) {
-  const QuicTcpCongestionWindow kMaxCongestionWindowTCP = 50;
+  const QuicPacketCount kMaxCongestionWindowTCP = 50;
   const int kNumberOfAcks = 1000;
   sender_.reset(
       new TcpCubicSenderPeer(&clock_, true, kMaxCongestionWindowTCP));
 
   SendAvailableSendWindow();
   AckNPackets(2);
   // Make sure we fall out of slow start.
   LoseNPackets(1);
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
 
   QuicByteCount expected_send_window =
       kMaxCongestionWindowTCP * kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicSenderTest, TcpCubicMaxCongestionWindow) {
-  const QuicTcpCongestionWindow kMaxCongestionWindowTCP = 50;
+  const QuicPacketCount kMaxCongestionWindowTCP = 50;
   // Set to 10000 to compensate for small cubic alpha.
   const int kNumberOfAcks = 10000;
 
   sender_.reset(
       new TcpCubicSenderPeer(&clock_, false, kMaxCongestionWindowTCP));
 
   SendAvailableSendWindow();
   AckNPackets(2);
   // Make sure we fall out of slow start.
   LoseNPackets(1);
@@ skipping 31 matching lines @@
                                      sequence_number_++, kDefaultTCPMSS,
                                      NO_RETRANSMITTABLE_DATA));
 
   // Send a data packet with retransmittable data, and ensure it is tracked.
   EXPECT_TRUE(sender_->OnPacketSent(clock_.Now(), bytes_in_flight_,
                                     sequence_number_++, kDefaultTCPMSS,
                                     HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(TcpCubicSenderTest, ConfigureMaxInitialWindow) {
-  QuicTcpCongestionWindow congestion_window = sender_->congestion_window();
+  QuicPacketCount congestion_window = sender_->congestion_window();
   QuicConfig config;
   QuicConfigPeer::SetReceivedInitialWindow(&config, 2 * congestion_window);
 
   sender_->SetFromConfig(config, true);
   EXPECT_EQ(2 * congestion_window, sender_->congestion_window());
 
   // Verify that kCOPT: kIW10 forces the congestion window to the
   // default of 10 regardless of ReceivedInitialWindow.
   QuicTagVector options;
   options.push_back(kIW10);
@@ skipping 97 matching lines @@
   }
 
   // Next ack should cause congestion window to grow by 1MSS.
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net