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

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 95 matching lines @@
   }
 
   SerializedPacket CreateFecPacket(QuicPacketSequenceNumber sequence_number) {
     packets_.push_back(QuicPacket::NewFecPacket(
         NULL, 0, false, PACKET_8BYTE_GUID, false,
         PACKET_6BYTE_SEQUENCE_NUMBER));
     return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
                             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_;
   MockClock clock_;
   MockSendAlgorithm* send_algorithm_;
 };
 
 TEST_F(QuicSentPacketManagerTest, IsUnacked) {
   VerifyUnackedPackets(NULL, 0);
 
@@ skipping 69 matching lines @@
   // Ack 1 but not 2.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(3u));
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
   // 2 remains unacked, but no packets have retransmittable data.
   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) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   RetransmitPacket(1, 2);
   RetransmitPacket(2, 3);
 
   // Ack 1 but not 2 or 3.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(4u));
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
   // 3 remains unacked, but no packets have retransmittable data.
   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) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   RetransmitPacket(1, 2);
   RetransmitPacket(2, 3);
   RetransmitPacket(3, 4);
 
@@ skipping 555 matching lines @@
 TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) {
   // Send 100 packets and then ensure all are abandoned when the RTO fires.
   const size_t kNumSentPackets = 100;
   for (size_t 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);
   }
 
-  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));
 
   manager_.OnRetransmissionTimeout();
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
             manager_.GetRetransmissionDelay());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMax) {
-  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
   QuicTime::Delta delay = QuicTime::Delta::FromSeconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillOnce(Return(delay));
 
   manager_.OnRetransmissionTimeout();
   EXPECT_EQ(QuicTime::Delta::FromSeconds(60),
             manager_.GetRetransmissionDelay());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelay) {
+  SendDataPacket(1);
   QuicTime::Delta delay = QuicTime::Delta::FromMilliseconds(500);
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillRepeatedly(Return(delay));
 
   // Delay should back off exponentially.
   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));
 
   // 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
   EXPECT_EQ(delay.Add(delay), manager_.GetRetransmissionDelay());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net