Land Recent QUIC Changes.

net/quic/quic_connection_test.cc

 // Copyright (c) 2012 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_connection.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 389 matching lines @@
 class TestConnection : public QuicConnection {
  public:
   TestConnection(QuicConnectionId connection_id,
                  IPEndPoint address,
                  TestConnectionHelper* helper,
                  TestPacketWriter* writer,
                  bool is_server,
                  QuicVersion version)
       : QuicConnection(connection_id, address, helper, writer, is_server,
                        SupportedVersions(version)),
-        helper_(helper),
         writer_(writer) {
     // Disable tail loss probes for most tests.
     QuicSentPacketManagerPeer::SetMaxTailLossProbes(
         QuicConnectionPeer::GetSentPacketManager(this), 0);
     writer_->set_is_server(is_server);
   }
 
   void SendAck() {
     QuicConnectionPeer::SendAck(this);
   }
@@ skipping 104 matching lines @@
   }
 
   TestConnectionHelper::TestAlarm* GetTimeoutAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetTimeoutAlarm(this));
   }
 
   using QuicConnection::SelectMutualVersion;
 
  private:
-  TestConnectionHelper* helper_;
   TestPacketWriter* writer_;
 
   DISALLOW_COPY_AND_ASSIGN(TestConnection);
 };
 
 class QuicConnectionTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicConnectionTest()
       : connection_id_(42),
         framer_(SupportedVersions(version()), QuicTime::Zero(), false),
@@ skipping 17 matching lines @@
         *send_algorithm_, TimeUntilSend(_, _, _, _)).WillRepeatedly(Return(
             QuicTime::Delta::Zero()));
     EXPECT_CALL(*receive_algorithm_,
                 RecordIncomingPacket(_, _, _)).Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
         .Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_, RetransmissionDelay()).WillRepeatedly(
         Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillRepeatedly(Return(
         QuicBandwidth::FromKBitsPerSecond(100)));
-    EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillRepeatedly(Return(
-        QuicTime::Delta::FromMilliseconds(100)));
     ON_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
         .WillByDefault(Return(true));
     EXPECT_CALL(visitor_, HasPendingWrites()).Times(AnyNumber());
     EXPECT_CALL(visitor_, HasPendingHandshake()).Times(AnyNumber());
     EXPECT_CALL(visitor_, OnCanWrite()).Times(AnyNumber());
 
     EXPECT_CALL(*loss_algorithm_, GetLossTimeout())
         .WillRepeatedly(Return(QuicTime::Zero()));
-    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+    EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
         .WillRepeatedly(Return(SequenceNumberSet()));
   }
 
   QuicVersion version() {
     return GetParam();
   }
 
   QuicAckFrame* outgoing_ack() {
     outgoing_ack_.reset(QuicConnectionPeer::CreateAckFrame(&connection_));
     return outgoing_ack_.get();
@@ skipping 459 matching lines @@
 
   QuicAckFrame frame = InitAckFrame(num_packets, 1);
   SequenceNumberSet lost_packets;
   // Create an ack with 256 nacks, none adjacent to one another.
   for (QuicPacketSequenceNumber i = 1; i <= 256; ++i) {
     NackPacket(i * 2, &frame);
     if (i < 256) {  // Last packet is nacked, but not lost.
       lost_packets.insert(i * 2);
     }
   }
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(entropy_calculator_,
               EntropyHash(511)).WillOnce(testing::Return(0));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(256);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(255);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(255);
   ProcessAckPacket(&frame);
 
   QuicReceivedPacketManager* received_packet_manager =
       QuicConnectionPeer::GetReceivedPacketManager(&connection_);
   // A truncated ack will not have the true largest observed.
   EXPECT_GT(num_packets,
             received_packet_manager->peer_largest_observed_packet());
 
   AckPacket(192, &frame);
 
   // Removing one missing packet allows us to ack 192 and one more range, but
   // 192 has already been declared lost, so it doesn't register as an ack.
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(1);
   ProcessAckPacket(&frame);
   EXPECT_EQ(num_packets,
             received_packet_manager->peer_largest_observed_packet());
 }
 
 TEST_P(QuicConnectionTest, AckReceiptCausesAckSendBadEntropy) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
@@ skipping 43 matching lines @@
   QuicByteCount packet_size;
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION, _))
       .WillOnce(DoAll(SaveArg<1>(&original), SaveArg<2>(&packet_size),
                       Return(true)));
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
   QuicAckFrame frame = InitAckFrame(original, 1);
   NackPacket(original, &frame);
   // First nack triggers early retransmit.
   SequenceNumberSet lost_packets;
   lost_packets.insert(1);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   QuicPacketSequenceNumber retransmission;
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, packet_size - kQuicVersionSize,
                            NACK_RETRANSMISSION, _))
       .WillOnce(DoAll(SaveArg<1>(&retransmission), Return(true)));
 
   ProcessAckPacket(&frame);
 
   QuicAckFrame frame2 = InitAckFrame(retransmission, 1);
   NackPacket(original, &frame2);
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _));
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
   ProcessAckPacket(&frame2);
 
   // Now if the peer sends an ack which still reports the retransmitted packet
   // as missing, that will bundle an ack with data after two acks in a row
   // indicate the high water mark needs to be raised.
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION,
                                              HAS_RETRANSMITTABLE_DATA));
   connection_.SendStreamDataWithString(3, "foo", 3, !kFin, NULL);
   // No ack sent.
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames()->size());
   writer_->Reset();
 
   // No more packet loss for the rest of the test.
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillRepeatedly(Return(SequenceNumberSet()));
   ProcessAckPacket(&frame2);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION,
                                              HAS_RETRANSMITTABLE_DATA));
   connection_.SendStreamDataWithString(3, "foo", 3, !kFin, NULL);
   // Ack bundled.
   if (version() > QUIC_VERSION_15) {
     EXPECT_EQ(3u, writer_->frame_count());
   } else {
     EXPECT_EQ(2u, writer_->frame_count());
@@ skipping 359 matching lines @@
   connection_.SendStreamDataWithString(3, "foo", 6, !kFin, NULL);
 
   QuicAckFrame ack_fec = InitAckFrame(5, 1);
   // Ack all data packets, but no fec packets.
   NackPacket(2, &ack_fec);
   NackPacket(4, &ack_fec);
 
   // Lose the first FEC packet and ack the three data packets.
   SequenceNumberSet lost_packets;
   lost_packets.insert(2);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(3);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
   ProcessAckPacket(&ack_fec);
 
   clock_.AdvanceTime(DefaultRetransmissionTime().Subtract(
       QuicTime::Delta::FromMilliseconds(1)));
 
@@ skipping 266 matching lines @@
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(1, _));
   QuicAckFrame ack_one = InitAckFrame(1, 0);
   ProcessAckPacket(&ack_one);
 
   // Lose a packet and ensure it triggers retransmission.
   QuicAckFrame nack_two = InitAckFrame(3, 0);
   NackPacket(2, &nack_two);
   SequenceNumberSet lost_packets;
   lost_packets.insert(2);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _));
   EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _)).Times(1);
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, second_packet_size - kQuicVersionSize,
                            NACK_RETRANSMISSION, _)).Times(1);
   ProcessAckPacket(&nack_two);
 }
 
 TEST_P(QuicConnectionTest, DiscardRetransmit) {
   QuicPacketSequenceNumber last_packet;
   SendStreamDataToPeer(1, "foo", 0, !kFin, &last_packet);  // Packet 1
   SendStreamDataToPeer(1, "foos", 3, !kFin, &last_packet);  // Packet 2
   SendStreamDataToPeer(1, "fooos", 7, !kFin, &last_packet);  // Packet 3
 
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Instigate a loss with an ack.
   QuicAckFrame nack_two = InitAckFrame(3, 0);
   NackPacket(2, &nack_two);
   // The first nack should trigger a fast retransmission, but we'll be
   // write blocked, so the packet will be queued.
   BlockOnNextWrite();
   SequenceNumberSet lost_packets;
   lost_packets.insert(2);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(2);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
   ProcessAckPacket(&nack_two);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Now, ack the previous transmission.
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
   QuicAckFrame ack_all = InitAckFrame(3, 0);
   ProcessAckPacket(&ack_all);
 
   // Unblock the socket and attempt to send the queued packets.  However,
   // since the previous transmission has been acked, we will not
   // send the retransmission.
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, _, _, _)).Times(0);
 
@@ skipping 10 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION, _))
       .WillOnce(DoAll(SaveArg<1>(&largest_observed), SaveArg<2>(&packet_size),
                       Return(true)));
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
 
   QuicAckFrame frame = InitAckFrame(1, largest_observed);
   NackPacket(largest_observed, &frame);
   // The first nack should retransmit the largest observed packet.
   SequenceNumberSet lost_packets;
   lost_packets.insert(1);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_,
               OnPacketSent(_, _, packet_size - kQuicVersionSize,
                            NACK_RETRANSMISSION, _));
   ProcessAckPacket(&frame);
 }
 
@@ skipping 103 matching lines @@
   // Ack 15, nack 1-14.
   SequenceNumberSet lost_packets;
   QuicAckFrame nack = InitAckFrame(15, 0);
   for (int i = 1; i < 15; ++i) {
     NackPacket(i, &nack);
     lost_packets.insert(i);
   }
 
   // 14 packets have been NACK'd and lost.  In TCP cubic, PRR limits
   // the retransmission rate in the case of burst losses.
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(15, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(_, _)).Times(14);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(14);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(14);
   ProcessAckPacket(&nack);
 }
 
 // Test sending multiple acks from the connection to the session.
@@ skipping 343 matching lines @@
   connection_.GetRetransmissionAlarm()->Fire();
   EXPECT_FALSE(QuicConnectionPeer::IsSavedForRetransmission(
       &connection_, original_sequence_number));
   ASSERT_TRUE(QuicConnectionPeer::IsSavedForRetransmission(
       &connection_, rto_sequence_number));
   EXPECT_TRUE(QuicConnectionPeer::IsRetransmission(
       &connection_, rto_sequence_number));
   // Once by explicit nack.
   SequenceNumberSet lost_packets;
   lost_packets.insert(rto_sequence_number);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(rto_sequence_number, _)).Times(1);
   EXPECT_CALL(*send_algorithm_,
               OnPacketAbandoned(rto_sequence_number, _)).Times(1);
   QuicPacketSequenceNumber nack_sequence_number = 0;
   // Ack packets might generate some other packets, which are not
   // retransmissions. (More ack packets).
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION, _))
       .Times(AnyNumber());
@@ skipping 27 matching lines @@
 }
 
 TEST_P(QuicConnectionTest, DelayRTOWithAckReceipt) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, NOT_RETRANSMISSION, _))
       .Times(2);
   connection_.SendStreamDataWithString(2, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, NULL);
   QuicAlarm* retransmission_alarm = connection_.GetRetransmissionAlarm();
   EXPECT_TRUE(retransmission_alarm->IsSet());
+  EXPECT_EQ(clock_.Now().Add(DefaultRetransmissionTime()),
+            retransmission_alarm->deadline());
 
   // Advance the time right before the RTO, then receive an ack for the first
   // packet to delay the RTO.
   clock_.AdvanceTime(DefaultRetransmissionTime());
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(1);
   QuicAckFrame ack = InitAckFrame(1, 0);
   ProcessAckPacket(&ack);
   EXPECT_TRUE(retransmission_alarm->IsSet());
+  EXPECT_GT(retransmission_alarm->deadline(), clock_.Now());
 
   // Move forward past the original RTO and ensure the RTO is still pending.
-  clock_.AdvanceTime(DefaultRetransmissionTime());
+  clock_.AdvanceTime(DefaultRetransmissionTime().Multiply(2));
 
   // Ensure the second packet gets retransmitted when it finally fires.
   EXPECT_TRUE(retransmission_alarm->IsSet());
   EXPECT_LT(retransmission_alarm->deadline(), clock_.ApproximateNow());
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, RTO_RETRANSMISSION, _));
   // Manually cancel the alarm to simulate a real test.
   connection_.GetRetransmissionAlarm()->Fire();
 
   // The new retransmitted sequence number should set the RTO to a larger value
@@ skipping 437 matching lines @@
 
 TEST_P(QuicConnectionTest, BundleAckWithDataOnIncomingAck) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   connection_.SendStreamDataWithString(kStreamId3, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(kStreamId3, "foo", 3, !kFin, NULL);
   // Ack the second packet, which will retransmit the first packet.
   QuicAckFrame ack = InitAckFrame(2, 0);
   NackPacket(1, &ack);
   SequenceNumberSet lost_packets;
   lost_packets.insert(1);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(2, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _)).Times(1);
   ProcessAckPacket(&ack);
   EXPECT_EQ(1u, writer_->frame_count());
   EXPECT_EQ(1u, writer_->stream_frames()->size());
   writer_->Reset();
 
   // Now ack the retransmission, which will both raise the high water mark
   // and see if there is more data to send.
   ack = InitAckFrame(3, 0);
   NackPacket(1, &ack);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(3, _)).Times(1);
   ProcessAckPacket(&ack);
 
   // Check that no packet is sent and the ack alarm isn't set.
   EXPECT_EQ(0u, writer_->frame_count());
   EXPECT_FALSE(connection_.GetAckAlarm()->IsSet());
   writer_->Reset();
 
   // Send the same ack, but send both data and an ack together.
   ack = InitAckFrame(3, 0);
   NackPacket(1, &ack);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
   EXPECT_CALL(visitor_, OnCanWrite()).WillOnce(
       IgnoreResult(InvokeWithoutArgs(
           &connection_,
           &TestConnection::EnsureWritableAndSendStreamData5)));
   ProcessAckPacket(&ack);
 
   // Check that ack is bundled with outgoing data and the delayed ack
   // alarm is reset.
   if (version() > QUIC_VERSION_15) {
@@ skipping 438 matching lines @@
   clock_.AdvanceTime(QuicTime::Delta::FromSeconds(10));
   connection_.GetRetransmissionAlarm()->Fire();
 
   // Retransmit due to explicit nacks.
   QuicAckFrame nack_three = InitAckFrame(4, 0);
   NackPacket(3, &nack_three);
   NackPacket(1, &nack_three);
   SequenceNumberSet lost_packets;
   lost_packets.insert(1);
   lost_packets.insert(3);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(4, _)).Times(1);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(_, _)).Times(2);
   EXPECT_CALL(visitor_, OnCanWrite()).Times(2);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessAckPacket(&nack_three);
 
-  EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillOnce(
-      Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillOnce(
       Return(QuicBandwidth::Zero()));
 
   const QuicConnectionStats& stats = connection_.GetStats();
   EXPECT_EQ(3 * first_packet_size + 2 * second_packet_size - kQuicVersionSize,
             stats.bytes_sent);
   EXPECT_EQ(5u, stats.packets_sent);
   EXPECT_EQ(2 * first_packet_size + second_packet_size - kQuicVersionSize,
             stats.bytes_retransmitted);
   EXPECT_EQ(3u, stats.packets_retransmitted);
   EXPECT_EQ(1u, stats.rto_count);
 }
 
 TEST_P(QuicConnectionTest, CheckReceiveStats) {
   if (version() < QUIC_VERSION_15) {
     return;
   }
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   size_t received_bytes = 0;
   received_bytes += ProcessFecProtectedPacket(1, false, !kEntropyFlag);
   received_bytes += ProcessFecProtectedPacket(3, false, !kEntropyFlag);
   // Should be counted against dropped packets.
   received_bytes += ProcessDataPacket(3, 1, !kEntropyFlag);
   received_bytes += ProcessFecPacket(4, 1, true, !kEntropyFlag, NULL);
 
-  EXPECT_CALL(*send_algorithm_, SmoothedRtt()).WillOnce(
-      Return(QuicTime::Delta::Zero()));
   EXPECT_CALL(*send_algorithm_, BandwidthEstimate()).WillOnce(
       Return(QuicBandwidth::Zero()));
 
   const QuicConnectionStats& stats = connection_.GetStats();
   EXPECT_EQ(received_bytes, stats.bytes_received);
   EXPECT_EQ(4u, stats.packets_received);
 
   EXPECT_EQ(1u, stats.packets_revived);
   EXPECT_EQ(1u, stats.packets_dropped);
 }
@@ skipping 175 matching lines @@
   // Send some other data which we will ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(1, "bar", 0, !kFin, NULL);
 
   // Now we receive ACK for packets 2 and 3, but importantly missing packet 1
   // which we registered to be notified about.
   QuicAckFrame frame = InitAckFrame(3, 0);
   NackPacket(1, &frame);
   SequenceNumberSet lost_packets;
   lost_packets.insert(1);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _));
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterRetransmission) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a delegate which we expect to be called.
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
   EXPECT_CALL(*delegate, OnAckNotification()).Times(1);
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, delegate.get());
   connection_.SendStreamDataWithString(3, "baz", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(3, "qux", 0, !kFin, NULL);
 
   // Now we receive ACK for packets 1, 3, and 4 and lose 2.
   QuicAckFrame frame = InitAckFrame(4, 0);
   NackPacket(2, &frame);
   SequenceNumberSet lost_packets;
   lost_packets.insert(2);
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(lost_packets));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(3);
   EXPECT_CALL(*send_algorithm_, OnPacketLost(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(2, _));
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _));
   ProcessAckPacket(&frame);
 
   // Now we get an ACK for packet 5 (retransmitted packet 2), which should
   // trigger the callback.
-  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _, _))
+  EXPECT_CALL(*loss_algorithm_, DetectLostPackets(_, _, _, _))
       .WillRepeatedly(Return(SequenceNumberSet()));
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(5, _));
   QuicAckFrame second_ack_frame = InitAckFrame(5, 0);
   ProcessAckPacket(&second_ack_frame);
 }
 
 // TODO(rjshade): Add a similar test that FEC recovery on peer (and resulting
 //                ACK) triggers notification on our end.
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterFECRecovery) {
@@ skipping 140 matching lines @@
   QuicBlockedFrame blocked;
   blocked.stream_id = 3;
   EXPECT_CALL(visitor_, OnBlockedFrames(_));
   ProcessFramePacket(QuicFrame(&blocked));
   EXPECT_TRUE(ack_alarm->IsSet());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net