Minor change of QUIC's RTO behavior to not change the congestion window

net/quic/quic_sent_packet_manager_test.cc

Index: net/quic/quic_sent_packet_manager_test.cc
diff --git a/net/quic/quic_sent_packet_manager_test.cc b/net/quic/quic_sent_packet_manager_test.cc
index 1a0885a6faad3a99dcf6589417959756499ba933..e5227d086b356159977ceb21f83ae3871d6efb3a 100644
--- a/net/quic/quic_sent_packet_manager_test.cc
+++ b/net/quic/quic_sent_packet_manager_test.cc
@@ -113,6 +113,32 @@ class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
                             packets_.back(), 0u, NULL);
   }
 
+  void SendDataPacket(QuicPacketSequenceNumber sequence_number) {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _, _))
+                    .Times(1).WillOnce(Return(true));
+    SerializedPacket packet(CreatePacket(sequence_number));
+    manager_.OnSerializedPacket(packet, clock_.ApproximateNow());
+    manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
+                          packet.packet->length(), NOT_RETRANSMISSION,
+                          HAS_RETRANSMITTABLE_DATA);
+  }
+
+  // Based on QuicConnection's WritePendingRetransmissions.
+  void RetransmitNextPacket(
+      QuicPacketSequenceNumber retransmission_sequence_number) {
+    EXPECT_TRUE(manager_.HasPendingRetransmissions());
+    EXPECT_CALL(*send_algorithm_,
+                OnPacketSent(_, retransmission_sequence_number, _, _, _))
+                    .Times(1).WillOnce(Return(true));
+    const QuicSentPacketManager::PendingRetransmission pending =
+        manager_.NextPendingRetransmission();
+    manager_.OnRetransmittedPacket(
+        pending.sequence_number, retransmission_sequence_number);
+    manager_.OnPacketSent(retransmission_sequence_number,
+                          clock_.ApproximateNow(), 1000,
+                          pending.transmission_type, HAS_RETRANSMITTABLE_DATA);
+  }
+
   testing::StrictMock<MockHelper> helper_;
   QuicSentPacketManager manager_;
   vector<QuicPacket*> packets_;
@@ -202,6 +228,11 @@ TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
+
+  // Verify that if the retransmission alarm does fire to abandon packet 2,
+  // the sent packet manager is not notified, since there is no retransmittable
+  // data outstanding.
+  manager_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
@@ -221,6 +252,11 @@ TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
   QuicPacketSequenceNumber unacked[] = { 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
+
+  // Verify that if the retransmission alarm does fire to abandon packet 3,
+  // the sent packet manager is not notified, since there is no retransmittable
+  // data outstanding.
+  manager_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
@@ -796,14 +832,12 @@ TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) {
                           NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   }
 
-  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(kNumSentPackets);
 
   manager_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMin) {
-  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
   QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(1);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillOnce(Return(delay));
@@ -814,7 +848,6 @@ TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMin) {
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMax) {
-  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
   QuicTime::Delta delay = QuicTime::Delta::FromSeconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillOnce(Return(delay));
@@ -825,6 +858,7 @@ TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMax) {
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelay) {
+  SendDataPacket(1);
   QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillRepeatedly(Return(delay));
@@ -833,14 +867,17 @@ TEST_F(QuicSentPacketManagerTest, GetTransmissionDelay) {
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(delay, manager_.GetRetransmissionDelay());
     delay = delay.Add(delay);
+    EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(i + 1, _));
     EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
     manager_.OnRetransmissionTimeout();
+    RetransmitNextPacket(i + 2);
   }
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTestTransmissionDelayTailDrop) {
   FLAGS_limit_rto_increase_for_tests = true;
 
+  SendDataPacket(1);
   QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillRepeatedly(Return(delay));
@@ -848,8 +885,10 @@ TEST_F(QuicSentPacketManagerTest, GetTestTransmissionDelayTailDrop) {
   // No backoff for the first 5 retransmissions.
   for (int i = 0; i < 5; ++i) {
     EXPECT_EQ(delay, manager_.GetRetransmissionDelay());
+    EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(i + 1, _));
     EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
     manager_.OnRetransmissionTimeout();
+    RetransmitNextPacket(i + 2);
   }
 
   // Then backoff starts