relnote: Remove remaining now unused FEC code from QUIC. Merge internal change: 135007563

net/quic/core/quic_framer_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/core/quic_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 225 matching lines @@
     return accept_public_header_;
   }
 
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override {
     return true;
   }
 
   void OnDecryptedPacket(EncryptionLevel level) override {}
 
   bool OnPacketHeader(const QuicPacketHeader& header) override {
-    if (header.fec_flag) {
-      // Drop any FEC packet.
-      return false;
-    }
     ++packet_count_;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
   bool OnStreamFrame(const QuicStreamFrame& frame) override {
     ++frame_count_;
     // Save a copy of the data so it is valid after the packet is processed.
     string* string_data = new string();
     StringPiece(frame.data_buffer, frame.data_length)
@@ skipping 419 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
                                PACKET_6BYTE_PACKET_NUMBER);
@@ skipping 49 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_0BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
                                PACKET_6BYTE_PACKET_NUMBER);
@@ skipping 54 matching lines @@
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
                                PACKET_6BYTE_PACKET_NUMBER);
@@ skipping 55 matching lines @@
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion, kIncludePathId,
                               !kIncludeDiversificationNonce));
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_TRUE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPathId, visitor_.header_->path_id);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, kIncludePathId,
                                !kIncludeDiversificationNonce,
@@ skipping 62 matching lines @@
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion, kIncludePathId,
                               !kIncludeDiversificationNonce));
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_TRUE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPathId, visitor_.header_->path_id);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, kIncludePathId,
                                !kIncludeDiversificationNonce,
@@ skipping 224 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34),
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
                                PACKET_4BYTE_PACKET_NUMBER);
@@ skipping 56 matching lines @@
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER,
             visitor_.header_->public_header.packet_number_length);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
                                PACKET_2BYTE_PACKET_NUMBER);
@@ skipping 56 matching lines @@
       false);
   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_EQ(kConnectionId, visitor_.header_->public_header.connection_id);
   EXPECT_FALSE(visitor_.header_->public_header.multipath_flag);
   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
   EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER,
             visitor_.header_->public_header.packet_number_length);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
   EXPECT_FALSE(visitor_.header_->entropy_flag);
   EXPECT_EQ(0, visitor_.header_->entropy_hash);
   EXPECT_EQ(kPacketNumber, visitor_.header_->packet_number);
 
   // Now test framing boundaries.
   for (size_t i = 0;
        i < GetPacketHeaderSize(framer_.version(), PACKET_8BYTE_CONNECTION_ID,
                                !kIncludeVersion, !kIncludePathId,
                                !kIncludeDiversificationNonce,
                                PACKET_1BYTE_PACKET_NUMBER);
@@ skipping 22 matching lines @@
 }
 
 TEST_P(QuicFramerTest, PacketNumberDecreasesThenIncreases) {
   FLAGS_quic_packet_numbers_largest_received = true;
   // Test the case when a packet is received from the past and future packet
   // numbers are still calculated relative to the largest received packet.
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.packet_number = kPacketNumber - 2;
 
   QuicPaddingFrame padding_frame;
   QuicFrames frames;
   frames.push_back(QuicFrame(padding_frame));
   std::unique_ptr<QuicPacket> data(BuildDataPacket(header, frames));
   ASSERT_TRUE(data != nullptr);
 
   QuicEncryptedPacket encrypted(data->data(), data->length(), false);
@@ skipping 231 matching lines @@
     // frame type (padding)
     0x00,
     0x00, 0x00, 0x00, 0x00
   };
   // clang-format on
   CheckProcessingFails(packet, arraysize(packet),
                        "Illegal private flags value.",
                        QUIC_INVALID_PACKET_HEADER);
 };
 
-TEST_P(QuicFramerTest, InvalidFECGroupOffset) {
-  if (framer_.version() > QUIC_VERSION_33) {
-    return;
-  }
-  // clang-format off
-  unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x38,
-    // connection_id
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet number
-    0x01, 0x00, 0x00, 0x00,
-    0x00, 0x00,
-    // private flags (fec group)
-    0x02,
-    // first fec protected packet offset
-    0x10
-  };
-  // clang-format on
-  CheckProcessingFails(packet, arraysize(packet),
-                       "Illegal private flags value.",
-                       QUIC_INVALID_PACKET_HEADER);
-
-};
-
 TEST_P(QuicFramerTest, PaddingFrame) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
     0x38,
     // connection_id
     0x10, 0x32, 0x54, 0x76,
     0x98, 0xBA, 0xDC, 0xFE,
     // packet number
     0xBC, 0x9A, 0x78, 0x56,
@@ skipping 2192 matching lines @@
     } else if (i < kVersionOffset) {
       expected_error = "Unable to read ConnectionId.";
     } else {
       expected_error = "Unable to read supported version in negotiation.";
       error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET;
     }
     CheckProcessingFails(packet, i, expected_error, error_code);
   }
 }
 
-TEST_P(QuicFramerTest, DropFecPacket) {
-  // clang-format off
-  unsigned char packet[] = {
-    // public flags (8 byte connection_id)
-    0x38,
-    // connection_id
-    0x10, 0x32, 0x54, 0x76,
-    0x98, 0xBA, 0xDC, 0xFE,
-    // packet number
-    0xBC, 0x9A, 0x78, 0x56,
-    0x34, 0x12,
-    // private flags (fec group & FEC)
-    0x06,
-    // first fec protected packet offset
-    0x01,
-
-    // redundancy
-    'a',  'b',  'c',  'd',
-    'e',  'f',  'g',  'h',
-    'i',  'j',  'k',  'l',
-    'm',  'n',  'o',  'p',
-  };
-  if (framer_.version() > QUIC_VERSION_33) {
-    return;
-  }
-  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
-  EXPECT_FALSE(framer_.ProcessPacket(encrypted));
-  EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
-  EXPECT_FALSE(visitor_.header_.get());
-}
-
 TEST_P(QuicFramerTest, BuildPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.packet_number = kPacketNumber;
 
   QuicPaddingFrame padding_frame;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(padding_frame));
 
   // clang-format off
   unsigned char packet[kMaxPacketSize] = {
@@ skipping 45 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.public_header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
   header.packet_number = kPacketNumber;
 
   QuicPaddingFrame padding_frame;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(padding_frame));
 
   // clang-format off
@@ skipping 44 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER;
   header.packet_number = kPacketNumber;
 
   QuicPaddingFrame padding_frame;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(padding_frame));
 
   // clang-format off
@@ skipping 44 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header.packet_number = kPacketNumber;
 
   QuicPaddingFrame padding_frame;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(padding_frame));
 
   // clang-format off
@@ skipping 44 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stream_frame));
 
   // clang-format off
@@ skipping 54 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = true;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stream_frame));
 
   // clang-format off
@@ skipping 50 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithMultipathFlag) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.multipath_flag = true;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.path_id = kPathId;
   header.packet_number = kPacketNumber;
 
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stream_frame));
 
@@ skipping 60 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildStreamFramePacketWithBothVersionAndMultipathFlag) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.multipath_flag = true;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = true;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.path_id = kPathId;
   header.packet_number = kPacketNumber;
 
   QuicStreamFrame stream_frame(kStreamId, true, kStreamOffset,
                                StringPiece("hello world!"));
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stream_frame));
 
@@ skipping 89 matching lines @@
 
 TEST_P(QuicFramerTest, BuildAckFramePacket) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicAckFrame ack_frame;
   ack_frame.entropy_hash = 0x43;
   ack_frame.largest_observed = kLargestObserved;
   ack_frame.ack_delay_time = QuicTime::Delta::Zero();
   ack_frame.packets.Add(kMissingPacket);
 
   QuicFrames frames;
@@ skipping 44 matching lines @@
 
 TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicAckFrame ack_frame;
   // This entropy hash is different from what shows up in the packet below,
   // since entropy is recomputed by the framer on ack truncation (by
   // TestEntropyCalculator for this test.)
   ack_frame.entropy_hash = 0x43;
   ack_frame.largest_observed = 2 * 300;
   ack_frame.ack_delay_time = QuicTime::Delta::Zero();
@@ skipping 91 matching lines @@
 
 TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
 
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicAckFrame ack_frame;
   // This entropy hash is different from what shows up in the packet below,
   // since entropy is recomputed by the framer on ack truncation (by
   // TestEntropyCalculator for this test.)
   ack_frame.entropy_hash = 0x43;
   ack_frame.largest_observed = 2 * 300;
   ack_frame.ack_delay_time = QuicTime::Delta::Zero();
@@ skipping 297 matching lines @@
 }
 
 TEST_P(QuicFramerTest, BuildStopWaitingPacket) {
   if (framer_.version() > QUIC_VERSION_33) {
     return;
   }
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicStopWaitingFrame stop_waiting_frame;
   stop_waiting_frame.entropy_hash = 0x14;
   stop_waiting_frame.least_unacked = kLeastUnacked;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stop_waiting_frame));
 
@@ skipping 29 matching lines @@
 }
 
 TEST_P(QuicFramerTest, BuildNewStopWaitingPacket) {
   if (framer_.version() <= QUIC_VERSION_33) {
     return;
   }
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.packet_number = kPacketNumber;
 
   QuicStopWaitingFrame stop_waiting_frame;
   stop_waiting_frame.least_unacked = kLeastUnacked;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&stop_waiting_frame));
 
   // clang-format off
@@ skipping 20 matching lines @@
   test::CompareCharArraysWithHexError("constructed packet", data->data(),
                                       data->length(), AsChars(packet),
                                       arraysize(packet));
 }
 
 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.packet_number = kPacketNumber;
 
   QuicRstStreamFrame rst_frame;
   rst_frame.stream_id = kStreamId;
   rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
   rst_frame.byte_offset = 0x0807060504030201;
 
   // clang-format off
   unsigned char packet[] = {
@@ skipping 52 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildCloseFramePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicConnectionCloseFrame close_frame;
   close_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
   close_frame.error_details = "because I can";
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&close_frame));
 
@@ skipping 56 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicGoAwayFrame goaway_frame;
   goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
   goaway_frame.last_good_stream_id = kStreamId;
   goaway_frame.reason_phrase = "because I can";
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&goaway_frame));
@@ skipping 60 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicWindowUpdateFrame window_update_frame;
   window_update_frame.stream_id = kStreamId;
   window_update_frame.byte_offset = 0x1122334455667788;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&window_update_frame));
 
@@ skipping 47 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildBlockedPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicBlockedFrame blocked_frame;
   blocked_frame.stream_id = kStreamId;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(&blocked_frame));
 
   // clang-format off
@@ skipping 40 matching lines @@
       AsChars(framer_.version() <= QUIC_VERSION_33 ? packet : packet_34),
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildPingPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicPingFrame ping_frame;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(ping_frame));
 
   // clang-format off
   unsigned char packet[] = {
@@ skipping 37 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 TEST_P(QuicFramerTest, BuildPathClosePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.multipath_flag = true;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.path_id = kDefaultPathId;
   header.packet_number = kPacketNumber;
 
   QuicPathCloseFrame path_close;
   path_close.path_id = kPathId;
   QuicFrames frames;
   frames.push_back(QuicFrame(&path_close));
 
   // clang-format off
@@ skipping 42 matching lines @@
       framer_.version() <= QUIC_VERSION_33 ? arraysize(packet)
                                            : arraysize(packet_34));
 }
 
 // Test that the MTU discovery packet is serialized correctly as a PING packet.
 TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicMtuDiscoveryFrame mtu_discovery_frame;
 
   QuicFrames frames;
   frames.push_back(QuicFrame(mtu_discovery_frame));
 
   // clang-format off
   unsigned char packet[] = {
@@ skipping 415 matching lines @@
 
   ASSERT_NE(0u, encrypted_length);
   EXPECT_TRUE(CheckEncryption(kPathId, packet_number, raw.get()));
 }
 
 TEST_P(QuicFramerTest, AckTruncationLargePacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.packet_number = kPacketNumber;
 
   QuicAckFrame ack_frame;
   // Create a packet with just the ack.
   if (framer_.version() <= QUIC_VERSION_33) {
     ack_frame = MakeAckFrameWithNackRanges(300, 0u);
   } else {
     ack_frame = MakeAckFrameWithAckBlocks(300, 0u);
   }
@@ skipping 31 matching lines @@
     EXPECT_EQ(90u, processed_ack_frame.packets.Min());
     EXPECT_EQ(600u, processed_ack_frame.packets.Max());
   }
 }
 
 TEST_P(QuicFramerTest, AckTruncationSmallPacket) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = false;
   header.packet_number = kPacketNumber;
 
   // Create a packet with just the ack.
   QuicAckFrame ack_frame;
   if (framer_.version() <= QUIC_VERSION_33) {
     ack_frame = MakeAckFrameWithNackRanges(300, 0u);
   } else {
     ack_frame = MakeAckFrameWithAckBlocks(300, 0u);
   }
@@ skipping 32 matching lines @@
     EXPECT_EQ(124u, processed_ack_frame.packets.Min());
     EXPECT_EQ(600u, processed_ack_frame.packets.Max());
   }
 }
 
 TEST_P(QuicFramerTest, CleanTruncation) {
   QuicPacketHeader header;
   header.public_header.connection_id = kConnectionId;
   header.public_header.reset_flag = false;
   header.public_header.version_flag = false;
-  header.fec_flag = false;
   header.entropy_flag = true;
   header.packet_number = kPacketNumber;
 
   QuicAckFrame ack_frame;
   ack_frame.largest_observed = 201;
   ack_frame.packets.Add(1, ack_frame.largest_observed);
 
   // Create a packet with just the ack.
   QuicFrame frame;
   frame.type = ACK_FRAME;
@@ skipping 59 matching lines @@
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(visitor_.header_->entropy_flag);
   EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
-  EXPECT_FALSE(visitor_.header_->fec_flag);
 };
 
 TEST_P(QuicFramerTest, StopPacketProcessing) {
   // clang-format off
   unsigned char packet[] = {
     // public flags (8 byte connection_id)
     static_cast<unsigned char>(
         framer_.version() > QUIC_VERSION_32 ? 0x38 : 0x3C),
     // connection_id
     0x10, 0x32, 0x54, 0x76,
@@ skipping 243 matching lines @@
     'o',  ' ',  'w',  'o',
     'r',  'l',  'd',  '!',
   };
   // clang-format on
 
   QuicFramerFuzzFunc(packet, arraysize(packet));
 }
 
 }  // namespace test
 }  // namespace net