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

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 <ostream>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 955 matching lines @@
 
   const QuicStopWaitingFrame InitStopWaitingFrame(
       QuicPacketNumber least_unacked) {
     QuicStopWaitingFrame frame;
     frame.least_unacked = least_unacked;
     return frame;
   }
 
   // Explicitly nack a packet.
   void NackPacket(QuicPacketNumber missing, QuicAckFrame* frame) {
-    frame->missing_packets.insert(missing);
+    frame->missing_packets.Add(missing);
     frame->entropy_hash ^=
         QuicConnectionPeer::PacketEntropy(&connection_, missing);
   }
 
   // Undo nacking a packet within the frame.
   void AckPacket(QuicPacketNumber arrived, QuicAckFrame* frame) {
-    EXPECT_THAT(frame->missing_packets, Contains(arrived));
-    frame->missing_packets.erase(arrived);
+    EXPECT_TRUE(frame->missing_packets.Contains(arrived));
+    frame->missing_packets.Remove(arrived);
     frame->entropy_hash ^=
         QuicConnectionPeer::PacketEntropy(&connection_, arrived);
   }
 
   void TriggerConnectionClose() {
     // Send an erroneous packet to close the connection.
     EXPECT_CALL(visitor_,
                 OnConnectionClosed(QUIC_INVALID_PACKET_HEADER, false));
     // Call ProcessDataPacket rather than ProcessPacket, as we should not get a
     // packet call to the visitor.
@@ skipping 150 matching lines @@
                             factory_, Perspective::IS_CLIENT, version());
   EXPECT_EQ(Perspective::IS_CLIENT, connection.perspective());
   EXPECT_EQ(lower_max_packet_size, connection.max_packet_length());
 }
 
 TEST_P(QuicConnectionTest, PacketsInOrder) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessPacket(1);
   EXPECT_EQ(1u, outgoing_ack()->largest_observed);
-  EXPECT_EQ(0u, outgoing_ack()->missing_packets.size());
+  EXPECT_TRUE(outgoing_ack()->missing_packets.Empty());
 
   ProcessPacket(2);
   EXPECT_EQ(2u, outgoing_ack()->largest_observed);
-  EXPECT_EQ(0u, outgoing_ack()->missing_packets.size());
+  EXPECT_TRUE(outgoing_ack()->missing_packets.Empty());
 
   ProcessPacket(3);
   EXPECT_EQ(3u, outgoing_ack()->largest_observed);
-  EXPECT_EQ(0u, outgoing_ack()->missing_packets.size());
+  EXPECT_TRUE(outgoing_ack()->missing_packets.Empty());
 }
 
 TEST_P(QuicConnectionTest, PacketsOutOfOrder) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   ProcessPacket(3);
   EXPECT_EQ(3u, outgoing_ack()->largest_observed);
   EXPECT_TRUE(IsMissing(2));
   EXPECT_TRUE(IsMissing(1));
 
@@ skipping 2850 matching lines @@
   QuicEncryptedPacket encrypted(nullptr, 0);
   connection_.ProcessUdpPacket(kSelfAddress, kPeerAddress, encrypted);
 }
 
 TEST_P(QuicConnectionTest, MissingPacketsBeforeLeastUnacked) {
   // Set the packet number of the ack packet to be least unacked (4).
   QuicPacketCreatorPeer::SetPacketNumber(&peer_creator_, 3);
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   QuicStopWaitingFrame frame = InitStopWaitingFrame(4);
   ProcessStopWaitingPacket(&frame);
-  EXPECT_TRUE(outgoing_ack()->missing_packets.empty());
+  EXPECT_TRUE(outgoing_ack()->missing_packets.Empty());
 }
 
 TEST_P(QuicConnectionTest, ReceivedEntropyHashCalculation) {
   EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(AtLeast(1));
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   ProcessDataPacket(1, 1, kEntropyFlag);
   ProcessDataPacket(4, 1, kEntropyFlag);
   ProcessDataPacket(3, 1, !kEntropyFlag);
   ProcessDataPacket(7, 1, kEntropyFlag);
   EXPECT_EQ(146u, outgoing_ack()->entropy_hash);
@@ skipping 773 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(1);
   connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
   EXPECT_TRUE(connection_.goaway_sent());
   EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _)).Times(0);
   connection_.SendGoAway(QUIC_PEER_GOING_AWAY, kHeadersStreamId, "Going Away.");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net