Remove FEC code from receive path.

net/quic/quic_packet_creator.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 <algorithm>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 151 matching lines @@
     return false;
   }
   if (needs_padding) {
     packet_.needs_padding = true;
   }
   return true;
 }
 
 bool QuicPacketCreator::HasRoomForStreamFrame(QuicStreamId id,
                                               QuicStreamOffset offset) {
-  return BytesFree() >
-         QuicFramer::GetMinStreamFrameSize(id, offset, true, NOT_IN_FEC_GROUP);
+  return BytesFree() > QuicFramer::GetMinStreamFrameSize(id, offset, true);
 }
 
 // static
 size_t QuicPacketCreator::StreamFramePacketOverhead(
     QuicConnectionIdLength connection_id_length,
     bool include_version,
     bool include_path_id,
     QuicPacketNumberLength packet_number_length,
-    QuicStreamOffset offset,
-    InFecGroup is_in_fec_group) {
+    QuicStreamOffset offset) {
   return GetPacketHeaderSize(connection_id_length, include_version,
-                             include_path_id, packet_number_length,
-                             is_in_fec_group) +
+                             include_path_id, packet_number_length) +
          // Assumes this is a stream with a single lone packet.
-         QuicFramer::GetMinStreamFrameSize(1u, offset, true, is_in_fec_group);
+         QuicFramer::GetMinStreamFrameSize(1u, offset, true);
 }
 
 size_t QuicPacketCreator::CreateStreamFrame(QuicStreamId id,
                                             QuicIOVector iov,
                                             size_t iov_offset,
                                             QuicStreamOffset offset,
                                             bool fin,
                                             QuicFrame* frame) {
   DCHECK_GT(max_packet_length_,
-            StreamFramePacketOverhead(
-                connection_id_length_, kIncludeVersion, kIncludePathId,
-                PACKET_6BYTE_PACKET_NUMBER, offset, IN_FEC_GROUP));
+            StreamFramePacketOverhead(connection_id_length_, kIncludeVersion,
+                                      kIncludePathId,
+                                      PACKET_6BYTE_PACKET_NUMBER, offset));
 
   MaybeUpdatePacketNumberLength();
 
   LOG_IF(DFATAL, !HasRoomForStreamFrame(id, offset))
       << "No room for Stream frame, BytesFree: " << BytesFree()
       << " MinStreamFrameSize: "
-      << QuicFramer::GetMinStreamFrameSize(id, offset, true, NOT_IN_FEC_GROUP);
+      << QuicFramer::GetMinStreamFrameSize(id, offset, true);
 
   if (iov_offset == iov.total_length) {
     QUIC_BUG_IF(!fin) << "Creating a stream frame with no data or fin.";
     // Create a new packet for the fin, if necessary.
     *frame = QuicFrame(new QuicStreamFrame(id, true, offset, StringPiece()));
     return 0;
   }
 
   const size_t data_size = iov.total_length - iov_offset;
   size_t min_frame_size = QuicFramer::GetMinStreamFrameSize(
-      id, offset, /* last_frame_in_packet= */ true, NOT_IN_FEC_GROUP);
+      id, offset, /* last_frame_in_packet= */ true);
   size_t bytes_consumed = min<size_t>(BytesFree() - min_frame_size, data_size);
 
   bool set_fin = fin && bytes_consumed == data_size;  // Last frame.
   UniqueStreamBuffer buffer =
       NewStreamBuffer(buffer_allocator_, bytes_consumed);
   CopyToBuffer(iov, iov_offset, bytes_consumed, buffer.get());
   *frame = QuicFrame(new QuicStreamFrame(id, set_fin, offset, bytes_consumed,
                                          std::move(buffer)));
   return bytes_consumed;
 }
@@ skipping 156 matching lines @@
 }
 
 size_t QuicPacketCreator::PacketSize() {
   if (!queued_frames_.empty()) {
     return packet_size_;
   }
   // Update packet number length on packet boundary.
   packet_.packet_number_length = next_packet_number_length_;
   packet_size_ = GetPacketHeaderSize(
       connection_id_length_, send_version_in_packet_, send_path_id_in_packet_,
-      packet_.packet_number_length, NOT_IN_FEC_GROUP);
+      packet_.packet_number_length);
   return packet_size_;
 }
 
 bool QuicPacketCreator::AddSavedFrame(const QuicFrame& frame) {
   return AddFrame(frame, /*save_retransmittable_frames=*/true);
 }
 
 bool QuicPacketCreator::AddPaddedSavedFrame(const QuicFrame& frame) {
   if (AddFrame(frame, /*save_retransmittable_frames=*/true)) {
     packet_.needs_padding = true;
@@ skipping 115 matching lines @@
       frame.stream_frame->stream_id != kCryptoStreamId &&
       packet_.encryption_level == ENCRYPTION_NONE) {
     QUIC_BUG << "Cannot send stream data without encryption.";
     delegate_->OnUnrecoverableError(QUIC_UNENCRYPTED_STREAM_DATA,
                                     ConnectionCloseSource::FROM_SELF);
     return false;
   }
   MaybeUpdatePacketNumberLength();
 
   size_t frame_len = framer_->GetSerializedFrameLength(
-      frame, BytesFree(), queued_frames_.empty(), true, NOT_IN_FEC_GROUP,
+      frame, BytesFree(), queued_frames_.empty(), true,
       packet_.packet_number_length);
   if (frame_len == 0) {
     // Current open packet is full.
     Flush();
     return false;
   }
   DCHECK_LT(0u, packet_size_);
   packet_size_ += ExpansionOnNewFrame() + frame_len;
 
   if (save_retransmittable_frames && ShouldRetransmit(frame)) {
@@ skipping 57 matching lines @@
   packet_.packet_number = it == multipath_packet_number_.end() ? 0 : it->second;
   packet_.path_id = path_id;
   DCHECK(packet_.path_id != kInvalidPathId);
   // Send path in packet if current path is not the default path.
   send_path_id_in_packet_ = packet_.path_id != kDefaultPathId ? true : false;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net