Remove FEC code from receive path.

net/quic/quic_framer.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_framer.h"
 
 #include <stdint.h>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 141 matching lines @@
   quic_version_ = supported_versions_[0];
   decrypter_.reset(QuicDecrypter::Create(kNULL));
   encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
 }
 
 QuicFramer::~QuicFramer() {}
 
 // static
 size_t QuicFramer::GetMinStreamFrameSize(QuicStreamId stream_id,
                                          QuicStreamOffset offset,
-                                         bool last_frame_in_packet,
-                                         InFecGroup is_in_fec_group) {
-  bool no_stream_frame_length =
-      last_frame_in_packet && is_in_fec_group == NOT_IN_FEC_GROUP;
+                                         bool last_frame_in_packet) {
   return kQuicFrameTypeSize + GetStreamIdSize(stream_id) +
          GetStreamOffsetSize(offset) +
-         (no_stream_frame_length ? 0 : kQuicStreamPayloadLengthSize);
+         (last_frame_in_packet ? 0 : kQuicStreamPayloadLengthSize);
 }
 
 // static
 size_t QuicFramer::GetMinAckFrameSize(
     QuicPacketNumberLength largest_observed_length) {
   return kQuicFrameTypeSize + kQuicEntropyHashSize + largest_observed_length +
          kQuicDeltaTimeLargestObservedSize;
 }
 
 // static
@@ skipping 84 matching lines @@
     }
   }
   return false;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
     const QuicFrame& frame,
     size_t free_bytes,
     bool first_frame,
     bool last_frame,
-    InFecGroup is_in_fec_group,
     QuicPacketNumberLength packet_number_length) {
   // Prevent a rare crash reported in b/19458523.
   if ((frame.type == STREAM_FRAME || frame.type == ACK_FRAME) &&
       frame.stream_frame == nullptr) {
     QUIC_BUG << "Cannot compute the length of a null frame. "
              << "type:" << frame.type << "free_bytes:" << free_bytes
              << " first_frame:" << first_frame << " last_frame:" << last_frame
-             << " is_in_fec:" << is_in_fec_group
              << " seq num length:" << packet_number_length;
     set_error(QUIC_INTERNAL_ERROR);
     visitor_->OnError(this);
     return 0;
   }
   if (frame.type == PADDING_FRAME) {
     // PADDING implies end of packet.
     return free_bytes;
   }
-  size_t frame_len = ComputeFrameLength(frame, last_frame, is_in_fec_group,
-                                        packet_number_length);
+  size_t frame_len =
+      ComputeFrameLength(frame, last_frame, packet_number_length);
   if (frame_len <= free_bytes) {
     // Frame fits within packet. Note that acks may be truncated.
     return frame_len;
   }
   // Only truncate the first frame in a packet, so if subsequent ones go
   // over, stop including more frames.
   if (!first_frame) {
     return 0;
   }
   bool can_truncate =
@@ skipping 26 matching lines @@
                                    size_t packet_length) {
   QuicDataWriter writer(packet_length, buffer);
   if (!AppendPacketHeader(header, &writer)) {
     QUIC_BUG << "AppendPacketHeader failed";
     return 0;
   }
 
   size_t i = 0;
   for (const QuicFrame& frame : frames) {
     // Determine if we should write stream frame length in header.
-    const bool no_stream_frame_length =
-        (header.is_in_fec_group == NOT_IN_FEC_GROUP) &&
-        (i == frames.size() - 1);
+    const bool no_stream_frame_length = i == frames.size() - 1;
     if (!AppendTypeByte(frame, no_stream_frame_length, &writer)) {
       QUIC_BUG << "AppendTypeByte failed";
       return 0;
     }
 
     switch (frame.type) {
       case PADDING_FRAME:
         writer.WritePadding();
         break;
       case STREAM_FRAME:
@@ skipping 62 matching lines @@
         RaiseError(QUIC_INVALID_FRAME_DATA);
         QUIC_BUG << "QUIC_INVALID_FRAME_DATA";
         return 0;
     }
     ++i;
   }
 
   return writer.length();
 }
 
-QuicPacket* QuicFramer::BuildFecPacket(const QuicPacketHeader& header,
-                                       StringPiece redundancy) {
-  DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group);
-  DCHECK_NE(0u, header.fec_group);
-  size_t len = GetPacketHeaderSize(header);
-  len += redundancy.length();
-
-  scoped_ptr<char[]> buffer(new char[len]);
-  QuicDataWriter writer(len, buffer.get());
-  if (!AppendPacketHeader(header, &writer)) {
-    QUIC_BUG << "AppendPacketHeader failed";
-    return nullptr;
-  }
-
-  if (!writer.WriteBytes(redundancy.data(), redundancy.length())) {
-    QUIC_BUG << "Failed to add FEC";
-    return nullptr;
-  }
-
-  return new QuicPacket(
-      buffer.release(), len, true, header.public_header.connection_id_length,
-      header.public_header.version_flag, header.public_header.multipath_flag,
-      header.public_header.packet_number_length);
-}
-
 // static
 QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
 
   CryptoHandshakeMessage reset;
   reset.set_tag(kPRST);
   reset.SetValue(kRNON, packet.nonce_proof);
   reset.SetValue(kRSEQ, packet.rejected_packet_number);
   if (!packet.client_address.address().empty()) {
@@ skipping 153 matching lines @@
     // The visitor suppresses further processing of the packet.
     return true;
   }
 
   if (packet.length() > kMaxPacketSize) {
     // If the packet has gotten this far, it should not be too large.
     QUIC_BUG << "Packet too large:" << packet.length();
     return RaiseError(QUIC_PACKET_TOO_LARGE);
   }
 
+  DCHECK(!header.fec_flag);
   // Handle the payload.
-  if (!header.fec_flag) {
-    if (header.is_in_fec_group == IN_FEC_GROUP) {
-      StringPiece payload = reader.PeekRemainingPayload();
-      visitor_->OnFecProtectedPayload(payload);
-    }
-    if (!ProcessFrameData(&reader, header)) {
-      DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
-      DLOG(WARNING) << "Unable to process frame data.";
-      return false;
-    }
-  } else {
-    visitor_->OnFecData(reader.ReadRemainingPayload());
+  if (!ProcessFrameData(&reader, header)) {
+    DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
+    DLOG(WARNING) << "Unable to process frame data.";
+    return false;
   }
 
   visitor_->OnPacketComplete();
   return true;
 }
 
 bool QuicFramer::ProcessPublicResetPacket(
     QuicDataReader* reader,
     const QuicPacketPublicHeader& public_header) {
   QuicPublicResetPacket packet(public_header);
@@ skipping 27 matching lines @@
     if (address_coder.Decode(address.data(), address.length())) {
       packet.client_address =
           IPEndPoint(address_coder.ip(), address_coder.port());
     }
   }
 
   visitor_->OnPublicResetPacket(packet);
   return true;
 }
 
-bool QuicFramer::ProcessRevivedPacket(QuicPacketHeader* header,
-                                      StringPiece payload) {
-  visitor_->OnRevivedPacket();
-
-  header->entropy_hash = GetPacketEntropyHash(*header);
-
-  if (!visitor_->OnPacketHeader(*header)) {
-    return true;
-  }
-
-  if (payload.length() > kMaxPacketSize) {
-    set_detailed_error("Revived packet too large.");
-    return RaiseError(QUIC_PACKET_TOO_LARGE);
-  }
-
-  QuicDataReader reader(payload.data(), payload.length());
-  if (!ProcessFrameData(&reader, *header)) {
-    DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
-    DLOG(WARNING) << "Unable to process frame data.";
-    return false;
-  }
-
-  visitor_->OnPacketComplete();
-  return true;
-}
-
 bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
                                     QuicDataWriter* writer) {
   DVLOG(1) << "Appending header: " << header;
-  DCHECK(header.fec_group > 0 || header.is_in_fec_group == NOT_IN_FEC_GROUP);
   uint8_t public_flags = 0;
   if (header.public_header.reset_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_RST;
   }
   if (header.public_header.version_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_VERSION;
   }
   if (header.public_header.multipath_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_MULTIPATH;
   }
@@ skipping 56 matching lines @@
 
   if (!AppendPacketSequenceNumber(header.public_header.packet_number_length,
                                   header.packet_number, writer)) {
     return false;
   }
 
   uint8_t private_flags = 0;
   if (header.entropy_flag) {
     private_flags |= PACKET_PRIVATE_FLAGS_ENTROPY;
   }
-  if (header.is_in_fec_group == IN_FEC_GROUP) {
-    private_flags |= PACKET_PRIVATE_FLAGS_FEC_GROUP;
-  }
-  if (header.fec_flag) {
-    private_flags |= PACKET_PRIVATE_FLAGS_FEC;
-  }
   if (!writer->WriteUInt8(private_flags)) {
     return false;
   }
 
-  // The FEC group number is the packet number of the first fec
-  // protected packet, or 0 if this packet is not protected.
-  if (header.is_in_fec_group == IN_FEC_GROUP) {
-    DCHECK_LE(header.fec_group, header.packet_number);
-    DCHECK_LT(header.packet_number - header.fec_group, 255u);
-    // Offset from the current packet number to the first fec
-    // protected packet.
-    uint8_t first_fec_protected_packet_offset =
-        static_cast<uint8_t>(header.packet_number - header.fec_group);
-    if (!writer->WriteBytes(&first_fec_protected_packet_offset, 1)) {
-      return false;
-    }
-  }
-
   return true;
 }
 
 const QuicTime::Delta QuicFramer::CalculateTimestampFromWire(
     uint32_t time_delta_us) {
   // The new time_delta might have wrapped to the next epoch, or it
   // might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch. Select the time closest to the previous
   // time.
   //
@@ skipping 1020 matching lines @@
       ack_size += 3 * (ack.received_packet_times.size() - 1);
     }
   }
 
   return ack_size;
 }
 
 size_t QuicFramer::ComputeFrameLength(
     const QuicFrame& frame,
     bool last_frame_in_packet,
-    InFecGroup is_in_fec_group,
     QuicPacketNumberLength packet_number_length) {
   switch (frame.type) {
     case STREAM_FRAME:
       return GetMinStreamFrameSize(frame.stream_frame->stream_id,
                                    frame.stream_frame->offset,
-                                   last_frame_in_packet, is_in_fec_group) +
+                                   last_frame_in_packet) +
              frame.stream_frame->frame_length;
     case ACK_FRAME: {
       return GetAckFrameSize(*frame.ack_frame, packet_number_length);
     }
     case STOP_WAITING_FRAME:
       return GetStopWaitingFrameSize(packet_number_length);
     case MTU_DISCOVERY_FRAME:
     // MTU discovery frames are serialized as ping frames.
     case PING_FRAME:
       // Ping has no payload.
@@ skipping 439 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net