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/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 13 matching lines @@
   MOCK_METHOD2(OnPacketNacked, void(QuicPacketSequenceNumber sequence_number,
                                     size_t nack_count));
 };
 
 class QuicSentPacketManagerTest : public ::testing::TestWithParam<bool> {
  protected:
   QuicSentPacketManagerTest()
       : manager_(true, &helper_) {
   }
 
-  void SetUp() {
-    FLAGS_track_retransmission_history = GetParam();
-  }
-
   ~QuicSentPacketManagerTest() {
     STLDeleteElements(&packets_);
   }
 
 
   void VerifyUnackedPackets(QuicPacketSequenceNumber* packets,
                             size_t num_packets) {
     if (num_packets == 0) {
       EXPECT_FALSE(manager_.HasUnackedPackets());
-      EXPECT_EQ(0u, manager_.GetNumUnackedPackets());
+      EXPECT_EQ(0u, manager_.GetNumRetransmittablePackets());
       EXPECT_TRUE(manager_.GetUnackedPackets().empty());
       return;
     }
 
     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 = manager_.GetUnackedPackets();
     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, manager_.GetNumRetransmittablePackets());
     EXPECT_EQ(num_packets, num_retransmittable);
   }
 
   void VerifyAckedPackets(QuicPacketSequenceNumber* expected,
                           size_t num_expected,
                           const SequenceNumberSet& actual) {
     if (num_expected == 0) {
       EXPECT_TRUE(actual.empty());
       return;
     }
@@ skipping 30 matching lines @@
         PACKET_6BYTE_SEQUENCE_NUMBER));
     return SerializedPacket(sequence_number, PACKET_6BYTE_SEQUENCE_NUMBER,
                             packets_.back(), 0u, NULL);
   }
 
   testing::StrictMock<MockHelper> helper_;
   QuicSentPacketManager manager_;
   vector<QuicPacket*> packets_;
 };
 
-INSTANTIATE_TEST_CASE_P(TrackRetransmissionHistory,
-                        QuicSentPacketManagerTest,
-                        ::testing::Values(false, true));
-
-TEST_P(QuicSentPacketManagerTest, IsUnacked) {
+TEST_F(QuicSentPacketManagerTest, IsUnacked) {
   VerifyUnackedPackets(NULL, 0);
 
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
 
   QuicPacketSequenceNumber unacked[] = { 1 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 1 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
-TEST_P(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
-  if (!FLAGS_track_retransmission_history) {
-    // This tests restransmission tracking specifically.
-    return;
-  }
+TEST_F(QuicSentPacketManagerTest, IsUnAckedRetransmit) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   RetransmitPacket(1, 2);
 
-  EXPECT_EQ(1u, manager_.GetRetransmissionCount(2));
+  EXPECT_TRUE(manager_.IsRetransmission(2));
   QuicPacketSequenceNumber unacked[] = { 1, 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 2 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
-
-  RetransmitPacket(2, 3);
-  EXPECT_EQ(2u, manager_.GetRetransmissionCount(3));
-  QuicPacketSequenceNumber unacked2[] = { 1, 2, 3 };
-  VerifyUnackedPackets(unacked2, arraysize(unacked2));
-  QuicPacketSequenceNumber retransmittable2[] = { 3 };
-  VerifyRetransmittablePackets(retransmittable2, arraysize(retransmittable2));
 }
 
-TEST_P(QuicSentPacketManagerTest, RetransmitThenAck) {
+TEST_F(QuicSentPacketManagerTest, RetransmitThenAck) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   RetransmitPacket(1, 2);
 
   // Ack 2 but not 1.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 2;
   received_info.missing_packets.insert(1);
   manager_.OnIncomingAck(received_info, false);
 
   // No unacked packets remain.
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 }
 
-TEST_P(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
+TEST_F(QuicSentPacketManagerTest, RetransmitThenAckBeforeSend) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   manager_.MarkForRetransmission(1, NACK_RETRANSMISSION);
   EXPECT_TRUE(manager_.HasPendingRetransmissions());
 
   // Ack 1.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 1;
   manager_.OnIncomingAck(received_info, false);
 
   // There should no longer be a pending retransmission.
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // No unacked packets remain.
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 }
 
-TEST_P(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
-  if (!FLAGS_track_retransmission_history) {
-    // This tests restransmission tracking specifically.
-    return;
-  }
+TEST_F(QuicSentPacketManagerTest, RetransmitThenAckPrevious) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   RetransmitPacket(1, 2);
 
   // Ack 1 but not 2.
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 2;
   received_info.missing_packets.insert(2);
   EXPECT_CALL(helper_, OnPacketNacked(2, 1)).Times(1);
   manager_.OnIncomingAck(received_info, false);
 
   // 2 remains unacked, but no packets have retransmittable data.
   QuicPacketSequenceNumber unacked[] = { 2 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   VerifyRetransmittablePackets(NULL, 0);
 }
 
-TEST_P(QuicSentPacketManagerTest, TruncatedAck) {
-  if (!FLAGS_track_retransmission_history) {
-    // This tests restransmission tracking specifically.
-    return;
-  }
+TEST_F(QuicSentPacketManagerTest, TruncatedAck) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   RetransmitPacket(1, 2);
   RetransmitPacket(2, 3);
   RetransmitPacket(3, 4);
 
   // Truncated ack with 2 NACKs
   ReceivedPacketInfo received_info;
   received_info.largest_observed = 2;
   received_info.missing_packets.insert(1);
   received_info.missing_packets.insert(2);
   manager_.OnIncomingAck(received_info, true);
 
   // High water mark will be raised.
   QuicPacketSequenceNumber unacked[] = { 2, 3, 4 };
   VerifyUnackedPackets(unacked, arraysize(unacked));
   QuicPacketSequenceNumber retransmittable[] = { 4 };
   VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
 }
 
-TEST_P(QuicSentPacketManagerTest, SendDropAckRetransmitManyPackets) {
-  if (!FLAGS_track_retransmission_history) {
-    // This tests restransmission tracking specifically.
-    return;
-  }
+TEST_F(QuicSentPacketManagerTest, SendDropAckRetransmitManyPackets) {
   manager_.OnSerializedPacket(CreatePacket(1), QuicTime::Zero());
   manager_.OnSerializedPacket(CreatePacket(2), QuicTime::Zero());
   manager_.OnSerializedPacket(CreatePacket(3), QuicTime::Zero());
 
   {
     // Ack packets 1 and 3.
     ReceivedPacketInfo received_info;
     received_info.largest_observed = 3;
     received_info.missing_packets.insert(2);
     EXPECT_CALL(helper_, OnPacketNacked(2, 1)).Times(1);
@@ skipping 121 matching lines @@
     manager_.OnIncomingAck(received_info, true);
 
     // Truncated ack raises the high water mark by clearing out 2, 4, and 6.
     QuicPacketSequenceNumber unacked[] = { 8, 9, 11, 12, 14, 15, 16 };
     VerifyUnackedPackets(unacked, arraysize(unacked));
     QuicPacketSequenceNumber retransmittable[] = { 8, 9, 11, 12, 14, 15, 16 };
     VerifyRetransmittablePackets(retransmittable, arraysize(retransmittable));
   }
 }
 
-TEST_P(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) {
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacket) {
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(1u));
   EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 }
 
-TEST_P(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnacked) {
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnacked) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   EXPECT_EQ(1u, manager_.GetLeastUnackedSentPacket());
 }
 
-TEST_P(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnackedFec) {
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketUnackedFec) {
   SerializedPacket serialized_packet(CreateFecPacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   // FEC packets do not count as "unacked".
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(2u));
   EXPECT_EQ(2u, manager_.GetLeastUnackedSentPacket());
 }
 
-TEST_P(QuicSentPacketManagerTest, GetLeastUnackedSentPacketDiscardUnacked) {
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedSentPacketDiscardUnacked) {
   SerializedPacket serialized_packet(CreatePacket(1));
 
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   manager_.DiscardUnackedPacket(1u);
   EXPECT_CALL(helper_, GetNextPacketSequenceNumber()).WillOnce(Return(2u));
   EXPECT_EQ(2u, manager_.GetLeastUnackedSentPacket());
 }
 
-TEST_P(QuicSentPacketManagerTest, GetLeastUnackedFecPacketAndDiscard) {
+TEST_F(QuicSentPacketManagerTest, GetLeastUnackedFecPacketAndDiscard) {
   VerifyUnackedPackets(NULL, 0);
 
   SerializedPacket serialized_packet(CreateFecPacket(1));
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   EXPECT_EQ(1u, manager_.GetLeastUnackedFecPacket());
 
   SerializedPacket serialized_packet2(CreateFecPacket(2));
   manager_.OnSerializedPacket(serialized_packet2, QuicTime::Zero());
   EXPECT_EQ(1u, manager_.GetLeastUnackedFecPacket());
 
@@ skipping 12 matching lines @@
   received_info.largest_observed = 2;
   manager_.OnIncomingAck(received_info, false);
 
   EXPECT_EQ(3u, manager_.GetLeastUnackedFecPacket());
 
   // Discard the 3rd packet and ensure there are no FEC packets.
   manager_.DiscardFecPacket(3);
   EXPECT_FALSE(manager_.HasUnackedFecPackets());
 }
 
-TEST_P(QuicSentPacketManagerTest, GetFecSentTime) {
+TEST_F(QuicSentPacketManagerTest, GetFecSentTime) {
   VerifyUnackedPackets(NULL, 0);
 
   SerializedPacket serialized_packet(CreateFecPacket(1));
   manager_.OnSerializedPacket(serialized_packet, QuicTime::Zero());
   SerializedPacket serialized_packet2(CreateFecPacket(2));
   QuicTime sent_time = QuicTime::Zero().Add(QuicTime::Delta::FromSeconds(1));
   manager_.OnSerializedPacket(serialized_packet2, sent_time);
 
   VerifyUnackedPackets(NULL, 0);
   VerifyRetransmittablePackets(NULL, 0);
 
   EXPECT_TRUE(manager_.HasUnackedFecPackets());
   EXPECT_EQ(QuicTime::Zero(), manager_.GetFecSentTime(1));
   EXPECT_EQ(sent_time, manager_.GetFecSentTime(2));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net