Fix QUIC's TCP style retransmission logic to only send a maximum of 2

net/quic/quic_sent_packet_manager_test.cc

 // Copyright 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/quic_sent_packet_manager.h"
 
 #include "base/stl_util.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 613 matching lines @@
   received_info.largest_observed = kNumSentPackets;
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(kNumSentPackets, _, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   SequenceNumberSet retransmissions =
       manager_.OnIncomingAckFrame(received_info, clock_.Now());
   EXPECT_EQ(1u, retransmissions.size());
   EXPECT_EQ(3u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
 }
 
-TEST_F(QuicSentPacketManagerTest, NackRetransmit10Packets) {
+TEST_F(QuicSentPacketManagerTest, NackRetransmit2Packets) {
   const size_t kNumSentPackets = 20;
   // Transmit 20 packets.
   for (QuicPacketSequenceNumber i = 1; i <= kNumSentPackets; ++i) {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
                     .Times(1).WillOnce(Return(true));
     manager_.OnPacketSent(i, clock_.Now(), 1000,
                            NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   }
 
   // Nack the first 19 packets 3 times.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = kNumSentPackets;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   for (size_t i = 1; i < kNumSentPackets; ++i) {
     received_info.missing_packets.insert(i);
   }
   EXPECT_CALL(*send_algorithm_,
               OnPacketAcked(kNumSentPackets, _, _)).Times(1);
-  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(10);
-  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(10);
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
   SequenceNumberSet retransmissions =
       manager_.OnIncomingAckFrame(received_info, clock_.Now());
-  EXPECT_EQ(10u, retransmissions.size());
+  EXPECT_EQ(2u, retransmissions.size());
   for (size_t i = 1; i < kNumSentPackets; ++i) {
     EXPECT_EQ(kNumSentPackets - i,
               QuicSentPacketManagerPeer::GetNackCount(&manager_, i));
   }
 }
 
-TEST_F(QuicSentPacketManagerTest, NackRetransmit10PacketsAlternateAcks) {
+TEST_F(QuicSentPacketManagerTest, NackRetransmit2PacketsAlternateAcks) {
   const size_t kNumSentPackets = 30;
   // Transmit 15 packets of data and 15 ack packets.  The send algorithm will
   // inform the congestion manager not to save the acks by returning false.
   for (QuicPacketSequenceNumber i = 1; i <= kNumSentPackets; ++i) {
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
                     .Times(1).WillOnce(Return(i % 2 == 0 ? false : true));
     manager_.OnPacketSent(
         i, clock_.Now(), 1000, NOT_RETRANSMISSION,
         i % 2 == 0 ? NO_RETRANSMITTABLE_DATA : HAS_RETRANSMITTABLE_DATA);
   }
 
   // Nack the first 29 packets 3 times.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = kNumSentPackets;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   for (size_t i = 1; i < kNumSentPackets; ++i) {
     received_info.missing_packets.insert(i);
   }
   // We never actually get an ack call, since the kNumSentPackets packet was
   // not saved.
-  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(10);
-  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(10);
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
   SequenceNumberSet retransmissions =
       manager_.OnIncomingAckFrame(received_info, clock_.Now());
-  EXPECT_EQ(10u, retransmissions.size());
+  EXPECT_EQ(2u, retransmissions.size());
   // Only non-ack packets have a nack count.
   for (size_t i = 1; i < kNumSentPackets; i += 2) {
     EXPECT_EQ(kNumSentPackets - i,
               QuicSentPacketManagerPeer::GetNackCount(&manager_, i));
   }
 
   // Ensure only the odd packets were retransmitted, since the others were not
   // retransmittable(ie: acks).
   for (SequenceNumberSet::const_iterator it = retransmissions.begin();
        it != retransmissions.end(); ++it) {
@@ skipping 185 matching lines @@
     RetransmitNextPacket(i + 2);
   }
 
   // Then backoff starts
   EXPECT_EQ(delay.Add(delay), manager_.GetRetransmissionDelay());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net