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

net/quic/congestion_control/pacing_sender_test.cc

 // Copyright (c) 2013 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/pacing_sender.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 25 matching lines @@
     clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(9));
   }
 
   ~PacingSenderTest() override {}
 
   void InitPacingRate(QuicPacketCount burst_size, QuicBandwidth bandwidth) {
     pacing_sender_.reset();
     mock_sender_ = new StrictMock<MockSendAlgorithm>();
     pacing_sender_.reset(new PacingSender(
         mock_sender_, QuicTime::Delta::FromMilliseconds(1), burst_size));
-    EXPECT_CALL(*mock_sender_, PacingRate()).WillRepeatedly(Return(bandwidth));
+    EXPECT_CALL(*mock_sender_, PacingRate(_)).WillRepeatedly(Return(bandwidth));
   }
 
   void CheckPacketIsSentImmediately(HasRetransmittableData retransmittable_data,
                                     QuicByteCount bytes_in_flight,
                                     bool in_recovery) {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     for (int i = 0; i < 2; ++i) {
       EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), bytes_in_flight))
           .WillOnce(Return(zero_time_));
@@ skipping 299 matching lines @@
 
   EXPECT_CALL(*mock_sender_, SetMaxCongestionWindow(kBytes));
   pacing_sender_->SetMaxCongestionWindow(kBytes);
 
   SendAlgorithmInterface::CongestionVector packets;
   EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytes, packets, packets));
   pacing_sender_->OnCongestionEvent(true, kBytes, packets, packets);
 
   EXPECT_CALL(*mock_sender_, OnPacketSent(kTime, kBytes, 123u, kBytes,
                                           HAS_RETRANSMITTABLE_DATA));
-  EXPECT_CALL(*mock_sender_, PacingRate()).WillOnce(Return(kBandwidth));
+  EXPECT_CALL(*mock_sender_, PacingRate(_)).WillOnce(Return(kBandwidth));
   pacing_sender_->OnPacketSent(kTime, kBytes, 123u, kBytes,
                                HAS_RETRANSMITTABLE_DATA);
 
   EXPECT_CALL(*mock_sender_, OnRetransmissionTimeout(true));
   pacing_sender_->OnRetransmissionTimeout(true);
 
   EXPECT_CALL(*mock_sender_, OnConnectionMigration());
   pacing_sender_->OnConnectionMigration();
 
   EXPECT_CALL(*mock_sender_, TimeUntilSend(kTime, kBytes))
       .WillOnce(Return(kTimeDelta));
   pacing_sender_->TimeUntilSend(kTime, kBytes);
 
-  EXPECT_CALL(*mock_sender_, PacingRate()).WillOnce(Return(kBandwidth));
-  EXPECT_EQ(kBandwidth, pacing_sender_->PacingRate());
+  EXPECT_CALL(*mock_sender_, PacingRate(_)).WillOnce(Return(kBandwidth));
+  EXPECT_EQ(kBandwidth, pacing_sender_->PacingRate(0));
 
   EXPECT_CALL(*mock_sender_, BandwidthEstimate()).WillOnce(Return(kBandwidth));
   EXPECT_EQ(kBandwidth, pacing_sender_->BandwidthEstimate());
 
   EXPECT_CALL(*mock_sender_, RetransmissionDelay())
       .WillOnce(Return(kTimeDelta));
   EXPECT_EQ(kTimeDelta, pacing_sender_->RetransmissionDelay());
 
   EXPECT_CALL(*mock_sender_, GetCongestionWindow()).WillOnce(Return(kBytes));
   EXPECT_EQ(kBytes, pacing_sender_->GetCongestionWindow());
 
   EXPECT_CALL(*mock_sender_, InSlowStart()).WillOnce(Return(true));
   EXPECT_TRUE(pacing_sender_->InSlowStart());
 
   EXPECT_CALL(*mock_sender_, InRecovery()).WillOnce(Return(true));
   EXPECT_TRUE(pacing_sender_->InRecovery());
 
   EXPECT_CALL(*mock_sender_, GetSlowStartThreshold()).WillOnce(Return(kBytes));
   EXPECT_EQ(kBytes, pacing_sender_->GetSlowStartThreshold());
 
   EXPECT_CALL(*mock_sender_, GetCongestionControlType())
       .WillOnce(Return(kReno));
   EXPECT_EQ(kReno, pacing_sender_->GetCongestionControlType());
 }
 
 }  // namespace test
 }  // namespace net