Add QUIC_VERSION_15 to add a revived_packets set to replace the

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 131 matching lines @@
                     .Times(1).WillOnce(Return(true));
     SerializedPacket packet(CreateDataPacket(sequence_number));
     packet.retransmittable_frames->AddStreamFrame(
         new QuicStreamFrame(1, false, 0, IOVector()));
     manager_.OnSerializedPacket(packet);
     manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
                           packet.packet->length(), NOT_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA);
   }
 
+  void SendFecPacket(QuicPacketSequenceNumber sequence_number) {
+    EXPECT_CALL(*send_algorithm_, OnPacketSent(_, sequence_number, _, _, _))
+                    .Times(1).WillOnce(Return(true));
+    SerializedPacket packet(CreateFecPacket(sequence_number));
+    manager_.OnSerializedPacket(packet);
+    manager_.OnPacketSent(sequence_number, clock_.ApproximateNow(),
+                          packet.packet->length(), NOT_RETRANSMISSION,
+                          NO_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(
@@ skipping 238 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _));
   EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
   manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
 
   VerifyUnackedPackets(NULL, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
 }
 
+TEST_F(QuicSentPacketManagerTest, LoseButDontRetransmitRevivedPacket) {
+  SendDataPacket(1);
+  SendDataPacket(2);
+  SendFecPacket(3);
+  SendDataPacket(4);
+
+  // Ack 2 and 3, and mark 1 as revived.
+  ReceivedPacketInfo received_info;
+  received_info.largest_observed = 3;
+  received_info.missing_packets.insert(1);
+  received_info.revived_packets.insert(1);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(2);
+  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+
+  EXPECT_FALSE(manager_.HasPendingRetransmissions());
+  QuicPacketSequenceNumber unacked[] = { 1, 4 };
+  VerifyUnackedPackets(unacked, arraysize(unacked));
+  EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
+  QuicPacketSequenceNumber retransmittable[] = { 4 };
+  VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
+
+  // Ack the 4th packet and expect the 1st to be considered lost.
+  received_info.largest_observed = 4;
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _));
+  EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _));
+  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+
+  EXPECT_FALSE(manager_.HasPendingRetransmissions());
+  VerifyRetransmittablePackets(NULL, 0);
+}
+
 TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   RetransmitAndSendPacket(2, 3);
   RetransmitAndSendPacket(3, 4);
   RetransmitAndSendPacket(4, 5);
 
   // Truncated ack with 4 NACKs, so the first packet is lost.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 4;
@@ skipping 803 matching lines @@
     delay = delay.Add(delay);
     EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
     manager_.OnRetransmissionTimeout();
     RetransmitNextPacket(i + 2);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net