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_bytes_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_sender_bytes.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <memory>
 
@@ skipping 786 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(TcpCubicSenderBytesTest, 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(10 * kDefaultTCPMSS, sender_->GetCongestionWindow());
+  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(TcpCubicSenderBytesTest, ResetAfterConnectionMigration) {
   // Starts from slow start.
   sender_->SetNumEmulatedConnections(1);
   const int kNumberOfAcks = 10;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
@@ skipping 34 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