Implement a QUIC No PRR connection option, NPRR. Protected by FLAGS_quic_allow_no_prr

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 280 matching lines @@
   }
 
   // The first packet was a "make up", then we sent two packets "into the
   // future", so the delay should be 1.5ms.
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMicroseconds(1500));
 }
 
+TEST_F(PacingSenderTest, NoBurstEnteringRecovery) {
+  ValueRestore<bool> old_flag(&FLAGS_quic_allow_noprr, true);
+  // Configure pacing rate of 1 packet per 1 ms with no burst tokens.
+  InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
+                        kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
+  // Sending a packet will set burst tokens.
+  CheckPacketIsSentImmediately();
+
+  // Losing a packet will set clear burst tokens.
+  SendAlgorithmInterface::CongestionVector lost_packets;
+  lost_packets.push_back(std::make_pair(1, kMaxPacketSize));
+  SendAlgorithmInterface::CongestionVector empty;
+  EXPECT_CALL(*mock_sender_,
+              OnCongestionEvent(true, kMaxPacketSize, empty, lost_packets));
+  pacing_sender_->OnCongestionEvent(true, kMaxPacketSize, empty, lost_packets);
+  // One packet is sent immediately, because of 1ms pacing granularity.
+  CheckPacketIsSentImmediately();
+  // Ensure packets are immediately paced.
+  EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(), kDefaultTCPMSS))
+      .WillOnce(Return(zero_time_));
+  // Verify the next packet is paced and delayed 2ms due to granularity.
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2),
+            pacing_sender_->TimeUntilSend(clock_.Now(), kDefaultTCPMSS));
+  CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
+}
+
 TEST_F(PacingSenderTest, NoBurstInRecovery) {
   // Configure pacing rate of 1 packet per 1 ms with no burst tokens.
   InitPacingRate(0, QuicBandwidth::FromBytesAndTimeDelta(
                         kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
   UpdateRtt();
 
   // Ensure only one packet is sent immediately and the rest are paced.
   CheckPacketIsSentImmediately(HAS_RETRANSMITTABLE_DATA, 0, true);
   CheckPacketIsSentImmediately();
@@ skipping 62 matching lines @@
   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