Update from https://crrev.com/312398

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 144 matching lines @@
 
   // Called when the complete header of a packet has been parsed.
   virtual void OnPacketHeader(const QuicPacketHeader& header) {}
 
   // Called when a StreamFrame has been parsed.
   virtual void OnStreamFrame(const QuicStreamFrame& frame) {}
 
   // Called when a AckFrame has been parsed.
   virtual void OnAckFrame(const QuicAckFrame& frame) {}
 
-  // Called when a CongestionFeedbackFrame has been parsed.
-  virtual void OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame) {}
-
   // Called when a StopWaitingFrame has been parsed.
   virtual void OnStopWaitingFrame(const QuicStopWaitingFrame& frame) {}
 
   // Called when a Ping has been parsed.
   virtual void OnPingFrame(const QuicPingFrame& frame) {}
 
   // Called when a GoAway has been parsed.
   virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) {}
 
   // Called when a RstStreamFrame has been parsed.
@@ skipping 174 matching lines @@
       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 OnCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& 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;
   void OnFecData(const QuicFecData& fec) override;
   void OnPacketComplete() override;
 
   // QuicPacketGenerator::DelegateInterface
   bool ShouldGeneratePacket(TransmissionType transmission_type,
                             HasRetransmittableData retransmittable,
                             IsHandshake handshake) override;
   QuicAckFrame* CreateAckFrame() override;
-  QuicCongestionFeedbackFrame* CreateFeedbackFrame() override;
   QuicStopWaitingFrame* CreateStopWaitingFrame() override;
   void OnSerializedPacket(const SerializedPacket& packet) override;
 
   // QuicSentPacketManager::NetworkChangeVisitor
   void OnCongestionWindowChange() override;
   void OnRttChange() override;
 
   // Called by the crypto stream when the handshake completes. In the server's
   // case this is when the SHLO has been ACKed. Clients call this on receipt of
   // the SHLO.
@@ skipping 53 matching lines @@
   // Sends a ping, and resets the ping alarm.
   void SendPing();
 
   // Sets up a packet with an QuicAckFrame and sends it out.
   void SendAck();
 
   // Called when an RTO fires.  Resets the retransmission alarm if there are
   // remaining unacked packets.
   void OnRetransmissionTimeout();
 
+  // Called when a data packet is sent. Starts an alarm if the data sent in
+  // |sequence_number| was FEC protected.
+  void MaybeSetFecAlarm(QuicPacketSequenceNumber sequence_number);
+
   // Retransmits all unacked packets with retransmittable frames if
   // |retransmission_type| is ALL_UNACKED_PACKETS, otherwise retransmits only
   // initially encrypted packets. Used when the negotiated protocol version is
   // different from what was initially assumed and when the initial encryption
   // changes.
   void RetransmitUnackedPackets(TransmissionType retransmission_type);
 
   // Calls |sent_packet_manager_|'s NeuterUnencryptedPackets. Used when the
   // connection becomes forward secure and hasn't received acks for all packets.
   void NeuterUnencryptedPackets();
@@ skipping 236 matching lines @@
 
   // 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_;
   std::vector<QuicStreamFrame> last_stream_frames_;
   std::vector<QuicAckFrame> last_ack_frames_;
-  std::vector<QuicCongestionFeedbackFrame> last_congestion_frames_;
   std::vector<QuicStopWaitingFrame> last_stop_waiting_frames_;
   std::vector<QuicRstStreamFrame> last_rst_frames_;
   std::vector<QuicGoAwayFrame> last_goaway_frames_;
   std::vector<QuicWindowUpdateFrame> last_window_update_frames_;
   std::vector<QuicBlockedFrame> last_blocked_frames_;
   std::vector<QuicPingFrame> last_ping_frames_;
   std::vector<QuicConnectionCloseFrame> last_close_frames_;
 
-  QuicCongestionFeedbackFrame outgoing_congestion_feedback_;
-
   // Track some peer state so we can do less bookkeeping
   // Largest sequence sent by the peer which had an ack frame (latest ack info).
   QuicPacketSequenceNumber largest_seen_packet_with_ack_;
 
   // Largest sequence number sent by the peer which had a stop waiting frame.
   QuicPacketSequenceNumber largest_seen_packet_with_stop_waiting_;
 
   // Collection of packets which were received before encryption was
   // established, but which could not be decrypted.  We buffer these on
   // the assumption that they could not be processed because they were
@@ skipping 43 matching lines @@
   scoped_ptr<QuicAlarm> resume_writes_alarm_;
   // An alarm that fires when the connection may have timed out.
   scoped_ptr<QuicAlarm> timeout_alarm_;
   // An alarm that fires when a ping should be sent.
   scoped_ptr<QuicAlarm> ping_alarm_;
 
   QuicConnectionVisitorInterface* visitor_;
   scoped_ptr<QuicConnectionDebugVisitor> debug_visitor_;
   QuicPacketGenerator packet_generator_;
 
+  // An alarm that fires when an FEC packet should be sent.
+  scoped_ptr<QuicAlarm> fec_alarm_;
+
   // Network idle time before we kill of this connection.
   QuicTime::Delta idle_network_timeout_;
   // Overall connection timeout.
   QuicTime::Delta overall_connection_timeout_;
 
   // Statistics for this session.
   QuicConnectionStats stats_;
 
   // The time that we got a packet for this connection.
   // This is used for timeouts, and does not indicate the packet was processed.
@@ skipping 48 matching lines @@
 
   // True if this is a secure QUIC connection.
   bool is_secure_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_