Update from https://crrev.com/303153

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;
+const uint32 kDefaultWindowTCP = kDefaultInitialWindow * kDefaultTCPMSS;
 const float kRenoBeta = 0.7f;  // Reno backoff factor.
 
 // TODO(ianswett): Remove 10000 once b/10075719 is fixed.
 const QuicPacketCount kDefaultMaxCongestionWindowTCP = 10000;
 
 class TcpCubicSenderPeer : public TcpCubicSender {
  public:
   TcpCubicSenderPeer(const QuicClock* clock,
                      bool reno,
                      QuicPacketCount max_tcp_congestion_window)
@@ skipping 145 matching lines @@
   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());
+  EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
+  EXPECT_EQ(QuicBandwidth::Zero(), sender_->BandwidthEstimate());
   // 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_->GetCongestionWindow();
-  EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks,
-            bytes_to_send);
+  const QuicByteCount cwnd = sender_->GetCongestionWindow();
+  EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks, cwnd);
+  EXPECT_FALSE(sender_->HasReliableBandwidthEstimate());
+  EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(
+                cwnd, sender_->rtt_stats_.smoothed_rtt()),
+            sender_->BandwidthEstimate());
 }
 
 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
   // than half the RTT, in this test case 30ms, which is more than 30 calls to
   // Ack2Packets in one round.
@@ skipping 80 matching lines @@
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
   // Now RTO and ensure slow start gets reset.
   EXPECT_TRUE(sender_->hybrid_slow_start().started());
   sender_->OnRetransmissionTimeout(true);
   EXPECT_FALSE(sender_->hybrid_slow_start().started());
 }
 
 TEST_F(TcpCubicSenderTest, NoPRRWhenLessThanOnePacketInFlight) {
   SendAvailableSendWindow();
-  LoseNPackets(kInitialCongestionWindow - 1);
+  LoseNPackets(kDefaultInitialWindow - 1);
   AckNPackets(1);
   // PRR will allow 2 packets for every ack during recovery.
   EXPECT_EQ(2, SendAvailableSendWindow());
   // Simulate abandoning all packets by supplying a bytes_in_flight of 0.
   // PRR should now allow a packet to be sent, even though prr's state
   // variables believe it has sent enough packets.
   EXPECT_EQ(QuicTime::Delta::Zero(),
             sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA));
 }
 
@@ skipping 147 matching lines @@
     // 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_.SmoothedRtt().ToMilliseconds(), 1);
+  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_.SmoothedRtt().ToMicroseconds()),
+                sender_->rtt_stats_.smoothed_rtt().ToMicroseconds()),
             sender_->BandwidthEstimate().ToBytesPerSecond());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
   const QuicPacketCount kMaxCongestionWindowTCP = 50;
   const int kNumberOfAcks = 100;
   sender_.reset(
       new TcpCubicSenderPeer(&clock_, false, kMaxCongestionWindowTCP));
 
   for (int i = 0; i < kNumberOfAcks; ++i) {
@@ skipping 194 matching lines @@
 
   // Next ack should cause congestion window to grow by 1MSS.
   SendAvailableSendWindow();
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net