Remove FEC code from receive path.

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_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::map;
 using std::numeric_limits;
 using std::ostream;
 using std::string;
 
 namespace net {
 
 const char* const kFinalOffsetHeaderKey = ":final-offset";
 
 size_t GetPacketHeaderSize(const QuicPacketHeader& header) {
-  return GetPacketHeaderSize(
-      header.public_header.connection_id_length,
-      header.public_header.version_flag, header.public_header.multipath_flag,
-      header.public_header.packet_number_length, header.is_in_fec_group);
+  return GetPacketHeaderSize(header.public_header.connection_id_length,
+                             header.public_header.version_flag,
+                             header.public_header.multipath_flag,
+                             header.public_header.packet_number_length);
 }
 
 size_t GetPacketHeaderSize(QuicConnectionIdLength connection_id_length,
                            bool include_version,
                            bool include_path_id,
-                           QuicPacketNumberLength packet_number_length,
-                           InFecGroup is_in_fec_group) {
+                           QuicPacketNumberLength packet_number_length) {
   return kPublicFlagsSize + connection_id_length +
          (include_version ? kQuicVersionSize : 0) +
          (include_path_id ? kQuicPathIdSize : 0) + packet_number_length +
-         kPrivateFlagsSize +
-         (is_in_fec_group == IN_FEC_GROUP ? kFecGroupSize : 0);
-}
-
-size_t GetStartOfFecProtectedData(QuicConnectionIdLength connection_id_length,
-                                  bool include_version,
-                                  bool include_path_id,
-                                  QuicPacketNumberLength packet_number_length) {
-  return GetPacketHeaderSize(connection_id_length, include_version,
-                             include_path_id, packet_number_length,
-                             IN_FEC_GROUP);
+         kPrivateFlagsSize;
 }
 
 size_t GetStartOfEncryptedData(QuicConnectionIdLength connection_id_length,
                                bool include_version,
                                bool include_path_id,
                                QuicPacketNumberLength packet_number_length) {
   // Don't include the fec size, since encryption starts before private flags.
   return GetPacketHeaderSize(connection_id_length, include_version,
-                             include_path_id, packet_number_length,
-                             NOT_IN_FEC_GROUP) -
+                             include_path_id, packet_number_length) -
          kPrivateFlagsSize;
 }
 
 QuicPacketPublicHeader::QuicPacketPublicHeader()
     : connection_id(0),
       connection_id_length(PACKET_8BYTE_CONNECTION_ID),
       multipath_flag(false),
       reset_flag(false),
       version_flag(false),
       packet_number_length(PACKET_6BYTE_PACKET_NUMBER) {}
@@ skipping 628 matching lines @@
       packet_number_length_(packet_number_length) {}
 
 QuicEncryptedPacket::QuicEncryptedPacket(const char* buffer, size_t length)
     : QuicData(buffer, length) {}
 
 QuicEncryptedPacket::QuicEncryptedPacket(char* buffer,
                                          size_t length,
                                          bool owns_buffer)
     : QuicData(buffer, length, owns_buffer) {}
 
-StringPiece QuicPacket::FecProtectedData() const {
-  const size_t start_of_fec =
-      GetStartOfFecProtectedData(connection_id_length_, includes_version_,
-                                 includes_path_id_, packet_number_length_);
-  return StringPiece(data() + start_of_fec, length() - start_of_fec);
-}
-
 StringPiece QuicPacket::AssociatedData() const {
   return StringPiece(data(), GetStartOfEncryptedData(
                                  connection_id_length_, includes_version_,
                                  includes_path_id_, packet_number_length_));
 }
 
 StringPiece QuicPacket::Plaintext() const {
   const size_t start_of_encrypted_data =
       GetStartOfEncryptedData(connection_id_length_, includes_version_,
                               includes_path_id_, packet_number_length_);
@@ skipping 83 matching lines @@
       is_fec_packet(is_fec_packet),
       has_crypto_handshake(has_crypto_handshake),
       needs_padding(needs_padding),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net