Remove unnecessary methods from QuicUnackedPacketMap and a minor

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/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ skipping 51 matching lines @@
 
     EXPECT_TRUE(manager_.HasUnackedPackets());
     EXPECT_EQ(packets[0], manager_.GetLeastUnackedSentPacket());
     for (size_t i = 0; i < num_packets; ++i) {
       EXPECT_TRUE(manager_.IsUnacked(packets[i])) << packets[i];
     }
   }
 
   void VerifyRetransmittablePackets(QuicPacketSequenceNumber* packets,
                                     size_t num_packets) {
-    SequenceNumberSet unacked =
-        QuicSentPacketManagerPeer::GetUnackedPackets(&manager_);
-    for (size_t i = 0; i < num_packets; ++i) {
-      EXPECT_TRUE(ContainsKey(unacked, packets[i])) << packets[i];
-    }
-    size_t num_retransmittable = 0;
-    for (SequenceNumberSet::const_iterator it = unacked.begin();
-         it != unacked.end(); ++it) {
-      if (manager_.HasRetransmittableFrames(*it)) {
-        ++num_retransmittable;
-      }
-    }
     EXPECT_EQ(num_packets,
               QuicSentPacketManagerPeer::GetNumRetransmittablePackets(
                   &manager_));
-    EXPECT_EQ(num_packets, num_retransmittable);
+    for (size_t i = 0; i < num_packets; ++i) {
+      EXPECT_TRUE(manager_.HasRetransmittableFrames(packets[i]))
+          << " packets[" << i << "]:" << packets[i];
+    }
   }
 
   void ExpectAck(QuicPacketSequenceNumber largest_observed) {
     EXPECT_CALL(*send_algorithm_, OnCongestionEvent(
         true, _, ElementsAre(Pair(largest_observed, _)), _));
   }
 
   void ExpectUpdatedRtt(QuicPacketSequenceNumber largest_observed) {
     EXPECT_CALL(*send_algorithm_,
                 OnCongestionEvent(true, _, _, _));
@@ skipping 452 matching lines @@
   received_info.missing_packets.insert(2);
   received_info.missing_packets.insert(3);
   received_info.missing_packets.insert(4);
   received_info.is_truncated = true;
 
   QuicPacketSequenceNumber lost[] = { 1 };
   ExpectAcksAndLosses(true, NULL, 0, lost, arraysize(lost));
   manager_.OnIncomingAck(received_info, clock_.Now());
 
   // High water mark will be raised.
-  QuicPacketSequenceNumber unacked[] = { 2, 3, 4 };
+  QuicPacketSequenceNumber unacked[] = { 2, 3, 4, 5 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
-  QuicPacketSequenceNumber retransmittable[] = { 4 };
+  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));
@@ skipping 646 matching lines @@
 
   EXPECT_EQ(kTime,
             QuicSentPacketManagerPeer::GetLossAlgorithm(
                 &manager_)->GetLossDetectionType());
 }
 
 
 }  // namespace
 }  // namespace test
 }  // namespace net