Remove is_fec_packet from TransmissionInfo and SerializedPacket. No functional change.

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 188 matching lines @@
     SerializedPacket packet(kDefaultPathId, packet_number,
                             PACKET_6BYTE_PACKET_NUMBER, nullptr, kDefaultLength,
                             0u, false, false);
     if (retransmittable) {
       packet.retransmittable_frames.push_back(
           QuicFrame(new QuicStreamFrame(kStreamId, false, 0, StringPiece())));
     }
     return packet;
   }
 
-  SerializedPacket CreateFecPacket(QuicPacketNumber packet_number) {
-    SerializedPacket serialized(kDefaultPathId, packet_number,
-                                PACKET_6BYTE_PACKET_NUMBER, nullptr,
-                                kDefaultLength, 0u, false, false);
-    serialized.is_fec_packet = true;
-    return serialized;
-  }
-
   void SendDataPacket(QuicPacketNumber packet_number) {
     EXPECT_CALL(*send_algorithm_,
                 OnPacketSent(_, BytesInFlight(), packet_number, _, _))
         .Times(1)
         .WillOnce(Return(true));
     SerializedPacket packet(CreateDataPacket(packet_number));
     manager_.OnPacketSent(&packet, 0, clock_.Now(), NOT_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA);
   }
 
   void SendCryptoPacket(QuicPacketNumber packet_number) {
     EXPECT_CALL(*send_algorithm_,
                 OnPacketSent(_, BytesInFlight(), packet_number, kDefaultLength,
                              HAS_RETRANSMITTABLE_DATA))
         .Times(1)
         .WillOnce(Return(true));
     SerializedPacket packet(CreateDataPacket(packet_number));
     packet.retransmittable_frames.push_back(
         QuicFrame(new QuicStreamFrame(1, false, 0, StringPiece())));
     packet.has_crypto_handshake = IS_HANDSHAKE;
     manager_.OnPacketSent(&packet, 0, clock_.Now(), NOT_RETRANSMISSION,
                           HAS_RETRANSMITTABLE_DATA);
   }
 
-  void SendFecPacket(QuicPacketNumber packet_number) {
-    EXPECT_CALL(*send_algorithm_,
-                OnPacketSent(_, BytesInFlight(), packet_number, kDefaultLength,
-                             HAS_RETRANSMITTABLE_DATA))
-        .Times(1)
-        .WillOnce(Return(true));
-    SerializedPacket packet(CreateFecPacket(packet_number));
-    manager_.OnPacketSent(&packet, 0, clock_.Now(), NOT_RETRANSMISSION,
-                          NO_RETRANSMITTABLE_DATA);
-  }
-
   void SendAckPacket(QuicPacketNumber packet_number) {
     EXPECT_CALL(*send_algorithm_,
                 OnPacketSent(_, BytesInFlight(), packet_number, kDefaultLength,
                              NO_RETRANSMITTABLE_DATA))
         .Times(1)
         .WillOnce(Return(false));
     SerializedPacket packet(CreatePacket(packet_number, false));
     manager_.OnPacketSent(&packet, 0, clock_.Now(), NOT_RETRANSMISSION,
                           NO_RETRANSMITTABLE_DATA);
   }
@@ skipping 279 matching lines @@
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnacked) {
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 }
 
 TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnacked) {
   SendDataPacket(1);
   EXPECT_EQ(1u, manager_.GetLeastUnacked());
 }
 
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedUnackedFec) {
-  SendFecPacket(1);
-  EXPECT_EQ(1u, manager_.GetLeastUnacked());
-}
-
-TEST_F(QuicSentPacketManagerTest, GetLeastUnackedAndDiscard) {
-  VerifyUnackedPackets(nullptr, 0);
-
-  SendFecPacket(1);
-  EXPECT_EQ(1u, manager_.GetLeastUnacked());
-
-  SendFecPacket(2);
-  EXPECT_EQ(1u, manager_.GetLeastUnacked());
-
-  SendFecPacket(3);
-  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.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);
-  QuicTime sent_time2 = clock_.Now();
-  SendFecPacket(2);
-  QuicPacketNumber unacked[] = {1, 2};
-  VerifyUnackedPackets(unacked, arraysize(unacked));
-  VerifyRetransmittablePackets(nullptr, 0);
-
-  EXPECT_TRUE(manager_.HasUnackedPackets());
-  EXPECT_EQ(sent_time, QuicSentPacketManagerPeer::GetSentTime(&manager_, 1));
-  EXPECT_EQ(sent_time2, QuicSentPacketManagerPeer::GetSentTime(&manager_, 2));
-}
-
 TEST_F(QuicSentPacketManagerTest, AckAckAndUpdateRtt) {
   SendDataPacket(1);
   SendAckPacket(2);
 
   // Now ack the ack and expect an RTT update.
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 2;
   ack_frame.ack_delay_time = QuicTime::Delta::FromMilliseconds(5);
 
   ExpectAck(1);
@@ skipping 1092 matching lines @@
   manager_.OnConnectionMigration(PORT_CHANGE);
 
   EXPECT_EQ(2 * default_init_rtt, rtt_stats->initial_rtt_us());
   EXPECT_EQ(1u, manager_.consecutive_rto_count());
   EXPECT_EQ(2u, manager_.consecutive_tlp_count());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net