Remove FEC code from receive path.

net/quic/quic_connection.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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 36 matching lines @@
 #include "net/quic/quic_sent_packet_manager.h"
 #include "net/quic/quic_time.h"
 #include "net/quic/quic_types.h"
 
 namespace net {
 
 class QuicClock;
 class QuicConfig;
 class QuicConnection;
 class QuicEncrypter;
-class QuicFecGroup;
 class QuicRandom;
 
 namespace test {
 class PacketSavingConnection;
 class QuicConnectionPeer;
 }  // namespace test
 
 // The initial number of packets between MTU probes.  After each attempt the
 // number is doubled.
 const QuicPacketCount kPacketsBetweenMtuProbesBase = 100;
@@ skipping 159 matching lines @@
   // Called when a PathCloseFrame has been parsed.
   virtual void OnPathCloseFrame(const QuicPathCloseFrame& frame) {}
 
   // Called when a public reset packet has been received.
   virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) {}
 
   // Called when a version negotiation packet has been received.
   virtual void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) {}
 
-  // Called after a packet has been successfully parsed which results
-  // in the revival of a packet via FEC.
-  virtual void OnRevivedPacket(const QuicPacketHeader& revived_header,
-                               base::StringPiece payload) {}
-
   // Called when the connection is closed.
   virtual void OnConnectionClosed(QuicErrorCode error,
                                   ConnectionCloseSource source) {}
 
   // Called when the version negotiation is successful.
   virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) {}
 
   // Called when a CachedNetworkParameters is sent to the client.
   virtual void OnSendConnectionState(
       const CachedNetworkParameters& cached_network_params) {}
@@ skipping 131 matching lines @@
 
   // Sends a GOAWAY frame. Does nothing if a GOAWAY frame has already been sent.
   virtual void SendGoAway(QuicErrorCode error,
                           QuicStreamId last_good_stream_id,
                           const std::string& reason);
 
   // Returns statistics tracked for this connection.
   const QuicConnectionStats& GetStats();
 
   // Processes an incoming UDP packet (consisting of a QuicEncryptedPacket) from
-  // the peer.  If processing this packet permits a packet to be revived from
-  // its FEC group that packet will be revived and processed.
+  // the peer.
   // In a client, the packet may be "stray" and have a different connection ID
   // than that of this connection.
   virtual void ProcessUdpPacket(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet);
 
   // QuicBlockedWriterInterface
   // Called when the underlying connection becomes writable to allow queued
   // writes to happen.
   void OnCanWrite() override;
@@ skipping 30 matching lines @@
     return framer_.supported_versions();
   }
 
   // From QuicFramerVisitorInterface
   void OnError(QuicFramer* framer) override;
   bool OnProtocolVersionMismatch(QuicVersion received_version) override;
   void OnPacket() override;
   void OnPublicResetPacket(const QuicPublicResetPacket& packet) override;
   void OnVersionNegotiationPacket(
       const QuicVersionNegotiationPacket& packet) override;
-  void OnRevivedPacket() override;
   bool OnUnauthenticatedPublicHeader(
       const QuicPacketPublicHeader& header) override;
   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override;
   void OnDecryptedPacket(EncryptionLevel level) override;
   bool OnPacketHeader(const QuicPacketHeader& header) override;
-  void OnFecProtectedPayload(base::StringPiece payload) override;
   bool OnStreamFrame(const QuicStreamFrame& frame) override;
   bool OnAckFrame(const QuicAckFrame& frame) override;
   bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override;
   bool OnPingFrame(const QuicPingFrame& frame) override;
   bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override;
   bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override;
   bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override;
   bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override;
   bool OnBlockedFrame(const QuicBlockedFrame& frame) override;
   bool OnPathCloseFrame(const QuicPathCloseFrame& frame) override;
-  void OnFecData(base::StringPiece redundnancy) override;
   void OnPacketComplete() override;
 
   // QuicPacketGenerator::DelegateInterface
   bool ShouldGeneratePacket(HasRetransmittableData retransmittable,
                             IsHandshake handshake) override;
   void PopulateAckFrame(QuicAckFrame* ack) override;
   void PopulateStopWaitingFrame(QuicStopWaitingFrame* stop_waiting) override;
 
   // QuicPacketCreator::DelegateInterface
   void OnSerializedPacket(SerializedPacket* packet) override;
@@ skipping 37 matching lines @@
   bool goaway_sent() const { return goaway_sent_; }
 
   bool goaway_received() const { return goaway_received_; }
 
   // Must only be called on client connections.
   const QuicVersionVector& server_supported_versions() const {
     DCHECK_EQ(Perspective::IS_CLIENT, perspective_);
     return server_supported_versions_;
   }
 
-  size_t NumFecGroups() const { return group_map_.size(); }
-
   // Testing only.
   size_t NumQueuedPackets() const { return queued_packets_.size(); }
 
   // Once called, any sent crypto packets to be saved as the
   // termination packet, for use with stateless rejections.
   void EnableSavingCryptoPackets();
 
   // Returns true if the underlying UDP socket is writable, there is
   // no queued data and the connection is not congestion-control
   // blocked.
@@ skipping 181 matching lines @@
   // sent immediately after receiving an ACK.
   void set_defer_send_in_response_to_packets(bool defer) {
     defer_send_in_response_to_packets_ = defer;
   }
 
  private:
   friend class test::QuicConnectionPeer;
   friend class test::PacketSavingConnection;
 
   typedef std::list<SerializedPacket> QueuedPacketList;
-  typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
 
   // Writes the given packet to socket, encrypted with packet's
   // encryption_level. Returns true on successful write, and false if the writer
   // was blocked and the write needs to be tried again. Notifies the
   // SentPacketManager when the write is successful and sets
   // retransmittable frames to nullptr.
   // Saves the connection close packet for later transmission, even if the
   // writer is write blocked.
   bool WritePacket(SerializedPacket* packet);
 
@@ skipping 30 matching lines @@
   // Returns true if the packet should be discarded and not sent.
   bool ShouldDiscardPacket(const SerializedPacket& packet);
 
   // Queues |packet| in the hopes that it can be decrypted in the
   // future, when a new key is installed.
   void QueueUndecryptablePacket(const QuicEncryptedPacket& packet);
 
   // Attempts to process any queued undecryptable packets.
   void MaybeProcessUndecryptablePackets();
 
-  // If a packet can be revived from the current FEC group, then
-  // revive and process the packet.
-  void MaybeProcessRevivedPacket();
-
   void ProcessAckFrame(const QuicAckFrame& incoming_ack);
 
   void ProcessStopWaitingFrame(const QuicStopWaitingFrame& stop_waiting);
 
   // Sends any packets which are a response to the last packet, including both
   // acks and pending writes if an ack opened the congestion window.
   void MaybeSendInResponseToPacket();
 
   // Queue an ack or set the ack alarm if needed.  |was_missing| is true if
   // the most recently received packet was formerly missing.
   void MaybeQueueAck(bool was_missing);
 
   // Gets the least unacked packet number, which is the next packet number
   // to be sent if there are no outstanding packets.
   QuicPacketNumber GetLeastUnacked() const;
 
-  // Get the FEC group associate with the last processed packet or nullptr, if
-  // the group has already been deleted.
-  QuicFecGroup* GetFecGroup();
-
-  // Closes any FEC groups protecting packets before |packet_number|.
-  void CloseFecGroupsBefore(QuicPacketNumber packet_number);
-
   // Sets the timeout alarm to the appropriate value, if any.
   void SetTimeoutAlarm();
 
   // Sets the ping alarm to the appropriate value, if any.
   void SetPingAlarm();
 
   // Sets the retransmission alarm based on SentPacketManager.
   void SetRetransmissionAlarm();
 
   // Sets the MTU discovery alarm if necessary.
@@ skipping 51 matching lines @@
   IPEndPoint peer_address_;
 
   // Used to store latest peer IP address for IP address migration.
   IPAddress migrating_peer_ip_;
   // Used to store latest peer port to possibly migrate to later.
   uint16_t migrating_peer_port_;
 
   // True if the last packet has gotten far enough in the framer to be
   // decrypted.
   bool last_packet_decrypted_;
-  bool last_packet_revived_;  // True if the last packet was revived from FEC.
   QuicByteCount last_size_;   // Size of the last received packet.
   EncryptionLevel last_decrypted_packet_level_;
   QuicPacketHeader last_header_;
   QuicStopWaitingFrame last_stop_waiting_frame_;
   bool should_last_packet_instigate_acks_;
 
   // Track some peer state so we can do less bookkeeping
   // Largest sequence sent by the peer which had an ack frame (latest ack info).
   QuicPacketNumber largest_seen_packet_with_ack_;
 
@@ skipping 24 matching lines @@
   bool save_crypto_packets_as_termination_packets_;
 
   // Contains the connection close packets if the connection has been closed.
   scoped_ptr<std::vector<QuicEncryptedPacket*>> termination_packets_;
 
   // When true, the connection does not send a close packet on idle timeout due
   // to lack of network activity.
   // This is particularly important on mobile, where connections are short.
   bool silent_close_enabled_;
 
-  FecGroupMap group_map_;
-
   QuicReceivedPacketManager received_packet_manager_;
   QuicSentEntropyManager sent_entropy_manager_;
 
   // Indicates whether an ack should be sent the next time we try to write.
   bool ack_queued_;
   // How many retransmittable packets have arrived without sending an ack.
   QuicPacketCount num_retransmittable_packets_received_since_last_ack_sent_;
   // Whether there were missing packets in the last sent ack.
   bool last_ack_had_missing_packets_;
   // How many consecutive packets have arrived without sending an ack.
@@ skipping 131 matching lines @@
 
   // If true, multipath is enabled for this connection.
   bool multipath_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_