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

net/quic/quic_connection_test.cc

 // Copyright (c) 2012 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_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 900 matching lines @@
 
   QuicAckFrame frame(num_packets, QuicTime::Zero(), 1);
   // Create an ack with 256 nacks, none adjacent to one another.
   for (QuicPacketSequenceNumber i = 1; i <= 256; ++i) {
     frame.received_info.missing_packets.insert(i * 2);
   }
   frame.received_info.entropy_hash = 0;
   EXPECT_CALL(entropy_calculator_,
               EntropyHash(511)).WillOnce(testing::Return(0));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(256);
-  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);
   ProcessAckPacket(&frame);
 
   QuicReceivedPacketManager* received_packet_manager =
       QuicConnectionPeer::GetReceivedPacketManager(&connection_);
   // A truncated ack will not have the true largest observed.
   EXPECT_GT(num_packets,
             received_packet_manager->peer_largest_observed_packet());
 
   frame.received_info.missing_packets.erase(192);
   frame.received_info.entropy_hash = 2;
 
   // Removing one missing packet allows us to ack 192 and one more range.
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(2);
-  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);
   ProcessAckPacket(&frame);
   EXPECT_EQ(num_packets,
             received_packet_manager->peer_largest_observed_packet());
 }
 
 TEST_F(QuicConnectionTest, AckReceiptCausesAckSendBadEntropy) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessPacket(1);
   // Delay sending, then queue up an ack.
@@ skipping 833 matching lines @@
 
   // Fire the alarms and ensure the connection is still write blocked.
   connection_.GetResumeWritesAlarm()->Fire();
   connection_.GetSendAlarm()->Fire();
   EXPECT_TRUE(QuicConnectionPeer::IsWriteBlocked(&connection_));
 }
 
 TEST_F(QuicConnectionTest, LimitPacketsPerNack) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(15, _, _)).Times(1);
-  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(13);
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(4);
   int offset = 0;
   // Send packets 1 to 15.
   for (int i = 0; i < 15; ++i) {
     SendStreamDataToPeer(1, "foo", offset, !kFin, NULL);
     offset += 3;
   }
 
   // Ack 15, nack 1-14.
   QuicAckFrame nack(15, QuicTime::Zero(), 0);
   for (int i = 1; i < 15; ++i) {
     nack.received_info.missing_packets.insert(i);
   }
 
   nack.received_info.entropy_hash =
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 15) ^
       QuicConnectionPeer::GetSentEntropyHash(&connection_, 14);
 
-  // 13 packets have been NACK'd 3 times, but we limit retransmissions to 10.
-  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(10);
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(10);
+  // 13 packets have been NACK'd 3 times, but we limit retransmissions to 2.
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
   ProcessAckPacket(&nack);
 
-  // The next call should trigger retransmitting 3 more packets, because 14
-  // only has 2 nacks so far.
-  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(3);
-  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(3);
+  // The next call should trigger retransmitting 2 more packets.
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(2);
   ProcessAckPacket(&nack);
 }
 
 // Test sending multiple acks from the connection to the session.
 TEST_F(QuicConnectionTest, MultipleAcks) {
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(6);
   QuicPacketSequenceNumber last_packet;
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);  // Packet 1
   EXPECT_EQ(1u, last_packet);
   SendStreamDataToPeer(3, "foo", 0, !kFin, &last_packet);  // Packet 2
@@ skipping 1551 matching lines @@
                         true);
   TestConnection client(guid_, IPEndPoint(), helper_.get(), writer_.get(),
                         false);
   EXPECT_TRUE(client.sent_packet_manager().using_pacing());
   EXPECT_FALSE(server.sent_packet_manager().using_pacing());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net