Land Recent QUIC Changes.

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 23 matching lines @@
 
   ~QuicSentPacketManagerTest() {
     STLDeleteElements(&packets_);
   }
 
   void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
                             size_t num_packets) {
     if (num_packets == 0) {
       EXPECT_FALSE(manager_.HasUnackedPackets());
       EXPECT_EQ(0u, manager_.GetNumRetransmittablePackets());
-      EXPECT_FALSE(manager_.HasUnackedPackets());
       return;
     }
 
     EXPECT_TRUE(manager_.HasUnackedPackets());
     EXPECT_EQ(packets[0], manager_.GetLeastUnackedSentPacket());
     for (size_t i = 0; i < num_packets; ++i) {
       EXPECT_TRUE(manager_.IsUnacked(packets[i])) << packets[i];
     }
   }
 
@@ skipping 51 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);
+    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);
 
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
 
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 1 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   RetransmitPacket(1, 2);
 
   EXPECT_TRUE(QuicSentPacketManagerPeer::IsRetransmission(&manager_, 2));
   QuicPacketSequenceNumber unacked[] = { 1, 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 2 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   RetransmitPacket(1, 2);
 
   // Ack 2 but not 1.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 2;
   received_info.missing_packets.insert(1);
-  EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(3u));
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
   // No unacked packets remain.
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   QuicSentPacketManagerPeer::MarkForRetransmission(
       &manager_, 1, NACK_RETRANSMISSION);
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
 
   // Ack 1.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
-  EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(2u));
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
   // There should no longer be a pending retransmission.
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // No unacked packets remain.
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   RetransmitPacket(1, 2);
 
   // 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.
+  EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
+      .WillOnce(Return(QuicTime::Delta::FromMilliseconds(1)));
+  manager_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitTwiceThenAckFirst) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   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.
+  EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
+      .WillOnce(Return(QuicTime::Delta::FromMilliseconds(1)));
+  manager_.OnRetransmissionTimeout();
 }
 
 TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   RetransmitPacket(1, 2);
   RetransmitPacket(2, 3);
   RetransmitPacket(3, 4);
 
   // Truncated ack with 2 NACKs
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 2;
   received_info.missing_packets.insert(1);
   received_info.missing_packets.insert(2);
   received_info.is_truncated = true;
-  EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(5u));
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
   // High water mark will be raised.
   QuicPacketSequenceNumber unacked[] = { 2, 3, 4 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 4 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, SendDropAckRetransmitManyPackets) {
-  manager_.OnSerializedPacket(CreatePacket(1), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(2), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(3), QuicTime::Zero());
+  manager_.OnSerializedPacket(CreatePacket(1));
+  manager_.OnSerializedPacket(CreatePacket(2));
+  manager_.OnSerializedPacket(CreatePacket(3));
 
   {
     // Ack packets 1 and 3.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 3;
     received_info.missing_packets.insert(2);
-    EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(4u));
     manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
     QuicPacketSequenceNumber unacked[] = { 2 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 2 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 
-  manager_.OnSerializedPacket(CreatePacket(4), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(5), QuicTime::Zero());
+  manager_.OnSerializedPacket(CreatePacket(4));
+  manager_.OnSerializedPacket(CreatePacket(5));
 
   {
     // Ack packets 5.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 5;
     received_info.missing_packets.insert(2);
     received_info.missing_packets.insert(4);
-    EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(6u));
     manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
     QuicPacketSequenceNumber unacked[] = { 2, 4 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 2, 4 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 
-  manager_.OnSerializedPacket(CreatePacket(6), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(7), QuicTime::Zero());
+  manager_.OnSerializedPacket(CreatePacket(6));
+  manager_.OnSerializedPacket(CreatePacket(7));
 
   {
     // Ack packets 7.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 7;
     received_info.missing_packets.insert(2);
     received_info.missing_packets.insert(4);
     received_info.missing_packets.insert(6);
-    EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(8u));
     manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
     QuicPacketSequenceNumber unacked[] = { 2, 4, 6 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 2, 4, 6 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 
   RetransmitPacket(2, 8);
-  manager_.OnSerializedPacket(CreatePacket(9), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(10), QuicTime::Zero());
+  manager_.OnSerializedPacket(CreatePacket(9));
+  manager_.OnSerializedPacket(CreatePacket(10));
 
   {
     // Ack packet 10.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 10;
     received_info.missing_packets.insert(2);
     received_info.missing_packets.insert(4);
     received_info.missing_packets.insert(6);
     received_info.missing_packets.insert(8);
     received_info.missing_packets.insert(9);
-    EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(11u));
     manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
     QuicPacketSequenceNumber unacked[] = { 2, 4, 6, 8, 9 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 4, 6, 8, 9 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 
 
   RetransmitPacket(4, 11);
-  manager_.OnSerializedPacket(CreatePacket(12), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(13), QuicTime::Zero());
+  manager_.OnSerializedPacket(CreatePacket(12));
+  manager_.OnSerializedPacket(CreatePacket(13));
 
   {
     // Ack packet 13.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 13;
     received_info.missing_packets.insert(2);
     received_info.missing_packets.insert(4);
     received_info.missing_packets.insert(6);
     received_info.missing_packets.insert(8);
     received_info.missing_packets.insert(9);
     received_info.missing_packets.insert(11);
     received_info.missing_packets.insert(12);
-    EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(14u));
     manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
     QuicPacketSequenceNumber unacked[] = { 2, 4, 6, 8, 9, 11, 12 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 6, 8, 9, 11, 12 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 
   RetransmitPacket(6, 14);
-  manager_.OnSerializedPacket(CreatePacket(15), QuicTime::Zero());
-  manager_.OnSerializedPacket(CreatePacket(16), QuicTime::Zero());
+  manager_.OnSerializedPacket(CreatePacket(15));
+  manager_.OnSerializedPacket(CreatePacket(16));
 
   {
     // Ack packet 16.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 13;
     received_info.missing_packets.insert(2);
     received_info.missing_packets.insert(4);
     received_info.missing_packets.insert(6);
     received_info.missing_packets.insert(8);
     received_info.missing_packets.insert(9);
     received_info.missing_packets.insert(11);
     received_info.missing_packets.insert(12);
     received_info.is_truncated = true;
-    EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(17u));
     manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
     // Truncated ack raises the high water mark by clearing out 2, 4, and 6.
     QuicPacketSequenceNumber unacked[] = { 8, 9, 11, 12, 14, 15, 16 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 8, 9, 11, 12, 14, 15, 16 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) {
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(1u));
   EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnacked) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnackedFec) {
   SerializedPacket serialized_packet(CreateFecPacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
-  // FEC packets do not count as "unacked".
-  EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(2u));
-  EXPECT_EQ(2u, manager_.GetLeastUnackedSentPacket());
+  manager_.OnSerializedPacket(serialized_packet);
+  EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketDiscardUnacked) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
   manager_.DiscardUnackedPacket(1u);
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(2u));
   EXPECT_EQ(2u, manager_.GetLeastUnackedSentPacket());
 }
 
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedFecPacketAndDiscard) {
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedPacketAndDiscard) {
   VerifyUnackedPackets(NULL, 0);
 
   SerializedPacket serialized_packet(CreateFecPacket(1));
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
-  EXPECT_EQ(1u, manager_.GetLeastUnackedFecPacket());
+  manager_.OnSerializedPacket(serialized_packet);
+  EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 
   SerializedPacket serialized_packet2(CreateFecPacket(2));
-  manager_.OnSerializedPacket(serialized_packet2, QuicTime::Zero());
-  EXPECT_EQ(1u, manager_.GetLeastUnackedFecPacket());
+  manager_.OnSerializedPacket(serialized_packet2);
+  EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 
   SerializedPacket serialized_packet3(CreateFecPacket(3));
-  manager_.OnSerializedPacket(serialized_packet3, QuicTime::Zero());
-  EXPECT_EQ(1u, manager_.GetLeastUnackedFecPacket());
+  manager_.OnSerializedPacket(serialized_packet3);
+  EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 
-  VerifyUnackedPackets(NULL, 0);
+  QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
+  VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
 
-  manager_.DiscardFecPacket(1);
-  EXPECT_EQ(2u, manager_.GetLeastUnackedFecPacket());
+  manager_.DiscardUnackedPacket(1);
+  EXPECT_EQ(2u, manager_.GetLeastUnackedSentPacket());
 
   // Ack 2.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 2;
-  EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(4u));
   manager_.OnIncomingAck(received_info, QuicTime::Zero());
 
-  EXPECT_EQ(3u, manager_.GetLeastUnackedFecPacket());
+  EXPECT_EQ(3u, manager_.GetLeastUnackedSentPacket());
 
   // Discard the 3rd packet and ensure there are no FEC packets.
-  manager_.DiscardFecPacket(3);
-  EXPECT_FALSE(manager_.HasUnackedFecPackets());
+  manager_.DiscardUnackedPacket(3);
+  EXPECT_FALSE(manager_.HasUnackedPackets());
 }
 
-TEST_F(QuicSentPacketManagerTest, GetFecSentTime) {
+TEST_F(QuicSentPacketManagerTest, GetSentTime) {
   VerifyUnackedPackets(NULL, 0);
 
   SerializedPacket serialized_packet(CreateFecPacket(1));
-  manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
+  manager_.OnSerializedPacket(serialized_packet);
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 1, _, _, _))
+                  .Times(1).WillOnce(Return(true));
+  manager_.OnPacketSent(
+      1, QuicTime::Zero(), 0, NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   SerializedPacket serialized_packet2(CreateFecPacket(2));
   QuicTime sent_time = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(1));
-  manager_.OnSerializedPacket(serialized_packet2, sent_time);
+  manager_.OnSerializedPacket(serialized_packet2);
+  EXPECT_CALL(*send_algorithm_, OnPacketSent(_, 2, _, _, _))
+                  .Times(1).WillOnce(Return(true));
+  manager_.OnPacketSent(
+      2, sent_time, 0, NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
 
-  VerifyUnackedPackets(NULL, 0);
+  QuicPacketSequenceNumber unacked[] = { 1, 2 };
+  VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
 
-  EXPECT_TRUE(manager_.HasUnackedFecPackets());
-  EXPECT_EQ(QuicTime::Zero(), manager_.GetFecSentTime(1));
-  EXPECT_EQ(sent_time, manager_.GetFecSentTime(2));
+  EXPECT_TRUE(manager_.HasUnackedPackets());
+  EXPECT_EQ(QuicTime::Zero(),
+            QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
+  EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
 }
 
 TEST_F(QuicSentPacketManagerTest, NackRetransmit1Packet) {
   const size_t kNumSentPackets = 4;
   // Transmit 4 packets.
   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);
@@ skipping 314 matching lines @@
   received_info.largest_observed = sequence_number;
   received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
   manager_.OnIncomingAckFrame(received_info, clock_.Now());
   EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
 }
 
 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);
+    SendDataPacket(i);
   }
 
-  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(kNumSentPackets);
 
+  EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
+      .WillOnce(Return(QuicTime::Delta::FromMilliseconds(1)));
+  EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout());
   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));
+      .WillOnce(Return(QuicTime::Delta::FromMilliseconds(1)));
 
-  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));
+      .WillOnce(Return(QuicTime::Delta::FromSeconds(500)));
 
-  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