relnote: Limit the number of burst tokens in QUIC's pacing sender to the

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 "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Return;
 using testing::StrictMock;
 using testing::_;
 
 namespace net {
@@ skipping 173 matching lines @@
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 }
 
 TEST_F(PacingSenderTest, InitialBurst) {
   // Configure pacing rate of 1 packet per 1 ms.
   InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
                          kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
+  if (FLAGS_quic_limit_pacing_burst) {
+    EXPECT_CALL(*mock_sender_, GetCongestionWindow())
+        .WillOnce(Return(10 * kDefaultTCPMSS));
+  }
   // Update the RTT and verify that the first 10 packets aren't paced.
   UpdateRtt();
 
   // Send 10 packets, and verify that they are not paced.
   for (int i = 0 ; i < kInitialBurstPackets; ++i) {
     CheckPacketIsSentImmediately();
   }
 
   // The first packet was a "make up", then we sent two packets "into the
   // future", so the delay should be 2ms.
@@ skipping 16 matching lines @@
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 }
 
 TEST_F(PacingSenderTest, InitialBurstNoRttMeasurement) {
   // Configure pacing rate of 1 packet per 1 ms.
   InitPacingRate(10, QuicBandwidth::FromBytesAndTimeDelta(
                          kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
+  if (FLAGS_quic_limit_pacing_burst) {
+    EXPECT_CALL(*mock_sender_, GetCongestionWindow())
+        .WillOnce(Return(10 * kDefaultTCPMSS));
+  }
   // Send 10 packets, and verify that they are not paced.
   for (int i = 0 ; i < kInitialBurstPackets; ++i) {
     CheckPacketIsSentImmediately();
   }
 
   // The first packet was a "make up", then we sent two packets "into the
   // future", so the delay should be 2ms.
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
@@ skipping 17 matching lines @@
   CheckPacketIsDelayed(QuicTime::Delta::FromMilliseconds(2));
 }
 
 TEST_F(PacingSenderTest, FastSending) {
   // Ensure the pacing sender paces, even when the inter-packet spacing is less
   // than the pacing granularity.
   InitPacingRate(10,
                  QuicBandwidth::FromBytesAndTimeDelta(
                      2 * kMaxPacketSize, QuicTime::Delta::FromMilliseconds(1)));
 
+  if (FLAGS_quic_limit_pacing_burst) {
+    EXPECT_CALL(*mock_sender_, GetCongestionWindow())
+        .WillOnce(Return(10 * kDefaultTCPMSS));
+  }
   // Update the RTT and verify that the first 10 packets aren't paced.
   UpdateRtt();
 
   // Send 10 packets, and verify that they are not paced.
   for (int i = 0; i < kInitialBurstPackets; ++i) {
     CheckPacketIsSentImmediately();
   }
 
   // The first packet was a "make up", then we sent two packets "into the
   // future", since it's 2 packets/ms, so the delay should be 1.5ms.
@@ skipping 15 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));
 }
 
 }  // namespace test
 }  // namespace net