Update from https://crrev.com/316786

net/quic/quic_protocol.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_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
@@ skipping 491 matching lines @@
       byte_offset(byte_offset) {}
 
 QuicBlockedFrame::QuicBlockedFrame(QuicStreamId stream_id)
     : stream_id(stream_id) {}
 
 QuicPacket::QuicPacket(char* buffer,
                        size_t length,
                        bool owns_buffer,
                        QuicConnectionIdLength connection_id_length,
                        bool includes_version,
-                       QuicSequenceNumberLength sequence_number_length,
-                       bool is_fec_packet)
+                       QuicSequenceNumberLength sequence_number_length)
     : QuicData(buffer, length, owns_buffer),
       buffer_(buffer),
-      is_fec_packet_(is_fec_packet),
       connection_id_length_(connection_id_length),
       includes_version_(includes_version),
       sequence_number_length_(sequence_number_length) {
 }
 
 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer,
                                          size_t length)
     : QuicData(buffer, length) {
 }
 
@@ skipping 98 matching lines @@
   return frames_.back();
 }
 
 void RetransmittableFrames::set_encryption_level(EncryptionLevel level) {
   encryption_level_ = level;
 }
 
 SerializedPacket::SerializedPacket(
     QuicPacketSequenceNumber sequence_number,
     QuicSequenceNumberLength sequence_number_length,
-    QuicPacket* packet,
+    QuicEncryptedPacket* packet,
     QuicPacketEntropyHash entropy_hash,
     RetransmittableFrames* retransmittable_frames)
     : sequence_number(sequence_number),
       sequence_number_length(sequence_number_length),
       packet(packet),
       entropy_hash(entropy_hash),
-      retransmittable_frames(retransmittable_frames) {
+      retransmittable_frames(retransmittable_frames),
+      is_fec_packet(false) {
 }
 
 SerializedPacket::~SerializedPacket() {}
 
 QuicEncryptedPacket* QuicEncryptedPacket::Clone() const {
   char* buffer = new char[this->length()];
   memcpy(buffer, this->data(), this->length());
   return new QuicEncryptedPacket(buffer, this->length(), true);
 }
 
@@ skipping 24 matching lines @@
       sent_time(sent_time),
       bytes_sent(0),
       nack_count(0),
       transmission_type(transmission_type),
       all_transmissions(nullptr),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(false) {}
 
 }  // namespace net