QUIC change to invoke SetNotPending for retransmissions in

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_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 98 matching lines @@
     vector<QuicPacketSequenceNumber> lost_vector;
     for (size_t i = 0; i < num_packets_lost; ++i) {
       lost_vector.push_back(packets_lost[i]);
     }
     EXPECT_CALL(*send_algorithm_,
                 OnCongestionEvent(rtt_updated, _,
                                   Pointwise(KeyEq(), ack_vector),
                                   Pointwise(KeyEq(), lost_vector)));
   }
 
+  // Retransmits a packet as though it was a TLP retransmission, because TLP
+  // leaves the |old_sequence_number| pending.
+  // TODO(ianswett): Test with transmission types besides TLP.
   void RetransmitPacket(QuicPacketSequenceNumber old_sequence_number,
                         QuicPacketSequenceNumber new_sequence_number) {
     QuicSentPacketManagerPeer::MarkForRetransmission(
-        &manager_, old_sequence_number, LOSS_RETRANSMISSION);
+        &manager_, old_sequence_number, TLP_RETRANSMISSION);
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
     QuicSentPacketManager::PendingRetransmission next_retransmission =
         manager_.NextPendingRetransmission();
     EXPECT_EQ(old_sequence_number, next_retransmission.sequence_number);
-    EXPECT_EQ(LOSS_RETRANSMISSION,
+    EXPECT_EQ(TLP_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);
 
@@ skipping 142 matching lines @@
   // Packet 1 is unacked, pending, but not retransmittable.
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   VerifyRetransmittablePackets(NULL, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
   SendDataPacket(1);
   QuicSentPacketManagerPeer::MarkForRetransmission(
-      &manager_, 1, LOSS_RETRANSMISSION);
+      &manager_, 1, TLP_RETRANSMISSION);
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
 
   // Ack 1.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
   ExpectAck(1);
   manager_.OnIncomingAck(received_info, clock_.Now());
 
   // There should no longer be a pending retransmission.
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
@@ skipping 889 matching lines @@
 
   EXPECT_EQ(kTime,
             QuicSentPacketManagerPeer::GetLossAlgorithm(
                 &manager_)->GetLossDetectionType());
 }
 
 
 }  // namespace
 }  // namespace test
 }  // namespace net