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/quic_flags.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
@@ skipping 26 matching lines @@
 class MockDebugDelegate : public QuicSentPacketManager::DebugDelegate {
  public:
   MOCK_METHOD2(OnSpuriousPacketRetransmition,
                void(TransmissionType transmission_type,
                     QuicByteCount byte_size));
 };
 
 class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
  protected:
   QuicSentPacketManagerTest()
-      : manager_(true, &clock_, &stats_, kFixRateCongestionControl, kNack),
+      : manager_(true, &clock_, &stats_, kCubic, kNack),
         send_algorithm_(new StrictMock<MockSendAlgorithm>),
         network_change_visitor_(new StrictMock<MockNetworkChangeVisitor>) {
     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));
     manager_.set_network_change_visitor(network_change_visitor_.get());
   }
 
@@ skipping 236 matching lines @@
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 2 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
 
   // Ack 2 but not 1.
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 2;
-  received_info.missing_packets.insert(1);
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 2;
+  ack_frame.missing_packets.insert(1);
   ExpectAck(2);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // 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, TLP_RETRANSMISSION);
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
 
   // Ack 1.
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 1;
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 1;
   ExpectAck(1);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // There should no longer be a pending retransmission.
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // No unacked packets remain.
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
   EXPECT_EQ(0u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   SendDataPacket(1);
   RetransmitPacket(1, 2);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2.
   ExpectAck(1);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 1;
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 1;
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // 2 should be unacked, since it may provide an RTT measurement.
   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());
   EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitAndSendThenAckPrevious) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2.
   ExpectAck(1);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 1;
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 1;
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // 2 remains unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   VerifyRetransmittablePackets(NULL, 0);
 
   EXPECT_EQ(1u, stats_.packets_spuriously_retransmitted);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPreviousThenNackRetransmit) {
   SendDataPacket(1);
   RetransmitPacket(1, 2);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 2, _, _))
       .WillOnce(Return(true));
   manager_.OnPacketSent(2, clock_.ApproximateNow(), kDefaultLength,
                         LOSS_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // First, ACK packet 1 which makes packet 2 non-retransmittable.
   ExpectAck(1);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 1;
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 1;
+  manager_.OnIncomingAck(ack_frame, 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);
+  ack_frame.largest_observed = 3;
+  ack_frame.missing_packets.insert(2);
   ExpectAck(3);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
-  received_info.largest_observed = 4;
+  ack_frame.largest_observed = 4;
   ExpectAck(4);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
-  received_info.largest_observed = 5;
+  ack_frame.largest_observed = 5;
   ExpectAckAndLoss(true, 5, 2);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, 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));
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange(_));
   EXPECT_CALL(*send_algorithm_, GetCongestionWindow())
       .WillOnce(Return(2 * kDefaultTCPMSS));
   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;
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 1;
   ExpectUpdatedRtt(1);
   EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // Since 2 was marked for retransmit, when 1 is acked, 2 is kept for RTT.
   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, RetransmitTwiceThenAckFirst) {
   StrictMock<MockDebugDelegate> debug_delegate;
   EXPECT_CALL(debug_delegate, OnSpuriousPacketRetransmition(
       TLP_RETRANSMISSION, kDefaultLength)).Times(2);
   manager_.set_debug_delegate(&debug_delegate);
 
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   RetransmitAndSendPacket(2, 3);
   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(15);
   clock_.AdvanceTime(rtt);
 
   // Ack 1 but not 2 or 3.
   ExpectAck(1);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 1;
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 1;
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   // 2 and 3 remain unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 2, 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   VerifyRetransmittablePackets(NULL, 0);
 
   // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
   SendDataPacket(4);
-  received_info.largest_observed = 4;
-  received_info.missing_packets.insert(2);
+  ack_frame.largest_observed = 4;
+  ack_frame.missing_packets.insert(2);
   QuicPacketSequenceNumber acked[] = { 3, 4 };
   ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   QuicPacketSequenceNumber unacked2[] = { 2 };
   VerifyUnackedPackets(unacked2, arraysize(unacked2));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   SendDataPacket(5);
-  received_info.largest_observed = 5;
+  ack_frame.largest_observed = 5;
   ExpectAckAndLoss(true, 5, 2);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   VerifyUnackedPackets(NULL, 0);
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   EXPECT_EQ(2u, 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);
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 3;
+  ack_frame.missing_packets.insert(1);
+  ack_frame.revived_packets.insert(1);
   QuicPacketSequenceNumber acked[] = { 2, 3 };
   ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, 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;
+  ack_frame.largest_observed = 4;
   ExpectAckAndLoss(true, 4, 1);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   VerifyRetransmittablePackets(NULL, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, MarkLostThenReviveAndDontRetransmitPacket) {
   SendDataPacket(1);
   SendDataPacket(2);
   SendDataPacket(3);
   SendDataPacket(4);
   SendFecPacket(5);
 
   // Ack 2, 3, and 4, and expect the 1st to be considered lost.
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 4;
-  received_info.missing_packets.insert(1);
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 4;
+  ack_frame.missing_packets.insert(1);
   QuicPacketSequenceNumber acked[] = { 2, 3, 4 };
   QuicPacketSequenceNumber lost[] = { 1 };
   ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost));
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   QuicPacketSequenceNumber unacked[] = { 1, 5 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 1 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 
   // Ack 5th packet (FEC) and revive 1st packet. 1st packet should now be
   // removed from pending retransmissions map.
-  received_info.largest_observed = 5;
-  received_info.revived_packets.insert(1);
+  ack_frame.largest_observed = 5;
+  ack_frame.revived_packets.insert(1);
   ExpectAck(5);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, 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;
-  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.is_truncated = true;
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 4;
+  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.insert(3);
+  ack_frame.missing_packets.insert(4);
+  ack_frame.is_truncated = true;
 
   QuicPacketSequenceNumber lost[] = { 1 };
   ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost));
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // High water mark will be raised.
   QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 5 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   RetransmitAndSendPacket(2, 3);
   RetransmitAndSendPacket(3, 4);
   manager_.OnSerializedPacket(CreateDataPacket(5));
   manager_.OnSerializedPacket(CreateDataPacket(6));
   manager_.OnSerializedPacket(CreateDataPacket(7));
   manager_.OnSerializedPacket(CreateDataPacket(8));
   manager_.OnSerializedPacket(CreateDataPacket(9));
 
   // Ack previous transmission
   {
-    ReceivedPacketInfo received_info;
-    received_info.largest_observed = 2;
-    received_info.missing_packets.insert(1);
+    QuicAckFrame ack_frame;
+    ack_frame.largest_observed = 2;
+    ack_frame.missing_packets.insert(1);
     ExpectAck(2);
-    manager_.OnIncomingAck(received_info, clock_.Now());
+    manager_.OnIncomingAck(ack_frame, clock_.Now());
     EXPECT_TRUE(manager_.IsUnacked(4));
   }
 
   // Truncated ack with 4 NACKs
   {
-    ReceivedPacketInfo received_info;
-    received_info.largest_observed = 6;
-    received_info.missing_packets.insert(3);
-    received_info.missing_packets.insert(4);
-    received_info.missing_packets.insert(5);
-    received_info.missing_packets.insert(6);
-    received_info.is_truncated = true;
+    QuicAckFrame ack_frame;
+    ack_frame.largest_observed = 6;
+    ack_frame.missing_packets.insert(3);
+    ack_frame.missing_packets.insert(4);
+    ack_frame.missing_packets.insert(5);
+    ack_frame.missing_packets.insert(6);
+    ack_frame.is_truncated = true;
     ExpectAckAndLoss(false, 1, 3);
-    manager_.OnIncomingAck(received_info, clock_.Now());
+    manager_.OnIncomingAck(ack_frame, clock_.Now());
   }
 
   // High water mark will be raised.
   QuicPacketSequenceNumber unacked[] = { 4, 5, 6, 7, 8, 9 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 5, 6, 7, 8, 9 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) {
@@ skipping 27 matching lines @@
 
   SerializedPacket serialized_packet3(CreateFecPacket(3));
   manager_.OnSerializedPacket(serialized_packet3);
   EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 
   QuicPacketSequenceNumber unacked[] = { 1, 2, 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
 
   // Ack 2, which has never been sent, so there's no rtt update.
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 2;
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 2;
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   EXPECT_EQ(3u, manager_.GetLeastUnackedSentPacket());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetSentTime) {
   VerifyUnackedPackets(NULL, 0);
 
   SerializedPacket serialized_packet(CreateFecPacket(1));
   manager_.OnSerializedPacket(serialized_packet);
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, 1, _, _))
@@ skipping 17 matching lines @@
   EXPECT_EQ(QuicTime::Zero(),
             QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
   EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
 }
 
 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
   SendDataPacket(1);
   SendAckPacket(2);
 
   // Now ack the ack and expect an RTT update.
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 2;
-  received_info.delta_time_largest_observed =
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 2;
+  ack_frame.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
 
   ExpectAck(1);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   SendAckPacket(3);
 
   // Now ack the ack and expect only an RTT update.
-  received_info.largest_observed = 3;
+  ack_frame.largest_observed = 3;
   ExpectUpdatedRtt(3);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 }
 
 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));
 
   ExpectAck(sequence_number);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = sequence_number;
-  received_info.delta_time_largest_observed =
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = sequence_number;
+  ack_frame.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(5);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
   EXPECT_EQ(expected_rtt,
             QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
 }
 
 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);
 
   ExpectAck(sequence_number);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = sequence_number;
-  received_info.delta_time_largest_observed =
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = sequence_number;
+  ack_frame.delta_time_largest_observed =
       QuicTime::Delta::FromMilliseconds(11);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
   EXPECT_EQ(expected_rtt,
             QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
 }
 
 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);
 
   ExpectAck(sequence_number);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = sequence_number;
-  received_info.delta_time_largest_observed = QuicTime::Delta::Infinite();
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = sequence_number;
+  ack_frame.delta_time_largest_observed = QuicTime::Delta::Infinite();
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
   EXPECT_EQ(expected_rtt,
             QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
 }
 
 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);
 
   ExpectAck(sequence_number);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = sequence_number;
-  received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = sequence_number;
+  ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
   EXPECT_EQ(expected_rtt,
             QuicSentPacketManagerPeer::GetRttStats(&manager_)->latest_rtt());
 }
 
 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeout) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
 
   // Send 1 packet.
   QuicPacketSequenceNumber sequence_number = 1;
   SendDataPacket(sequence_number);
@@ skipping 17 matching lines @@
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   RetransmitNextPacket(3);
   EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _)).WillOnce(Return(
       QuicTime::Delta::Infinite()));
   EXPECT_EQ(QuicTime::Delta::Infinite(),
             manager_.TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA));
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack the third and ensure the first two are still pending.
   ExpectAck(3);
-  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());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 3;
+  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.insert(2);
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   // Acking two more packets will lose both of them due to nacks.
-  received_info.largest_observed = 5;
+  ack_frame.largest_observed = 5;
   QuicPacketSequenceNumber lost[] = { 1, 2 };
   ExpectAcksAndLosses(false, NULL, 0, lost, arraysize(lost));
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   EXPECT_EQ(2u, stats_.tlp_count);
   EXPECT_EQ(0u, stats_.rto_count);
 }
 
 TEST_F(QuicSentPacketManagerTest, TailLossProbeThenRTO) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
 
@@ skipping 67 matching lines @@
   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.
   QuicPacketSequenceNumber acked[] = { 3, 4, 5, 8, 9 };
   ExpectAcksAndLosses(true, acked, arraysize(acked), NULL, 0);
-  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());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 9;
+  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.insert(6);
+  ack_frame.missing_packets.insert(7);
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutVersionNegotiation) {
   // Send 2 crypto packets and 3 data packets.
   const size_t kNumSentCryptoPackets = 2;
   for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
     SendCryptoPacket(i);
   }
@@ skipping 33 matching lines @@
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(2);
 
   // Retransmit the crypto packet as 3.
   manager_.OnRetransmissionTimeout();
   RetransmitNextPacket(3);
 
   // Now ack the second crypto packet, and ensure the first gets removed, but
   // the third does not.
   ExpectUpdatedRtt(2);
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 2;
-  received_info.missing_packets.insert(1);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 2;
+  ack_frame.missing_packets.insert(1);
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
   QuicPacketSequenceNumber unacked[] = { 3 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
 }
 
 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
   // Send 2 crypto packets and serialize 1 data packet.
   const size_t kNumSentCryptoPackets = 2;
   for (size_t i = 1; i <= kNumSentCryptoPackets; ++i) {
@@ skipping 49 matching lines @@
   // connection goes forward secure.
   manager_.NeuterUnencryptedPackets();
   QuicPacketSequenceNumber unacked[] = { 1, 2, 3};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   // Ensure both packets get discarded when packet 2 is acked.
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 3;
-  received_info.missing_packets.insert(1);
-  received_info.missing_packets.insert(2);
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 3;
+  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.insert(2);
   ExpectUpdatedRtt(3);
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, TailLossProbeTimeoutUnsentDataPacket) {
   QuicSentPacketManagerPeer::SetMaxTailLossProbes(&manager_, 2);
   // Serialize two data packets and send the latter.
   SerializedPacket packet(CreateDataPacket(1));
   manager_.OnSerializedPacket(packet);
   SendDataPacket(2);
@@ skipping 26 matching lines @@
   EXPECT_EQ(min_rtt,
             QuicSentPacketManagerPeer::GetRttStats(
                 &manager_)->recent_min_rtt());
 
   // Send two packets with no prior bytes in flight.
   SendDataPacket(1);
   SendDataPacket(2);
 
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(100));
   // Ack two packets with 100ms RTT observations.
-  ReceivedPacketInfo received_info;
-  received_info.delta_time_largest_observed = QuicTime::Delta::Zero();
-  received_info.largest_observed = 1;
+  QuicAckFrame ack_frame;
+  ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
+  ack_frame.largest_observed = 1;
   ExpectAck(1);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // First ack does not change recent min rtt.
   EXPECT_EQ(min_rtt,
             QuicSentPacketManagerPeer::GetRttStats(
                 &manager_)->recent_min_rtt());
 
-  received_info.largest_observed = 2;
+  ack_frame.largest_observed = 2;
   ExpectAck(2);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   EXPECT_EQ(min_rtt,
             QuicSentPacketManagerPeer::GetRttStats(&manager_)->min_rtt());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(100),
             QuicSentPacketManagerPeer::GetRttStats(
                 &manager_)->recent_min_rtt());
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) {
   // Send 100 packets and then ensure all are abandoned when the RTO fires.
@@ skipping 108 matching lines @@
   RetransmitNextPacket(6);
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   EXPECT_TRUE(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);
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 2;
+  ack_frame.missing_packets.insert(1);
   ExpectUpdatedRtt(2);
   EXPECT_CALL(*send_algorithm_, RevertRetransmissionTimeout());
-  manager_.OnIncomingAck(received_info, clock_.ApproximateNow());
+  manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(4 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
 
   // Wait 2RTTs from now for the RTO, since it's the max of the RTO time
   // and the TLP time.  In production, there would always be two TLP's first.
   expected_time = clock_.Now().Add(QuicTime::Delta::FromMilliseconds(200));
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
 }
 
@@ skipping 53 matching lines @@
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillRepeatedly(Return(QuicTime::Zero()));
   SendDataPacket(1);
   SendDataPacket(2);
 
   // Handle an ack which causes the loss algorithm to be evaluated and
   // set the loss timeout.
   ExpectAck(2);
   EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
-  ReceivedPacketInfo received_info;
-  received_info.largest_observed = 2;
-  received_info.missing_packets.insert(1);
-  manager_.OnIncomingAck(received_info, clock_.Now());
+  QuicAckFrame ack_frame;
+  ack_frame.largest_observed = 2;
+  ack_frame.missing_packets.insert(1);
+  manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   QuicTime timeout(clock_.Now().Add(QuicTime::Delta::FromMilliseconds(10)));
   EXPECT_CALL(*loss_algorithm, GetLossTimeout())
       .WillRepeatedly(Return(timeout));
   EXPECT_EQ(timeout, manager_.GetRetransmissionTime());
 
   // Fire the retransmission timeout and ensure the loss detection algorithm
   // is invoked.
   EXPECT_CALL(*loss_algorithm, DetectLostPackets(_, _, _, _))
       .WillOnce(Return(SequenceNumberSet()));
@@ skipping 74 matching lines @@
       .WillOnce(Return(100 * kDefaultTCPMSS));
   EXPECT_CALL(*send_algorithm_, SetFromConfig(_, _));
   manager_.SetFromConfig(config);
 
   EXPECT_TRUE(manager_.using_pacing());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net