Remove FEC from send 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 64 matching lines @@
   params.push_back(TestParams(all_supported_versions[0], true, max));
   return params;
 }
 
 class MockDelegate : public QuicPacketCreator::DelegateInterface {
  public:
   MockDelegate() {}
   ~MockDelegate() override {}
 
   MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet));
-  MOCK_METHOD0(OnResetFecGroup, void());
   MOCK_METHOD2(OnUnrecoverableError,
                void(QuicErrorCode, ConnectionCloseSource source));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
 class QuicPacketCreatorTest : public ::testing::TestWithParam<TestParams> {
  public:
   void ClearSerializedPacket(SerializedPacket* serialized_packet) {
@@ skipping 77 matching lines @@
     ASSERT_TRUE(frame.stream_frame);
     EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
     EXPECT_EQ(data, StringPiece(frame.stream_frame->frame_buffer,
                                 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(InFecGroup is_in_fec_group) {
+  size_t GetPacketHeaderOverhead() {
     return GetPacketHeaderSize(
         creator_.connection_id_length(), kIncludeVersion, !kIncludePathId,
         QuicPacketCreatorPeer::NextPacketNumberLength(&creator_),
-        is_in_fec_group);
+        NOT_IN_FEC_GROUP);
   }
 
   // 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(InFecGroup is_in_fec_group) {
+  size_t GetStreamFrameOverhead() {
     return QuicFramer::GetMinStreamFrameSize(kClientDataStreamId1, kOffset,
-                                             true, is_in_fec_group);
+                                             true, NOT_IN_FEC_GROUP);
   }
 
   QuicIOVector MakeIOVector(StringPiece s) {
     return ::net::MakeIOVector(s, &iov_);
   }
 
   PendingRetransmission CreateRetransmission(
       const QuicFrames& retransmittable_frames,
       bool has_crypto_handshake,
       bool needs_padding,
@@ skipping 55 matching lines @@
       EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
       EXPECT_CALL(framer_visitor_, OnAckFrame(_));
       EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
       EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
       EXPECT_CALL(framer_visitor_, OnPacketComplete());
     }
     ProcessPacket(serialized);
   }
 }
 
-TEST_P(QuicPacketCreatorTest, SerializeWithFEC) {
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  // Serialize the packet.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.Flush();
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized_packet_);
-  DeleteSerializedPacket();
-
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
-                                           /*is_fec_timeout=*/false);
-  ASSERT_EQ(2u, serialized_packet_.packet_number);
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecData(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized_packet_);
-  DeleteSerializedPacket();
-}
-
 TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
   frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u))));
   creator_.AddSavedFrame(frames_[0]);
   QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
                                                    PACKET_4BYTE_PACKET_NUMBER);
 
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
@@ skipping 110 matching lines @@
     EXPECT_CALL(framer_visitor_, OnPacketComplete());
   }
   ProcessPacket(serialized_packet_);
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
             header.public_header.packet_number_length);
 
   DeleteSerializedPacket();
   delete ack_frame.ack_frame;
 }
 
-TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
-  // Test goal is to test the following sequence (P1 => generate Packet 1):
-  // P1 <change seq num length> P2 FEC,
-  // and we expect that packet number length should not change until the end
-  // of the open FEC group.
-
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-
-  // Generate Packet 1.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  // Change the packet number length mid-FEC group and it should not change.
-  QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
-                                                   PACKET_4BYTE_PACKET_NUMBER);
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillRepeatedly(
-          Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.Flush();
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            serialized_packet_.packet_number_length);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized_packet_);
-  DeleteSerializedPacket();
-
-  // Generate Packet 2.
-  ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  creator_.Flush();
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            serialized_packet_.packet_number_length);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
-    EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized_packet_);
-  DeleteSerializedPacket();
-
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // Force generation of FEC packet.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  // Turn off FEC protection.
-  creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
-                                           /*is_fec_timeout=*/false);
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            serialized_packet_.packet_number_length);
-  ASSERT_EQ(3u, serialized_packet_.packet_number);
-
-  {
-    InSequence s;
-    EXPECT_CALL(framer_visitor_, OnPacket());
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
-    EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
-    EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
-    EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
-    EXPECT_CALL(framer_visitor_, OnFecData(_));
-    EXPECT_CALL(framer_visitor_, OnPacketComplete());
-  }
-  ProcessPacket(serialized_packet_);
-  DeleteSerializedPacket();
-
-  // Ensure the next FEC group starts using the new packet number length.
-  ASSERT_TRUE(creator_.ConsumeData(3u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.Flush();
-  EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
-            serialized_packet_.packet_number_length);
-  DeleteSerializedPacket();
-}
-
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
   // If the original packet number length, the current packet number
   // length, and the configured send packet number length are different, the
   // retransmit must sent with the original length and the others do not change.
   QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_,
                                                    PACKET_4BYTE_PACKET_NUMBER);
   QuicPacketCreatorPeer::SetPacketNumberLength(&creator_,
                                                PACKET_2BYTE_PACKET_NUMBER);
   QuicStreamFrame* stream_frame =
       new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, 0u, StringPiece());
@@ skipping 76 matching lines @@
       ENCRYPTION_NONE,
       QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.ReserializeAllFrames(retransmission, buffer, kMaxPacketSize);
   EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
   delete frame.stream_frame;
 }
 
 TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) {
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) +
-                          GetEncryptionOverhead() +
-                          GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
+  const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead() +
+                          GetStreamFrameOverhead();
   size_t capacity = kDefaultMaxPacketSize - overhead;
   for (int delta = -5; delta <= 0; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = 0 - delta;
 
     QuicFrame frame;
     QuicIOVector io_vector(MakeIOVector(data));
     UniqueStreamBuffer stream_buffer;
     QuicPacketCreatorPeer::CreateStreamFrame(
         &creator_, kCryptoStreamId, io_vector, 0, kOffset, false, &frame);
@@ skipping 40 matching lines @@
   EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_));
   EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
   EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_));
   EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
   EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
   EXPECT_CALL(framer_visitor_, OnPacketComplete());
 
   ProcessPacket(serialized);
 }
 
-TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) {
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-  // We do not have enough packets in the FEC group to trigger an FEC packet.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // Switching FEC off should not change creator state, since there is an
-  // FEC packet under construction.
-  EXPECT_DFATAL(QuicPacketCreatorPeer::StopFecProtectingPackets(&creator_),
-                "Cannot stop FEC protection with open FEC group.");
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  // Confirm that FEC packet is still under construction.
-  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  // Turn off FEC protection.
-  creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
-                                           /*is_fec_timeout=*/false);
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-}
-
-TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) {
-  // Add a stream frame to the creator.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  ASSERT_TRUE(frame.stream_frame);
-  size_t consumed = frame.stream_frame->frame_length;
-  EXPECT_EQ(4u, consumed);
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  // Enable FEC protection, and send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecEnabled(&creator_));
-  EXPECT_DFATAL(QuicPacketCreatorPeer::StartFecProtectingPackets(&creator_),
-                "Cannot start FEC protection with pending frames.");
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-
-  // Start FEC protection after current open packet is flushed.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  ASSERT_TRUE(frame.stream_frame);
-  consumed = frame.stream_frame->frame_length;
-  EXPECT_EQ(4u, consumed);
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-}
-
 TEST_P(QuicPacketCreatorTest, ConsumeData) {
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, 1u, "test", 0u, false);
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataFin) {
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 10u, true, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 10u, true, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   CheckStreamFrame(frame, 1u, "test", 10u, true);
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
 TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) {
   QuicFrame frame;
   QuicIOVector io_vector(nullptr, 0, 0);
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame,
-                                   MAY_FEC_PROTECT));
+  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(0u, consumed);
   CheckStreamFrame(frame, 1u, string(), 0u, true);
   EXPECT_TRUE(creator_.HasPendingFrames());
 }
 
-TEST_P(QuicPacketCreatorTest, ConsumeDataWithFecProtect) {
-  creator_.set_max_packets_per_fec_group(6);
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  ASSERT_TRUE(frame.stream_frame);
-  size_t consumed = frame.stream_frame->frame_length;
-  EXPECT_EQ(4u, consumed);
-  CheckStreamFrame(frame, 1u, "test", 0u, false);
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-}
-
 TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
-  const size_t overhead =
-      GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) + GetEncryptionOverhead();
+  const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead();
   for (size_t i = overhead; i < overhead + 100; ++i) {
     creator_.SetMaxPacketLength(i);
-    const bool should_have_room =
-        i > overhead + GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
+    const bool should_have_room = i > overhead + GetStreamFrameOverhead();
     ASSERT_EQ(should_have_room,
               creator_.HasRoomForStreamFrame(kClientDataStreamId1, kOffset));
     if (should_have_room) {
       QuicFrame frame;
       QuicIOVector io_vector(MakeIOVector("testdata"));
       EXPECT_CALL(delegate_, OnSerializedPacket(_))
           .WillRepeatedly(
               Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
       ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
-                                       kOffset, false, false, &frame,
-                                       MAY_FEC_PROTECT));
+                                       kOffset, false, false, &frame));
       ASSERT_TRUE(frame.stream_frame);
       size_t bytes_consumed = frame.stream_frame->frame_length;
       EXPECT_LT(0u, bytes_consumed);
       creator_.Flush();
     }
   }
 }
 
 TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) {
   // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) +
-                          GetEncryptionOverhead() +
-                          GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
+  const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead() +
+                          GetStreamFrameOverhead();
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
     QuicFrame frame;
     QuicIOVector io_vector(MakeIOVector(data));
     ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
-                                     kOffset, false, false, &frame,
-                                     MAY_FEC_PROTECT));
+                                     kOffset, false, false, &frame));
     ASSERT_TRUE(frame.stream_frame);
 
     // BytesFree() returns bytes available for the next frame, which will
     // be two bytes smaller since the stream frame would need to be grown.
     EXPECT_EQ(2u, creator_.ExpansionOnNewFrame());
     size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
     EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     creator_.Flush();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     DeleteSerializedPacket();
   }
 }
 
-TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) {
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-
-  // Serialize the packet.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-  // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP) +
-                          GetEncryptionOverhead() +
-                          GetStreamFrameOverhead(IN_FEC_GROUP);
-  size_t capacity = kDefaultMaxPacketSize - overhead;
-  // Now, test various sizes around this size.
-  for (int delta = -5; delta <= 5; ++delta) {
-    string data(capacity + delta, 'A');
-    size_t bytes_free = delta > 0 ? 0 : 0 - delta;
-    QuicFrame frame;
-    QuicIOVector io_vector(MakeIOVector(data));
-    ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
-                                     kOffset, false, false, &frame,
-                                     MUST_FEC_PROTECT));
-    ASSERT_TRUE(frame.stream_frame);
-    // BytesFree() returns bytes available for the next frame. Since stream
-    // frame does not grow for FEC protected packets, this should be the same
-    // as bytes_free (bound by 0).
-    EXPECT_EQ(0u, creator_.ExpansionOnNewFrame());
-    size_t expected_bytes_free = bytes_free > 0 ? bytes_free : 0;
-    EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
-    {
-      InSequence s;
-      EXPECT_CALL(delegate_, OnSerializedPacket(_))
-          .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-      // Every 6th packet will generate an extra FEC packet.
-      if (delta == -1 || delta == 5) {
-        EXPECT_CALL(delegate_, OnSerializedPacket(_))
-            .WillOnce(
-                Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-      }
-    }
-    creator_.Flush();
-    ASSERT_TRUE(serialized_packet_.encrypted_buffer);
-    DeleteSerializedPacket();
-  }
-}
-
 TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
   // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) +
-                          GetEncryptionOverhead() +
-                          GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
+  const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead() +
+                          GetStreamFrameOverhead();
   ASSERT_GT(kMaxPacketSize, overhead);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 
     QuicFrame frame;
     QuicIOVector io_vector(MakeIOVector(data));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillRepeatedly(
             Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     ASSERT_TRUE(creator_.ConsumeData(kCryptoStreamId, io_vector, 0u, kOffset,
-                                     false, true, &frame, MAY_FEC_PROTECT));
+                                     false, true, &frame));
     ASSERT_TRUE(frame.stream_frame);
     size_t bytes_consumed = frame.stream_frame->frame_length;
     EXPECT_LT(0u, bytes_consumed);
     creator_.Flush();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     // If there is not enough space in the packet to fit a padding frame
     // (1 byte) and to expand the stream frame (another 2 bytes) the packet
     // will not be padded.
     if (bytes_free < 3) {
       EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
                 serialized_packet_.encrypted_length);
     } else {
       EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
     }
     DeleteSerializedPacket();
   }
 }
 
 TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
   // Compute the total overhead for a single frame in packet.
-  const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) +
-                          GetEncryptionOverhead() +
-                          GetStreamFrameOverhead(NOT_IN_FEC_GROUP);
+  const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead() +
+                          GetStreamFrameOverhead();
   ASSERT_GT(kDefaultMaxPacketSize, overhead);
   size_t capacity = kDefaultMaxPacketSize - overhead;
   // Now, test various sizes around this size.
   for (int delta = -5; delta <= 5; ++delta) {
     string data(capacity + delta, 'A');
     size_t bytes_free = delta > 0 ? 0 : 0 - delta;
 
     QuicFrame frame;
     QuicIOVector io_vector(MakeIOVector(data));
     EXPECT_CALL(delegate_, OnSerializedPacket(_))
         .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
     ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u,
-                                     kOffset, false, false, &frame,
-                                     MAY_FEC_PROTECT));
+                                     kOffset, false, false, &frame));
     ASSERT_TRUE(frame.stream_frame);
     size_t bytes_consumed = frame.stream_frame->frame_length;
     EXPECT_LT(0u, bytes_consumed);
     creator_.Flush();
     ASSERT_TRUE(serialized_packet_.encrypted_buffer);
     if (bytes_free > 0) {
       EXPECT_EQ(kDefaultMaxPacketSize - bytes_free,
                 serialized_packet_.encrypted_length);
     } else {
       EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.encrypted_length);
@@ skipping 16 matching lines @@
     EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_));
   }
   QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_CLIENT);
   client_framer_.ProcessPacket(*encrypted);
 }
 
 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
-  size_t max_packets_per_fec_group = 10;
-  creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
-  QuicPacketCreatorPeer::SetPacketNumber(&creator_,
-                                         64 - max_packets_per_fec_group);
+  QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64);
   creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
-  QuicPacketCreatorPeer::SetPacketNumber(&creator_,
-                                         64 * 256 - max_packets_per_fec_group);
+  QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256);
   creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
   EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
-  QuicPacketCreatorPeer::SetPacketNumber(
-      &creator_, 64 * 256 * 256 - max_packets_per_fec_group);
+  QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256 * 256);
   creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
   EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
-  QuicPacketCreatorPeer::SetPacketNumber(
-      &creator_,
-      UINT64_C(64) * 256 * 256 * 256 * 256 - max_packets_per_fec_group);
+  QuicPacketCreatorPeer::SetPacketNumber(&creator_,
+                                         UINT64_C(64) * 256 * 256 * 256 * 256);
   creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
   EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 }
 
 TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) {
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
   creator_.UpdatePacketNumberLength(1, 10000 / kDefaultMaxPacketSize);
@@ skipping 51 matching lines @@
       client_framer_.version(),
       QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
       QuicPacketCreatorPeer::SendPathIdInPacket(&creator_),
       creator_.connection_id_length(), PACKET_1BYTE_PACKET_NUMBER,
       NOT_IN_FEC_GROUP, &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,
-                                   MAY_FEC_PROTECT));
+  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) {
@@ skipping 11 matching lines @@
                     PACKET_1BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
             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(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   QuicPaddingFrame padding_frame;
   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(padding_frame)));
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.BytesFree());
 
@@ skipping 38 matching lines @@
 
   // 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());
 
   // Make sure that an additional stream frame can be added to the packet.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   // Ensure the packet is successfully created, and the packet size estimate
   // matches the serialized packet length.
   EXPECT_CALL(entropy_calculator_, EntropyHash(_)).WillOnce(testing::Return(0));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
@@ skipping 59 matching lines @@
       EXPECT_EQ(expected_rand_bool, observed_rand_bool);
       EXPECT_EQ(0, rest_of_hash);
     }
     // After 64 calls, BoolSource will refresh the bucket - make sure it does.
     mock_random_.ChangeValue();
   }
 
   delete frames_[0].stream_frame;
 }
 
-TEST_P(QuicPacketCreatorTest, ResetFecGroup) {
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Add a stream frame and turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  // Serialize the packet.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  EXPECT_TRUE(creator_.IsFecGroupOpen());
-  // We do not have enough packets in the FEC group to trigger an FEC packet.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // FEC group will be reset if FEC police is alarm trigger but FEC alarm does
-  // not fire.
-  EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
-  creator_.set_fec_send_policy(FEC_ALARM_TRIGGER);
-  creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
-                                           /*is_fec_timeout=*/false);
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  EXPECT_FALSE(creator_.IsFecGroupOpen());
-  // We do not have enough packets in the FEC group to trigger an FEC packet.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Confirm that there is no FEC packet under construction.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  char buffer[kMaxPacketSize];
-  EXPECT_DFATAL(
-      QuicPacketCreatorPeer::SerializeFec(&creator_, buffer, kMaxPacketSize),
-      "SerializeFEC called but no group or zero packets in group.");
-
-  // Create and send a new FEC protected packet.
-  ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  EXPECT_TRUE(creator_.IsFecGroupOpen());
-  // We do not have enough packets in the FEC group to trigger an FEC packet.
-  EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // Should return false since we do not have enough packets in the FEC group to
-  // trigger an FEC packet.
-  ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false));
-  // Should return true since there are packets in the FEC group.
-  ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true));
-
-  // Change FEC policy, send FEC packet and close FEC group.
-  creator_.set_fec_send_policy(FEC_ANY_TRIGGER);
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
-  creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
-                                           /*is_fec_timeout=*/false);
-  ASSERT_EQ(3u, serialized_packet_.packet_number);
-  DeleteSerializedPacket();
-}
-
-TEST_P(QuicPacketCreatorTest, ResetFecGroupWithQueuedFrames) {
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Add a stream frame to the creator and turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  ASSERT_TRUE(frame.stream_frame);
-  size_t consumed = frame.stream_frame->frame_length;
-  EXPECT_EQ(4u, consumed);
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_DFATAL(QuicPacketCreatorPeer::ResetFecGroup(&creator_),
-                "Cannot reset FEC group with pending frames.");
-
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-  EXPECT_FALSE(creator_.HasPendingFrames());
-
-  // FEC group will be reset if FEC police is alarm trigger but FEC alarm does
-  // not fire.
-  EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1);
-  creator_.set_fec_send_policy(FEC_ALARM_TRIGGER);
-  creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true,
-                                           /*is_fec_timeout=*/false);
-  EXPECT_FALSE(creator_.IsFecGroupOpen());
-}
-
 TEST_P(QuicPacketCreatorTest, SetCurrentPath) {
   // Current path is the default path.
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_EQ(0u, creator_.packet_number());
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
   // Add a stream frame to the creator.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
 
   // Change current path.
   QuicPathId kPathId1 = 1;
   EXPECT_DFATAL(creator_.SetCurrentPath(kPathId1, 1, 0),
                 "Unable to change paths when a packet is under construction");
@@ skipping 10 matching lines @@
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
   // Change current path back.
   creator_.SetCurrentPath(kDefaultPathId, 2, 1);
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_EQ(1u, creator_.packet_number());
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
   // Add a stream frame to the creator.
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
 
   // Does not change current path.
   creator_.SetCurrentPath(kDefaultPathId, 2, 0);
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(1u, creator_.packet_number());
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 }
 
-TEST_P(QuicPacketCreatorTest, SetCurrentPathWithFec) {
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Current path is the default path.
-  EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
-  EXPECT_EQ(0u, creator_.packet_number());
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  // Add a stream frame to the creator.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  ASSERT_TRUE(frame.stream_frame);
-  size_t consumed = frame.stream_frame->frame_length;
-  EXPECT_EQ(4u, consumed);
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  EXPECT_EQ(0u, creator_.packet_number());
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-
-  // Change current path.
-  QuicPathId kPathId1 = 1;
-  EXPECT_DFATAL(creator_.SetCurrentPath(kPathId1, 1, 0),
-                "Unable to change paths when a packet is under construction");
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .Times(2)
-      .WillRepeatedly(
-          Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  creator_.SetCurrentPath(kPathId1, 1, 0);
-  EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
-  EXPECT_FALSE(creator_.HasPendingFrames());
-  EXPECT_EQ(0u, creator_.packet_number());
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
-  EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-
-  // Change current path back.
-  creator_.SetCurrentPath(kDefaultPathId, 3, 2);
-  EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
-  // FEC packet consumes a packet number.
-  EXPECT_EQ(2u, creator_.packet_number());
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
-  // Add a stream frame to the creator.
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
-  ASSERT_TRUE(frame.stream_frame);
-  consumed = frame.stream_frame->frame_length;
-  EXPECT_EQ(4u, consumed);
-  EXPECT_TRUE(creator_.HasPendingFrames());
-
-  // Does not change current path.
-  creator_.SetCurrentPath(kDefaultPathId, 3, 0);
-  EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
-  EXPECT_TRUE(creator_.HasPendingFrames());
-  // FEC packet consumes a packet number.
-  EXPECT_EQ(2u, creator_.packet_number());
-  EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
-            QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-}
-
 TEST_P(QuicPacketCreatorTest,
-       SetCurrentPathWithFecAndUpdatePacketSequenceNumberLength) {
-  // Send FEC packet every 10 packets.
-  size_t max_packets_per_fec_group = 10;
-  creator_.set_max_packets_per_fec_group(max_packets_per_fec_group);
+       SetCurrentPathAndUpdatePacketSequenceNumberLength) {
   // Current path is the default path.
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
-  QuicPacketCreatorPeer::SetPacketNumber(
-      &creator_, 64 * 256 - max_packets_per_fec_group - 2);
+  QuicPacketCreatorPeer::SetPacketNumber(&creator_, 64 * 256 - 2);
   // Add a stream frame to the creator and send the packet.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MUST_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .Times(2)
+      .Times(1)
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
   creator_.Flush();
-  EXPECT_EQ(64 * 256 - max_packets_per_fec_group - 1, creator_.packet_number());
+  EXPECT_EQ(UINT64_C(64 * 256 - 1), creator_.packet_number());
   creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize);
   EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
   // Change current path.
   QuicPathId kPathId1 = 1;
   creator_.SetCurrentPath(kPathId1, 1, 0);
   EXPECT_EQ(0u, creator_.packet_number());
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
   // Change current path back.
   creator_.SetCurrentPath(kDefaultPathId, 2, 10000 / kDefaultMaxPacketSize);
-  // FEC packet consumes a packet number.
-  EXPECT_EQ(64 * 256 - max_packets_per_fec_group, creator_.packet_number());
+  EXPECT_EQ(UINT64_C(64 * 256 - 1), creator_.packet_number());
   EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 }
 
 TEST_P(QuicPacketCreatorTest, SerializePacketOnDifferentPath) {
   // Current path is the default path.
   EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_EQ(0u, creator_.packet_number());
   // Add a stream frame to the creator and flush the packet.
   QuicFrame frame;
   QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   size_t consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
   EXPECT_CALL(delegate_, OnSerializedPacket(_))
       .WillRepeatedly(
           Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
   creator_.Flush();
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(1u, creator_.packet_number());
   // Verify serialized data packet's path id.
   EXPECT_EQ(kDefaultPathId, serialized_packet_.path_id);
   DeleteSerializedPacket();
 
   // Change to path 1.
   QuicPathId kPathId1 = 1;
   creator_.SetCurrentPath(kPathId1, 1, 0);
   EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_));
   EXPECT_FALSE(creator_.HasPendingFrames());
   EXPECT_EQ(0u, creator_.packet_number());
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             QuicPacketCreatorPeer::NextPacketNumberLength(&creator_));
 
   // Add a stream frame to the creator and flush the packet.
-  ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame,
-                                   MAY_FEC_PROTECT));
+  ASSERT_TRUE(
+      creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame));
   ASSERT_TRUE(frame.stream_frame);
   consumed = frame.stream_frame->frame_length;
   EXPECT_EQ(4u, consumed);
   EXPECT_TRUE(creator_.HasPendingFrames());
   creator_.Flush();
   // Verify serialized data packet's path id.
   EXPECT_EQ(kPathId1, serialized_packet_.path_id);
   DeleteSerializedPacket();
 }
 
 TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) {
   FLAGS_quic_never_write_unencrypted_data = true;
   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.");
 }
 
-TEST_P(QuicPacketCreatorTest, DontSendUnencryptedFec) {
-  ValueRestore<bool> old_flag(&FLAGS_quic_no_unencrypted_fec, true);
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Send stream data encrypted with FEC protection.
-  creator_.set_encryption_level(ENCRYPTION_INITIAL);
-  // Turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(kHeadersStreamId, io_vector, 0u, 0u, false,
-                                   false, &frame, MUST_FEC_PROTECT));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  // Serialize the packet.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-
-  // The creator will clear the FEC group rather than try to send without
-  // encryption.
-  creator_.set_encryption_level(ENCRYPTION_NONE);
-  EXPECT_CALL(delegate_, OnResetFecGroup());
-  creator_.MaybeSendFecPacketAndCloseGroup(true, false);
-}
-
-TEST_P(QuicPacketCreatorTest, SerializeUnencryptedFecClosesConnection) {
-  ValueRestore<bool> old_flag(&FLAGS_quic_no_unencrypted_fec, true);
-  // Send FEC packet every 6 packets.
-  creator_.set_max_packets_per_fec_group(6);
-  // Send stream data encrypted with FEC protection.
-  creator_.set_encryption_level(ENCRYPTION_INITIAL);
-  // Turn on FEC protection.
-  QuicFrame frame;
-  QuicIOVector io_vector(MakeIOVector("test"));
-  ASSERT_TRUE(creator_.ConsumeData(kHeadersStreamId, io_vector, 0u, 0u, false,
-                                   false, &frame, MUST_FEC_PROTECT));
-  EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_));
-  // Serialize the packet.
-  EXPECT_CALL(delegate_, OnSerializedPacket(_))
-      .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket));
-  creator_.Flush();
-
-  // Try to send an FEC packet unencrypted.
-  creator_.set_encryption_level(ENCRYPTION_NONE);
-  EXPECT_CALL(delegate_, OnUnrecoverableError(QUIC_UNENCRYPTED_FEC_DATA, _));
-  char seralized_fec_buffer[kMaxPacketSize];
-  EXPECT_DFATAL(QuicPacketCreatorPeer::SerializeFec(
-                    &creator_, seralized_fec_buffer, kMaxPacketSize),
-                "SerializeFEC must be called with encryption.");
-}
-
 }  // namespace
 }  // namespace test
 }  // namespace net