relnote: Refactor QuicAckFrame::missing_packets to support a change to a

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 277 matching lines @@
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
 
   // Ack 2 but not 1.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   ExpectAck(2);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // Packet 1 is unacked, pending, but not retransmittable.
   QuicPacketNumber unacked[] = {1};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   VerifyRetransmittablePackets(nullptr, 0);
 }
 
@@ skipping 68 matching lines @@
   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.
   ack_frame.largest_observed = 3;
-  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.Add(2);
   ExpectAck(3);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   ack_frame.largest_observed = 4;
   ExpectAck(4);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   ack_frame.largest_observed = 5;
   ExpectAckAndLoss(true, 5, 2);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
@@ skipping 59 matching lines @@
 
   // 2 and 3 remain unacked, but no packets have retransmittable data.
   QuicPacketNumber unacked[] = {2, 3};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   VerifyRetransmittablePackets(nullptr, 0);
 
   // Ensure packet 2 is lost when 4 is sent and 3 and 4 are acked.
   SendDataPacket(4);
   ack_frame.largest_observed = 4;
-  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.Add(2);
   QuicPacketNumber acked[] = {3, 4};
   ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   QuicPacketNumber unacked2[] = {2};
   VerifyUnackedPackets(unacked2, arraysize(unacked2));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   SendDataPacket(5);
   ack_frame.largest_observed = 5;
   ExpectAckAndLoss(true, 5, 2);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   VerifyUnackedPackets(nullptr, 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.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 3;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   ack_frame.revived_packets.insert(1);
   QuicPacketNumber acked[] = {2, 3};
   ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   QuicPacketNumber unacked[] = {1, 4};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
   QuicPacketNumber retransmittable[] = {4};
@@ skipping 11 matching lines @@
 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.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 4;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   QuicPacketNumber acked[] = {2, 3, 4};
   QuicPacketNumber lost[] = {1};
   ExpectAcksAndLosses(true, acked, arraysize(acked), lost, arraysize(lost));
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   QuicPacketNumber unacked[] = {1, 5};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketNumber retransmittable[] = {1};
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
@@ skipping 14 matching lines @@
                               false);
   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.
   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.missing_packets.Add(1, 5);
   ack_frame.is_truncated = true;
 
   QuicPacketNumber lost[] = {1};
   ExpectAcksAndLosses(true, nullptr, 0, lost, arraysize(lost));
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // High water mark will be raised.
   QuicPacketNumber unacked[] = {2, 3, 4, 5};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketNumber retransmittable[] = {5};
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
 TEST_F(QuicSentPacketManagerTest, AckPreviousTransmissionThenTruncatedAck) {
   SendDataPacket(1);
   RetransmitAndSendPacket(1, 2);
   RetransmitAndSendPacket(2, 3);
   RetransmitAndSendPacket(3, 4);
   SendDataPacket(5);
   SendDataPacket(6);
   SendDataPacket(7);
   SendDataPacket(8);
   SendDataPacket(9);
 
   // Ack previous transmission
   {
     QuicAckFrame ack_frame;
     ack_frame.largest_observed = 2;
-    ack_frame.missing_packets.insert(1);
+    ack_frame.missing_packets.Add(1);
     ExpectAck(2);
     manager_.OnIncomingAck(ack_frame, clock_.Now());
     EXPECT_TRUE(manager_.IsUnacked(4));
   }
 
   // Truncated ack with 4 NACKs
   {
     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.missing_packets.Add(3, 7);
     ack_frame.is_truncated = true;
     ExpectAckAndLoss(true, 1, 3);
     manager_.OnIncomingAck(ack_frame, clock_.Now());
   }
 
   // High water mark will be raised.
   QuicPacketNumber unacked[] = {4, 5, 6, 7, 8, 9};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketNumber retransmittable[] = {5, 6, 7, 8, 9};
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
@@ skipping 26 matching lines @@
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 
   QuicPacketNumber unacked[] = {1, 2, 3};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(nullptr, 0);
 
   // Ack 2, so there's an rtt update.
   ExpectAck(2);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetSentTime) {
   VerifyUnackedPackets(nullptr, 0);
 
   QuicTime sent_time = clock_.Now();
   SendFecPacket(1);
@@ skipping 126 matching lines @@
   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);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 3;
-  ack_frame.missing_packets.insert(1);
-  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.Add(1, 3);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_TRUE(QuicSentPacketManagerPeer::HasPendingPackets(&manager_));
 
   // Acking two more packets will lose both of them due to nacks.
   ack_frame.largest_observed = 5;
   QuicPacketNumber lost[] = {1, 2};
   ExpectAcksAndLosses(false, nullptr, 0, lost, arraysize(lost));
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
@@ skipping 58 matching lines @@
   EXPECT_EQ(2u, stats_.tlp_count);
   EXPECT_EQ(1u, stats_.rto_count);
 
   // Send and Ack the RTO and ensure OnRetransmissionTimeout is called.
   EXPECT_EQ(102 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
 
   RetransmitNextPacket(103);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 103;
-  for (int i = 0; i < 103; ++i) {
-    ack_frame.missing_packets.insert(i);
-  }
+  ack_frame.missing_packets.Add(0, 103);
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   EXPECT_CALL(*send_algorithm_,
               OnCongestionEvent(true, _, ElementsAre(Pair(103, _)), _));
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
   // All packets before 103 should be lost.
   EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
 }
 
@@ skipping 26 matching lines @@
   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.
   QuicPacketNumber acked[] = {3, 4, 5, 8, 9};
   ExpectAcksAndLosses(true, acked, arraysize(acked), nullptr, 0);
   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);
+  ack_frame.missing_packets.Add(1, 3);
+  ack_frame.missing_packets.Add(6, 8);
   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 43 matching lines @@
 
   // 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);
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
 
   EXPECT_FALSE(QuicSentPacketManagerPeer::HasUnackedCryptoPackets(&manager_));
   QuicPacketNumber unacked[] = {3};
   VerifyUnackedPackets(unacked, arraysize(unacked));
 }
 
 TEST_F(QuicSentPacketManagerTest, CryptoHandshakeTimeoutUnsentDataPacket) {
   // Send 2 crypto packets and 1 data packet.
   const size_t kNumSentCryptoPackets = 2;
@@ skipping 51 matching lines @@
   QuicPacketNumber unacked[] = {1, 2, 3};
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(nullptr, 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.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 3;
-  ack_frame.missing_packets.insert(1);
-  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.Add(1, 3);
   ExpectUpdatedRtt(3);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
   VerifyUnackedPackets(nullptr, 0);
   VerifyRetransmittablePackets(nullptr, 0);
 }
 
 TEST_F(QuicSentPacketManagerTest, RetransmissionTimeout) {
   // Send 100 packets.
   const size_t kNumSentPackets = 100;
   for (size_t i = 1; i <= kNumSentPackets; ++i) {
     SendDataPacket(i);
   }
 
   EXPECT_FALSE(manager_.MaybeRetransmitTailLossProbe());
   manager_.OnRetransmissionTimeout();
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(100 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(101);
   RetransmitNextPacket(102);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack a retransmission.
   QuicAckFrame ack_frame;
   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
   ack_frame.largest_observed = 102;
-  for (int i = 0; i < 102; ++i) {
-    ack_frame.missing_packets.insert(i);
-  }
+  ack_frame.missing_packets.Add(0, 102);
   // Ensure no packets are lost.
   EXPECT_CALL(*send_algorithm_,
               OnCongestionEvent(true, _, ElementsAre(Pair(102, _)),
                                 /*lost_packets=*/IsEmpty()));
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 }
 
@@ skipping 25 matching lines @@
   EXPECT_EQ(100 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(101);
   RetransmitNextPacket(102);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack a retransmission and expect no call to OnRetransmissionTimeout.
   QuicAckFrame ack_frame;
   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
   ack_frame.largest_observed = 102;
-  for (int i = 0; i < 102; ++i) {
-    ack_frame.missing_packets.insert(i);
-  }
+  ack_frame.missing_packets.Add(0, 102);
   // This will include packets in the lost packet map.
   EXPECT_CALL(*send_algorithm_,
               OnCongestionEvent(true, _, ElementsAre(Pair(102, _)),
                                 /*lost_packets=*/Not(IsEmpty())));
   EXPECT_CALL(*network_change_visitor_, OnCongestionWindowChange());
   EXPECT_CALL(*network_change_visitor_, OnRttChange());
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 }
 
 TEST_F(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckSecond) {
@@ skipping 13 matching lines @@
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(3);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack a retransmission and ensure OnRetransmissionTimeout is called.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   QuicAckFrame ack_frame;
   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
   ack_frame.largest_observed = 2;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   ExpectAck(2);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // The original packet and newest should be outstanding.
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckFirst) {
   // Send 1 packet.
@@ skipping 12 matching lines @@
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
   RetransmitNextPacket(3);
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // Ack a retransmission and ensure OnRetransmissionTimeout is called.
   EXPECT_CALL(*send_algorithm_, OnRetransmissionTimeout(true));
   QuicAckFrame ack_frame;
   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
   ack_frame.largest_observed = 3;
-  ack_frame.missing_packets.insert(1);
-  ack_frame.missing_packets.insert(2);
+  ack_frame.missing_packets.Add(1, 3);
   ExpectAck(3);
   manager_.OnIncomingAck(ack_frame, clock_.Now());
 
   // The first two packets should still be outstanding.
   EXPECT_EQ(2 * kDefaultLength,
             QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
 }
 
 TEST_F(QuicSentPacketManagerTest, GetTransmissionTime) {
   EXPECT_EQ(QuicTime::Zero(), manager_.GetRetransmissionTime());
@@ skipping 97 matching lines @@
   // The delay should double the second time.
   expected_time = clock_.Now().Add(expected_rto_delay).Add(expected_rto_delay);
   // Once we always base the timer on the right edge, leaving the older packets
   // in flight doesn't change the timeout.
   EXPECT_EQ(expected_time, manager_.GetRetransmissionTime());
 
   // Ack a packet before the first RTO and ensure the RTO timeout returns to the
   // original value and OnRetransmissionTimeout is not called or reverted.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(1);
   ExpectAck(2);
   manager_.OnIncomingAck(ack_frame, clock_.ApproximateNow());
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
   EXPECT_EQ(5 * 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.
   // Since retransmission was spurious, smoothed_rtt_ is expired, and replaced
   // by the latest RTT sample of 500ms.
@@ skipping 53 matching lines @@
   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(PacketNumberSet()));
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
-  ack_frame.missing_packets.insert(1);
+  ack_frame.missing_packets.Add(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(_, _, _, _))
@@ skipping 323 matching lines @@
 
   EXPECT_CALL(*send_algorithm_, ResumeConnectionState(_, false));
   manager_.ResumeConnectionState(cached_network_params, false);
   EXPECT_EQ(kRttMs * kNumMicrosPerMilli,
             static_cast<uint64>(manager_.GetRttStats()->initial_rtt_us()));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net