Add a new rate based sending connection option which uses the pacing rate to keep the bytes_in_flig…

net/quic/congestion_control/tcp_cubic_sender_packets_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 "net/quic/congestion_control/tcp_cubic_sender_packets.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/logging.h"
@@ skipping 935 matching lines @@
   LoseNPackets(9);
   AckNPackets(1);
 
   // We should now have fallen out of slow start with a reduced window.
   EXPECT_EQ(kRenoBeta * kDefaultWindowTCP, sender_->GetCongestionWindow());
   const QuicPacketCount window_in_packets =
       kRenoBeta * kDefaultWindowTCP / kDefaultTCPMSS;
   const QuicBandwidth expected_pacing_rate =
       QuicBandwidth::FromBytesAndTimeDelta(kRenoBeta * kDefaultWindowTCP,
                                            sender_->rtt_stats_.smoothed_rtt());
-  EXPECT_EQ(expected_pacing_rate, sender_->PacingRate());
+  EXPECT_EQ(expected_pacing_rate, sender_->PacingRate(0));
   EXPECT_EQ(window_in_packets,
             static_cast<uint64_t>(SendAvailableSendWindow()));
-  EXPECT_EQ(expected_pacing_rate, sender_->PacingRate());
+  EXPECT_EQ(expected_pacing_rate,
+            sender_->PacingRate(kRenoBeta * kDefaultWindowTCP));
+}
+
+TEST_F(TcpCubicSenderPacketsTest, PaceSlowerAboveCwnd) {
+  ValueRestore<bool> old_flag(&FLAGS_quic_rate_based_sending, true);
+  QuicTime::Delta rtt(QuicTime::Delta::FromMilliseconds(60));
+  sender_->rtt_stats_.UpdateRtt(rtt, QuicTime::Delta::Zero(), clock_.Now());
+
+  QuicConfig config;
+  QuicTagVector options;
+  options.push_back(kRATE);
+  QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
+  sender_->SetFromConfig(config, Perspective::IS_SERVER);
+  EXPECT_EQ(10u, sender_->congestion_window());
+  sender_->SetNumEmulatedConnections(1);
+  // Lose a packet to exit slow start.
+  LoseNPackets(1);
+  const QuicPacketCount cwnd = 7;
+  EXPECT_EQ(cwnd * kDefaultTCPMSS, sender_->GetCongestionWindow());
+
+  EXPECT_TRUE(
+      sender_->TimeUntilSend(QuicTime::Zero(), kDefaultTCPMSS).IsZero());
+  EXPECT_EQ(sender_->PacingRate(kDefaultTCPMSS),
+            QuicBandwidth::FromBytesAndTimeDelta(7 * kDefaultTCPMSS, rtt)
+                .Scale(1.25));
+  for (QuicPacketCount i = cwnd + 1; i < 1.5 * cwnd; ++i) {
+    EXPECT_TRUE(
+        sender_->TimeUntilSend(QuicTime::Zero(), i * kDefaultTCPMSS).IsZero());
+    EXPECT_EQ(sender_->PacingRate(i * kDefaultTCPMSS),
+              QuicBandwidth::FromBytesAndTimeDelta(cwnd * kDefaultTCPMSS, rtt)
+                  .Scale(0.75));
+  }
+  EXPECT_FALSE(
+      sender_->TimeUntilSend(QuicTime::Zero(), 11 * kDefaultTCPMSS).IsZero());
 }
 
 TEST_F(TcpCubicSenderPacketsTest, ResetAfterConnectionMigration) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
   EXPECT_EQ(kMaxCongestionWindowPackets, sender_->slowstart_threshold());
 
   // Starts with slow start.
   sender_->SetNumEmulatedConnections(1);
   const int kNumberOfAcks = 10;
   for (int i = 0; i < kNumberOfAcks; ++i) {
@@ skipping 37 matching lines @@
     acked_packets.push_back(std::make_pair(i, 1350));
     sender->OnCongestionEvent(true, sender->GetCongestionWindow(),
                               acked_packets, missing_packets);
   }
   EXPECT_EQ(kDefaultMaxCongestionWindowPackets,
             sender->GetCongestionWindow() / kDefaultTCPMSS);
 }
 
 }  // namespace test
 }  // namespace net