Remove FEC code from receive path.

net/quic/quic_packet_creator_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_packet_creator.h"
 
 #include <stdint.h>
 
 #include "base/macros.h"
 #include "base/stl_util.h"
@@ skipping 164 matching lines @@
                                 frame.stream_frame->frame_length));
     EXPECT_EQ(offset, frame.stream_frame->offset);
     EXPECT_EQ(fin, frame.stream_frame->fin);
   }
 
   // Returns the number of bytes consumed by the header of packet, including
   // the version.
   size_t GetPacketHeaderOverhead() {
     return GetPacketHeaderSize(
         creator_.connection_id_length(), kIncludeVersion, !kIncludePathId,
-        QuicPacketCreatorPeer::NextPacketNumberLength(&creator_),
-        NOT_IN_FEC_GROUP);
+        QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
   }
 
   // Returns the number of bytes of overhead that will be added to a packet
   // of maximum length.
   size_t GetEncryptionOverhead() {
     return creator_.max_packet_length() -
            client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
   }
 
   // Returns the number of bytes consumed by the non-data fields of a stream
   // frame, assuming it is the last frame in the packet
   size_t GetStreamFrameOverhead() {
     return QuicFramer::GetMinStreamFrameSize(kClientDataStreamId1, kOffset,
-                                             true, NOT_IN_FEC_GROUP);
+                                             true);
   }
 
   QuicIOVector MakeIOVector(StringPiece s) {
     return ::net::MakeIOVector(s, &iov_);
   }
 
   PendingRetransmission CreateRetransmission(
       const QuicFrames& retransmittable_frames,
       bool has_crypto_handshake,
       bool needs_padding,
@@ skipping 600 matching lines @@
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   // A string larger than fits into a frame.
   size_t payload_length;
   creator_.SetMaxPacketLength(GetPacketLengthForOneStream(
       client_framer_.version(),
       QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
       QuicPacketCreatorPeer::SendPathIdInPacket(&creator_),
       creator_.connection_id_length(), PACKET_1BYTE_PACKET_NUMBER,
-      NOT_IN_FEC_GROUP, &payload_length));
+      &payload_length));
   QuicFrame frame;
   const string too_long_payload(payload_length * 2, 'a');
   QuicIOVector io_vector(MakeIOVector(too_long_payload));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(payload_length, consumed);
   const string payload(payload_length, 'a');
   CheckStreamFrame(frame, 1u, payload, 0u, false);
   creator_.Flush();
   DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, AddFrameAndFlush) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   const size_t max_plaintext_size =
       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(max_plaintext_size -
                 GetPacketHeaderSize(
                     creator_.connection_id_length(),
                     QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
                     QuicPacketCreatorPeer::SendPathIdInPacket(&creator_),
-                    PACKET_1BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
+                    PACKET_1BYTE_PACKET_NUMBER),
             creator_.BytesFree());
 
   // Add a variety of frame types and then a padding frame.
   QuicAckFrame ack_frame(MakeAckFrame(0u));
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
   ASSERT_TRUE(
@@ skipping 20 matching lines @@
   ASSERT_EQ(1u, retransmittable.size());
   EXPECT_EQ(STREAM_FRAME, retransmittable[0].type);
   ASSERT_TRUE(retransmittable[0].stream_frame);
   DeleteSerializedPacket();
 
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(max_plaintext_size -
                 GetPacketHeaderSize(
                     creator_.connection_id_length(),
                     QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
-                    /*include_path_id=*/false, PACKET_1BYTE_PACKET_NUMBER,
-                    NOT_IN_FEC_GROUP),
+                    /*include_path_id=*/false, PACKET_1BYTE_PACKET_NUMBER),
             creator_.BytesFree());
 }
 
 TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithLargePacketSize) {
   if (!GetParam().version_serialization) {
     creator_.StopSendingVersion();
   }
   creator_.SetMaxPacketLength(kMaxPacketSize);
 
   // Serialized length of ack frame with 2000 nack ranges should be limited by
   // the number of nack ranges that can be fit in an ack frame.
   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
   size_t frame_len = client_framer_.GetSerializedFrameLength(
-      QuicFrame(&ack_frame), creator_.BytesFree(), true, true, NOT_IN_FEC_GROUP,
+      QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
       PACKET_1BYTE_PACKET_NUMBER);
   EXPECT_GT(creator_.BytesFree(), frame_len);
   EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize());
 
   // Add ack frame to creator.
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize());
   EXPECT_LT(0u, creator_.BytesFree());
 
@@ skipping 27 matching lines @@
   creator_.SetMaxPacketLength(500u);
 
   const size_t max_plaintext_size =
       client_framer_.GetMaxPlaintextSize(creator_.max_packet_length());
   EXPECT_EQ(max_plaintext_size - creator_.PacketSize(), creator_.BytesFree());
 
   // Serialized length of ack frame with 2000 nack ranges should be limited by
   // the packet size.
   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u);
   size_t frame_len = client_framer_.GetSerializedFrameLength(
-      QuicFrame(&ack_frame), creator_.BytesFree(), true, true, NOT_IN_FEC_GROUP,
+      QuicFrame(&ack_frame), creator_.BytesFree(), true, true,
       PACKET_1BYTE_PACKET_NUMBER);
   EXPECT_EQ(creator_.BytesFree(), frame_len);
 
   // Add ack frame to creator.
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()),
             creator_.PacketSize());
   EXPECT_EQ(0u, creator_.BytesFree());
 
@@ skipping 177 matching lines @@
   EXPECT_CALL(delegate_, OnUnrecoverableError(_, _));
   QuicStreamFrame stream_frame(kHeadersStreamId, /*fin=*/false, 0u,
                                StringPiece());
   EXPECT_DFATAL(creator_.AddSavedFrame(QuicFrame(&stream_frame)),
                 "Cannot send stream data without encryption.");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net