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 14 matching lines @@
 };
 
 class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
  protected:
   QuicSentPacketManagerTest()
       : manager_(true, &helper_, &clock_, kFixRate),
         send_algorithm_(new StrictMock<MockSendAlgorithm>) {
     QuicSentPacketManagerPeer::SetSendAlgorithm(&manager_, send_algorithm_);
     // Disable tail loss probes for most tests.
     QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 0);
+    // Advance the time 1s so the send times are never QuicTime::Zero.
+    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
   }
 
   ~QuicSentPacketManagerTest() {
     STLDeleteElements(&packets_);
   }
 
   void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
                             size_t num_packets) {
     if (num_packets == 0) {
       EXPECT_FALSE(manager_.HasUnackedPackets());
@@ skipping 190 matching lines @@
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // No unacked packets remain.
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   SendDataPacket(1);
   RetransmitPacket(1, 2);
+  QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
+  clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2.
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _, _));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
-  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
 
   // 2 remains unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   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);
+  QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
+  clock_.AdvanceTime(rtt);
 
   // First, ACK packet 1 which makes packet 2 non-retransmittable.
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _, _));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
-  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
 
   SendDataPacket(3);
   SendDataPacket(4);
   SendDataPacket(5);
+  clock_.AdvanceTime(rtt);
+
   // 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()));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
 
   received_info.largest_observed = 4;
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _, _));
-  EXPECT_TRUE(manager_.OnIncomingAck(received_info, QuicTime::Zero()));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
 
   received_info.largest_observed = 5;
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _, _));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
+  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()));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
 
   // No packets remain unacked.
   VerifyUnackedPackets(NULL, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   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()));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(QuicTime::Delta::Zero()));
+  EXPECT_TRUE(manager_.OnIncomingAck(received_info, clock_.ApproximateNow()));
 
   // Since 2 was marked for retransmit, when 1 is acked, 2 is discarded.
   VerifyUnackedPackets(NULL, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   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);
+  QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
+  clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2 or 3.
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _, _));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(rtt));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
-  manager_.OnIncomingAck(received_info, QuicTime::Zero());
+  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
 
   // 3 remains unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   VerifyRetransmittablePackets(NULL, 0);
 
   // Verify that the retransmission alarm would not fire to abandon packet 3.
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
 }
@@ skipping 284 matching lines @@
   }
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
 
   // Nack the first packet 3 times with increasing largest observed.
   ReceivedPacketInfo received_info;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   received_info.missing_packets.insert(1);
   for (QuicPacketSequenceNumber i = 1; i <= 3; ++i) {
     received_info.largest_observed = i + 1;
-    EXPECT_CALL(*send_algorithm_, OnPacketAcked(i + 1, _, _)).Times(1);
+    EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+    EXPECT_CALL(*send_algorithm_, OnPacketAcked(i + 1, _)).Times(1);
     if (i == 3) {
       EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
       EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
     }
     manager_.OnIncomingAck(received_info, clock_.Now());
     EXPECT_EQ(
         i == 3 ? 1u : 0u,
         QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
     EXPECT_EQ(i, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
   }
 }
 
 // A stretch ack is an ack that covers more than 1 packet of previously
 // unacknowledged data.
 TEST_F(QuicSentPacketManagerTest, NackRetransmit1PacketWith1StretchAck) {
   const size_t kNumSentPackets = 4;
   // Transmit 4 packets.
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   // Nack the first packet 3 times in a single StretchAck.
   ReceivedPacketInfo received_info;
   received_info.delta_time_largest_observed =
         QuicTime::Delta::FromMilliseconds(5);
   received_info.missing_packets.insert(1);
   received_info.largest_observed = kNumSentPackets;
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(3);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(3);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(
       1u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
   EXPECT_EQ(3u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
 }
 
 // Ack a packet 3 packets ahead, causing a retransmit.
 TEST_F(QuicSentPacketManagerTest, NackRetransmit1PacketSingleAck) {
   const size_t kNumSentPackets = 5;
   // Transmit 5 packets.
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   // Nack the first packet 3 times in an AckFrame with three missing packets.
   ReceivedPacketInfo received_info;
   received_info.delta_time_largest_observed =
         QuicTime::Delta::FromMilliseconds(5);
   received_info.missing_packets.insert(1);
   received_info.missing_packets.insert(2);
   received_info.missing_packets.insert(3);
   received_info.largest_observed = 4;
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _, _)).Times(1);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(
       1u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
   EXPECT_EQ(3u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
 }
 
 TEST_F(QuicSentPacketManagerTest, EarlyRetransmit1Packet) {
   const size_t kNumSentPackets = 2;
   // Transmit 2 packets.
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   // Early retransmit when the final packet gets acked and the first is nacked.
   ReceivedPacketInfo received_info;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   received_info.missing_packets.insert(1);
   received_info.largest_observed = kNumSentPackets;
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(kNumSentPackets, _, _)).Times(1);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(kNumSentPackets, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(
       1u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
   EXPECT_EQ(1u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
 }
 
 TEST_F(QuicSentPacketManagerTest, DontEarlyRetransmitPacket) {
   const size_t kNumSentPackets = 5;
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   // Fast retransmit when the final packet gets acked, but don't early
   // retransmit as well, because there are 4 packets outstanding when the ack
   // arrives.
   ReceivedPacketInfo received_info;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   received_info.missing_packets.insert(1);
   received_info.missing_packets.insert(2);
   received_info.missing_packets.insert(3);
   received_info.missing_packets.insert(4);
   received_info.largest_observed = kNumSentPackets;
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _, _)).Times(1);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(
       2u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
   EXPECT_EQ(4u, QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
 }
 
 TEST_F(QuicSentPacketManagerTest, NackRetransmit2Packets) {
   const size_t kNumSentPackets = 20;
   // Transmit 20 packets.
   for (QuicPacketSequenceNumber i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   // Nack the first 19 packets 3 times.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = kNumSentPackets;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   for (size_t i = 1; i < kNumSentPackets; ++i) {
     received_info.missing_packets.insert(i);
   }
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_,
-              OnPacketAcked(kNumSentPackets, _, _)).Times(1);
+              OnPacketAcked(kNumSentPackets, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(
       2u, QuicSentPacketManagerPeer::GetPendingRetransmissionCount(&manager_));
   for (size_t i = 1; i < kNumSentPackets; ++i) {
     EXPECT_EQ(kNumSentPackets - i,
               QuicSentPacketManagerPeer::GetNackCount(&manager_, i));
   }
 }
@@ skipping 49 matching lines @@
   // Nack the first packet 2 times, then ack it.
   ReceivedPacketInfo received_info;
   received_info.missing_packets.insert(1);
   for (size_t i = 1; i <= 3; ++i) {
     if (i == 3) {
       received_info.missing_packets.clear();
     }
     received_info.largest_observed = i + 1;
     received_info.delta_time_largest_observed =
         QuicTime::Delta::FromMilliseconds(5);
+    EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
     EXPECT_CALL(*send_algorithm_,
-                OnPacketAcked(_, _, _)).Times(i == 3 ? 2 : 1);
+                OnPacketAcked(_, _)).Times(i == 3 ? 2 : 1);
     manager_.OnIncomingAck(received_info, clock_.Now());
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
     // The nack count remains at 2 when the packet is acked.
     EXPECT_EQ(i == 3 ? 2u : i,
               QuicSentPacketManagerPeer::GetNackCount(&manager_, 1));
   }
 }
 
 TEST_F(QuicSentPacketManagerTest, Rtt) {
   QuicPacketSequenceNumber sequence_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(15);
   SendDataPacket(sequence_number);
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(20));
 
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
   EXPECT_CALL(*send_algorithm_,
-              OnPacketAcked(sequence_number, _, expected_rtt)).Times(1);
+              OnPacketAcked(sequence_number, _)).Times(1);
   ReceivedPacketInfo received_info;
   received_info.largest_observed = sequence_number;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, RttWithInvalidDelta) {
   // Expect that the RTT is equal to the local time elapsed, since the
   // delta_time_largest_observed is larger than the local time elapsed
   // and is hence invalid.
   QuicPacketSequenceNumber sequence_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
   SendDataPacket(sequence_number);
   clock_.AdvanceTime(expected_rtt);
 
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
   EXPECT_CALL(*send_algorithm_,
-              OnPacketAcked(sequence_number, _, expected_rtt)).Times(1);
+              OnPacketAcked(sequence_number, _)).Times(1);
   ReceivedPacketInfo received_info;
   received_info.largest_observed = sequence_number;
   received_info.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(11);
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, RttWithInfiniteDelta) {
   // Expect that the RTT is equal to the local time elapsed, since the
   // delta_time_largest_observed is infinite, and is hence invalid.
   QuicPacketSequenceNumber sequence_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
   SendDataPacket(sequence_number);
   clock_.AdvanceTime(expected_rtt);
 
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
   EXPECT_CALL(*send_algorithm_,
-              OnPacketAcked(sequence_number, _, expected_rtt)).Times(1);
+              OnPacketAcked(sequence_number, _)).Times(1);
   ReceivedPacketInfo received_info;
   received_info.largest_observed = sequence_number;
   received_info.delta_time_largest_observed = QuicTime::Delta::Infinite();
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, RttZeroDelta) {
   // Expect that the RTT is the time between send and receive since the
   // delta_time_largest_observed is zero.
   QuicPacketSequenceNumber sequence_number = 1;
   QuicTime::Delta expected_rtt = QuicTime::Delta::FromMilliseconds(10);
   SendDataPacket(sequence_number);
   clock_.AdvanceTime(expected_rtt);
 
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _, expected_rtt))
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(expected_rtt));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(sequence_number, _))
       .Times(1);
   ReceivedPacketInfo received_info;
   received_info.largest_observed = sequence_number;
   received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
   manager_.OnIncomingAck(received_info, clock_.Now());
   EXPECT_EQ(expected_rtt, QuicSentPacketManagerPeer::rtt(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeout) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
 
   // Send 1 packet.
   QuicPacketSequenceNumber sequence_number = 1;
   SendDataPacket(sequence_number);
 
   // The first tail loss probe retransmits 1 packet.
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(2);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // The second tail loss probe retransmits 1 packet.
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(3);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack the third and ensure the first two are considered lost, but they were
   // already abandoned, so that won't occur again.
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _, _));
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 3;
   received_info.missing_packets.insert(1);
   received_info.missing_packets.insert(2);
   manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 }
@@ skipping 49 matching lines @@
   // The second retransmits 2 packets.
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(2);
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(8);
   RetransmitNextPacket(9);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
 
   // Now ack the two crypto packets and the speculatively encrypted request,
   // and ensure the first four crypto packets get abandoned, but not lost.
-  EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _, _)).Times(5);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(5);
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 9;
   received_info.missing_packets.insert(1);
   received_info.missing_packets.insert(2);
   received_info.missing_packets.insert(6);
   received_info.missing_packets.insert(7);
   manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
 
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
 }
@@ skipping 127 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   clock_.AdvanceTime(expected_rto_delay);
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(3);
   RetransmitNextPacket(4);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // The delay should double the second time.
   expected_time = clock_.Now().Add(expected_rto_delay).Add(expected_rto_delay);
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
+
+  // Ack a packet and ensure the RTO goes back to the original value.
+  ReceivedPacketInfo received_info;
+  received_info.largest_observed = 2;
+  received_info.missing_packets.insert(1);
+  EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
+  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+
+  expected_time = clock_.Now().Add(expected_rto_delay);
+  EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionDelayMin) {
   EXPECT_CALL(*send_algorithm_, RetransmissionDelay())
       .WillOnce(Return(QuicTime::Delta::FromMilliseconds(1)));
 
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(200),
             QuicSentPacketManagerPeer::GetRetransmissionDelay(&manager_));
 }
 
@@ skipping 18 matching lines @@
     delay = delay.Add(delay);
     EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
     manager_.OnRetransmissionTimeout();
     RetransmitNextPacket(i + 2);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net