Correctly handle NACK-based "retransmission" of packets which no longer

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 @@
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
     QuicSentPacketManager::PendingRetransmission next_retransmission =
         manager_.NextPendingRetransmission();
     EXPECT_EQ(old_sequence_number, next_retransmission.sequence_number);
     EXPECT_EQ(NACK_RETRANSMISSION, next_retransmission.transmission_type);
     manager_.OnRetransmittedPacket(old_sequence_number, new_sequence_number);
     EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(
         &manager_, new_sequence_number));
   }
 
+  void RetransmitAndSendPacket(QuicPacketSequenceNumber old_sequence_number,
+                               QuicPacketSequenceNumber new_sequence_number) {
+    RetransmitPacket(old_sequence_number, new_sequence_number);
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, new_sequence_number, _, _, _))
+        .WillOnce(Return(true));
+    manager_.OnPacketSent(new_sequence_number, clock_.Now(),
+                          1000, NACK_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+  }
+
   SerializedPacket CreateDataPacket(QuicPacketSequenceNumber sequence_number) {
     return CreatePacket(sequence_number, true);
   }
 
   SerializedPacket CreatePacket(QuicPacketSequenceNumber sequence_number,
                                 bool retransmittable) {
     packets_.push_back(QuicPacket::NewDataPacket(
         NULL, 1000, false, PACKET_8BYTE_GUID, false,
         PACKET_6BYTE_SEQUENCE_NUMBER));
     return SerializedPacket(
@@ skipping 133 matching lines @@
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyPendingPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 
   // Verify that the retransmission alarm would not fire,
   // since there is no retransmittable data outstanding.
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
 }
 
+TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
+  SendDataPacket(1);
+  RetransmitPacket(1, 2);
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 2, _, _, _))
+      .WillOnce(Return(true));
+  manager_.OnPacketSent(2, clock_.ApproximateNow(), 1000,
+                        NACK_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
+
+  // First, ACK packet 1 which makes packet 2 non-retransmittable.
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _, _));
+  ReceivedPacketInfo received_info;
+  received_info.largest_observed = 1;
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+
+  SendDataPacket(3);
+  SendDataPacket(4);
+  SendDataPacket(5);
+  // Next, NACK packet 2 three times.
+  received_info.largest_observed = 3;
+  received_info.missing_packets.insert(2);
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _, _));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+
+  received_info.largest_observed = 4;
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _, _));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+
+  received_info.largest_observed = 5;
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _, _));
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+
+  // No packets remain unacked.
+  VerifyUnackedPackets(NULL, 0);
+  VerifyPendingPackets(NULL, 0);
+  VerifyRetransmittablePackets(NULL, 0);
+
+  // Verify that the retransmission alarm would not fire,
+  // since there is no retransmittable data outstanding.
+  EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
+}
+
+TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckPreviousBeforeSend) {
+  SendDataPacket(1);
+  RetransmitAndSendPacket(1, 2);
+
+  // Fire the RTO, which will mark 2 for retransmission (but will not send it).
+  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
+  manager_.OnRetransmissionTimeout();
+  EXPECT_TRUE(manager_.HasPendingRetransmissions());
+
+  // Ack 1 but not 2, before 2 is able to be sent.
+  // Since 1 has been retransmitted, it has already been lost, and so the
+  // send algorithm is not informed that it has been ACK'd.
+  ReceivedPacketInfo received_info;
+  received_info.largest_observed = 1;
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+
+  // Since 2 was marked for retransmit, when 1 is acked, 2 is discarded.
+  VerifyUnackedPackets(NULL, 0);
+  VerifyPendingPackets(NULL, 0);
+  VerifyRetransmittablePackets(NULL, 0);
+
+  // Verify that the retransmission alarm would not fire,
+  // since there is no retransmittable data outstanding.
+  EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
+}
+
 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
   SendDataPacket(1);
   RetransmitPacket(1, 2);
   RetransmitPacket(2, 3);
 
   // Ack 1 but not 2 or 3.
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _, _));
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
@@ skipping 767 matching lines @@
     delay = delay.Add(delay);
     EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
     manager_.OnRetransmissionTimeout();
     RetransmitNextPacket(i + 2);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net