Revert of Landing Recent QUIC Changes.

net/quic/quic_unacked_packet_map_test.cc

 // Copyright 2014 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_unacked_packet_map.h"
 
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ skipping 17 matching lines @@
   }
 
   SerializedPacket CreateNonRetransmittablePacket(
       QuicPacketSequenceNumber sequence_number) {
     return SerializedPacket(
         sequence_number, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
   }
 
   void VerifyInFlightPackets(QuicPacketSequenceNumber* packets,
                              size_t num_packets) {
-    unacked_packets_.RemoveObsoletePackets();
     if (num_packets == 0) {
       EXPECT_FALSE(unacked_packets_.HasInFlightPackets());
       EXPECT_FALSE(unacked_packets_.HasMultipleInFlightPackets());
       return;
     }
     if (num_packets == 1) {
       EXPECT_TRUE(unacked_packets_.HasInFlightPackets());
       EXPECT_FALSE(unacked_packets_.HasMultipleInFlightPackets());
       ASSERT_TRUE(unacked_packets_.IsUnacked(packets[0]));
       EXPECT_TRUE(unacked_packets_.GetTransmissionInfo(packets[0]).in_flight);
     }
     for (size_t i = 0; i < num_packets; ++i) {
       ASSERT_TRUE(unacked_packets_.IsUnacked(packets[i]));
       EXPECT_TRUE(unacked_packets_.GetTransmissionInfo(packets[i]).in_flight);
     }
     size_t in_flight_count = 0;
     for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
          it != unacked_packets_.end(); ++it) {
-      if (it->in_flight) {
+      if (it->second.in_flight) {
         ++in_flight_count;
       }
     }
     EXPECT_EQ(num_packets, in_flight_count);
   }
 
   void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
                             size_t num_packets) {
-    unacked_packets_.RemoveObsoletePackets();
     if (num_packets == 0) {
       EXPECT_FALSE(unacked_packets_.HasUnackedPackets());
       EXPECT_FALSE(unacked_packets_.HasUnackedRetransmittableFrames());
       return;
     }
     EXPECT_TRUE(unacked_packets_.HasUnackedPackets());
     for (size_t i = 0; i < num_packets; ++i) {
       EXPECT_TRUE(unacked_packets_.IsUnacked(packets[i])) << packets[i];
     }
-    EXPECT_EQ(num_packets, unacked_packets_.GetNumUnackedPacketsDebugOnly());
+    size_t unacked_count = 0;
+    for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
+         it != unacked_packets_.end(); ++it) {
+      ++unacked_count;
+    }
+    EXPECT_EQ(num_packets, unacked_count);
   }
 
   void VerifyRetransmittablePackets(QuicPacketSequenceNumber* packets,
                                     size_t num_packets) {
-    unacked_packets_.RemoveObsoletePackets();
     size_t num_retransmittable_packets = 0;
     for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
          it != unacked_packets_.end(); ++it) {
-      if (it->retransmittable_frames != NULL) {
+      if (it->second.retransmittable_frames != NULL) {
         ++num_retransmittable_packets;
       }
     }
     EXPECT_EQ(num_packets, num_retransmittable_packets);
     for (size_t i = 0; i < num_packets; ++i) {
       EXPECT_TRUE(unacked_packets_.HasRetransmittableFrames(packets[i]))
           << " packets[" << i << "]:" << packets[i];
     }
   }
 
@@ skipping 136 matching lines @@
   VerifyUnackedPackets(unacked4, arraysize(unacked4));
   QuicPacketSequenceNumber pending4[] = { 3, 5, 7 };
   VerifyInFlightPackets(pending4, arraysize(pending4));
   QuicPacketSequenceNumber retransmittable4[] = { 7 };
   VerifyRetransmittablePackets(retransmittable4, arraysize(retransmittable4));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net