Remove FEC code from receive path.

net/quic/quic_framer.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 73 matching lines @@
 
   // Called when a public reset packet has been parsed but has not yet
   // been validated.
   virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) = 0;
 
   // Called only when |perspective_| is IS_CLIENT and a version negotiation
   // packet has been parsed.
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) = 0;
 
-  // Called when a lost packet has been recovered via FEC,
-  // before it has been processed.
-  virtual void OnRevivedPacket() = 0;
-
   // Called when the public header has been parsed, but has not been
   // authenticated. If it returns false, framing for this packet will cease.
   virtual bool OnUnauthenticatedPublicHeader(
       const QuicPacketPublicHeader& header) = 0;
 
   // Called when the unauthenticated portion of the header has been parsed.
   // If OnUnauthenticatedHeader returns false, framing for this packet will
   // cease.
   virtual bool OnUnauthenticatedHeader(const QuicPacketHeader& header) = 0;
 
   // Called when a packet has been decrypted. |level| is the encryption level
   // of the packet.
   virtual void OnDecryptedPacket(EncryptionLevel level) = 0;
 
   // Called when the complete header of a packet had been parsed.
   // If OnPacketHeader returns false, framing for this packet will cease.
   virtual bool OnPacketHeader(const QuicPacketHeader& header) = 0;
 
-  // Called when a data packet is parsed that is part of an FEC group.
-  // |payload| is the non-encrypted FEC protected payload of the packet.
-  virtual void OnFecProtectedPayload(base::StringPiece payload) = 0;
-
   // Called when a StreamFrame has been parsed.
   virtual bool OnStreamFrame(const QuicStreamFrame& frame) = 0;
 
   // Called when a AckFrame has been parsed.  If OnAckFrame returns false,
   // the framer will stop parsing the current packet.
   virtual bool OnAckFrame(const QuicAckFrame& frame) = 0;
 
   // Called when a StopWaitingFrame has been parsed.
   virtual bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) = 0;
 
@@ skipping 12 matching lines @@
 
   // Called when a WindowUpdateFrame has been parsed.
   virtual bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) = 0;
 
   // Called when a BlockedFrame has been parsed.
   virtual bool OnBlockedFrame(const QuicBlockedFrame& frame) = 0;
 
   // Called when a PathCloseFrame has been parsed.
   virtual bool OnPathCloseFrame(const QuicPathCloseFrame& frame) = 0;
 
-  // Called when FEC data has been parsed.
-  virtual void OnFecData(base::StringPiece redundancy) = 0;
-
   // Called when a packet has been completely processed.
   virtual void OnPacketComplete() = 0;
 };
 
 // This class calculates the received entropy of the ack packet being
 // framed, should it get truncated.
 class NET_EXPORT_PRIVATE QuicReceivedEntropyHashCalculatorInterface {
  public:
   virtual ~QuicReceivedEntropyHashCalculatorInterface() {}
 
   // When an ack frame gets truncated while being framed the received
   // entropy of the ack frame needs to be calculated since the some of the
   // missing packets are not added and the largest observed might be lowered.
   // This should return the received entropy hash of the packets received up to
   // and including |packet_number|.
   virtual QuicPacketEntropyHash EntropyHash(
       QuicPacketNumber packet_number) const = 0;
 };
 
 // Class for parsing and constructing QUIC packets.  It has a
 // QuicFramerVisitorInterface that is called when packets are parsed.
-// It also has a QuicFecBuilder that is called when packets are constructed
-// in order to generate FEC data for subsequently building FEC packets.
 class NET_EXPORT_PRIVATE QuicFramer {
  public:
   // Constructs a new framer that installs a kNULL QuicEncrypter and
   // QuicDecrypter for level ENCRYPTION_NONE. |supported_versions| specifies the
   // list of supported QUIC versions. |quic_version_| is set to the maximum
   // version in |supported_versions|.
   QuicFramer(const QuicVersionVector& supported_versions,
              QuicTime creation_time,
              Perspective perspective);
 
@@ skipping 33 matching lines @@
 
   QuicErrorCode error() const { return error_; }
 
   // Pass a UDP packet into the framer for parsing.
   // Return true if the packet was processed succesfully. |packet| must be a
   // single, complete UDP packet (not a frame of a packet).  This packet
   // might be null padded past the end of the payload, which will be correctly
   // ignored.
   bool ProcessPacket(const QuicEncryptedPacket& packet);
 
-  // Pass a data packet that was revived from FEC data into the framer
-  // for parsing.
-  // Return true if the packet was processed succesfully. |payload| must be
-  // the complete DECRYPTED payload of the revived packet.
-  bool ProcessRevivedPacket(QuicPacketHeader* header,
-                            base::StringPiece payload);
-
   // Largest size in bytes of all stream frame fields without the payload.
   static size_t GetMinStreamFrameSize(QuicStreamId stream_id,
                                       QuicStreamOffset offset,
-                                      bool last_frame_in_packet,
-                                      InFecGroup is_in_fec_group);
+                                      bool last_frame_in_packet);
   // Size in bytes of all ack frame fields without the missing packets.
   static size_t GetMinAckFrameSize(
       QuicPacketNumberLength largest_observed_length);
   // Size in bytes of a stop waiting frame.
   static size_t GetStopWaitingFrameSize(
       QuicPacketNumberLength packet_number_length);
   // Size in bytes of all reset stream frame without the error details.
   // Used before QUIC_VERSION_25.
   static size_t GetMinRstStreamFrameSize();
   // Size in bytes of all reset stream frame fields.
@@ skipping 16 matching lines @@
   // Size in bytes required for a serialized version negotiation packet
   static size_t GetVersionNegotiationPacketSize(size_t number_versions);
 
   // Returns the number of bytes added to the packet for the specified frame,
   // and 0 if the frame doesn't fit.  Includes the header size for the first
   // frame.
   size_t GetSerializedFrameLength(const QuicFrame& frame,
                                   size_t free_bytes,
                                   bool first_frame_in_packet,
                                   bool last_frame_in_packet,
-                                  InFecGroup is_in_fec_group,
                                   QuicPacketNumberLength packet_number_length);
 
   // Returns the associated data from the encrypted packet |encrypted| as a
   // stringpiece.
   static base::StringPiece GetAssociatedDataFromEncryptedPacket(
       const QuicEncryptedPacket& encrypted,
       QuicConnectionIdLength connection_id_length,
       bool includes_version,
       bool includes_path_id,
       QuicPacketNumberLength packet_number_length);
 
   // Serializes a packet containing |frames| into |buffer|.
   // Returns the length of the packet, which must not be longer than
   // |packet_length|.  Returns 0 if it fails to serialize.
   size_t BuildDataPacket(const QuicPacketHeader& header,
                          const QuicFrames& frames,
                          char* buffer,
                          size_t packet_length);
 
-  // Returns a QuicPacket* that is owned by the caller, and is populated with
-  // the fields in |header| and |fec|.  Returns nullptr if the packet could
-  // not be created.
-  QuicPacket* BuildFecPacket(const QuicPacketHeader& header,
-                             base::StringPiece redundancy);
-
   // Returns a new public reset packet, owned by the caller.
   static QuicEncryptedPacket* BuildPublicResetPacket(
       const QuicPublicResetPacket& packet);
 
   // Returns a new version negotiation packet, owned by the caller.
   static QuicEncryptedPacket* BuildVersionNegotiationPacket(
       QuicConnectionId connection_id,
       const QuicVersionVector& versions);
 
   // SetDecrypter sets the primary decrypter, replacing any that already exists,
@@ skipping 145 matching lines @@
   // was created.
   const QuicTime::Delta CalculateTimestampFromWire(uint32_t time_delta_us);
 
   // Computes the wire size in bytes of the |ack| frame, assuming no truncation.
   size_t GetAckFrameSize(const QuicAckFrame& ack,
                          QuicPacketNumberLength packet_number_length);
 
   // Computes the wire size in bytes of the payload of |frame|.
   size_t ComputeFrameLength(const QuicFrame& frame,
                             bool last_frame_in_packet,
-                            InFecGroup is_in_fec_group,
                             QuicPacketNumberLength packet_number_length);
 
   static bool AppendPacketSequenceNumber(
       QuicPacketNumberLength packet_number_length,
       QuicPacketNumber packet_number,
       QuicDataWriter* writer);
 
   static uint8_t GetSequenceNumberFlags(
       QuicPacketNumberLength packet_number_length);
 
@@ skipping 41 matching lines @@
 
   std::string detailed_error_;
   QuicFramerVisitorInterface* visitor_;
   QuicReceivedEntropyHashCalculatorInterface* entropy_calculator_;
   QuicErrorCode error_;
   // Set of closed paths. A path is considered as closed if a PATH_CLOSED frame
   // has been sent/received.
   // TODO(fayang): this set is never cleaned up. A possible improvement is to
   // use intervals.
   std::unordered_set<QuicPathId> closed_paths_;
-  // Map mapping path id to packet number of last successfully decrypted/revived
+  // Map mapping path id to packet number of last successfully decrypted
   // received packet.
   std::unordered_map<QuicPathId, QuicPacketNumber> last_packet_numbers_;
   // Updated by ProcessPacketHeader when it succeeds.
   QuicPacketNumber last_packet_number_;
-  // The path on which last successfully decrypted/revived packet was received.
+  // The path on which last successfully decrypted packet was received.
   QuicPathId last_path_id_;
   // Updated by WritePacketHeader.
   QuicConnectionId last_serialized_connection_id_;
   // The last QUIC version tag received.
   QuicTag last_version_tag_;
   // Version of the protocol being used.
   QuicVersion quic_version_;
   // This vector contains QUIC versions which we currently support.
   // This should be ordered such that the highest supported version is the first
   // element, with subsequent elements in descending order (versions can be
@@ skipping 24 matching lines @@
   // The time delta computed for the last timestamp frame. This is relative to
   // the creation_time.
   QuicTime::Delta last_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_