Update from https://crrev.com/312398

net/quic/quic_sent_packet_manager.h

 // Copyright 2013 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_SENT_PACKET_MANAGER_H_
 #define NET_QUIC_QUIC_SENT_PACKET_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 30 matching lines @@
 class NET_EXPORT_PRIVATE QuicSentPacketManager {
  public:
   // Interface which gets callbacks from the QuicSentPacketManager at
   // interesting points.  Implementations must not mutate the state of
   // the packet manager or connection as a result of these callbacks.
   class NET_EXPORT_PRIVATE DebugDelegate {
    public:
     virtual ~DebugDelegate() {}
 
     // Called when a spurious retransmission is detected.
-    virtual void OnSpuriousPacketRetransmition(
+    virtual void OnSpuriousPacketRetransmission(
         TransmissionType transmission_type,
         QuicByteCount byte_size) {}
 
     virtual void OnIncomingAck(
         const QuicAckFrame& ack_frame,
         QuicTime ack_receive_time,
         QuicPacketSequenceNumber largest_observed,
         bool rtt_updated,
         QuicPacketSequenceNumber least_unacked_sent_packet) {}
   };
@@ skipping 87 matching lines @@
   // Retrieves the next pending retransmission.  You must ensure that
   // there are pending retransmissions prior to calling this function.
   PendingRetransmission NextPendingRetransmission();
 
   bool HasUnackedPackets() const;
 
   // Returns the smallest sequence number of a serialized packet which has not
   // been acked by the peer.
   QuicPacketSequenceNumber GetLeastUnacked() const;
 
-  // Called when a congestion feedback frame is received from peer.
-  virtual void OnIncomingQuicCongestionFeedbackFrame(
-      const QuicCongestionFeedbackFrame& frame,
-      const QuicTime& feedback_receive_time);
-
   // Called when we have sent bytes to the peer.  This informs the manager both
   // the number of bytes sent and if they were retransmitted.  Returns true if
   // the sender should reset the retransmission timer.
   virtual bool OnPacketSent(SerializedPacket* serialized_packet,
                             QuicPacketSequenceNumber original_sequence_number,
                             QuicTime sent_time,
                             QuicByteCount bytes,
                             TransmissionType transmission_type,
                             HasRetransmittableData has_retransmittable_data);
 
@@ skipping 36 matching lines @@
   // congestion window has been recently reduced, of if non-full packets are
   // sent.
   QuicPacketCount EstimateMaxPacketsInFlight(
       QuicByteCount max_packet_length) const;
 
   // Returns the size of the slow start congestion window in nume of 1460 byte
   // TCP segments, aka ssthresh.  Some send algorithms do not define a slow
   // start threshold and will return 0.
   QuicPacketCount GetSlowStartThresholdInTcpMss() const;
 
+  // Called by the connection every time it receives a serialized packet.
+  void OnSerializedPacket(const SerializedPacket& serialized_packet);
+
   // Enables pacing if it has not already been enabled.
   void EnablePacing();
 
   bool using_pacing() const { return using_pacing_; }
 
   void set_debug_delegate(DebugDelegate* debug_delegate) {
     debug_delegate_ = debug_delegate;
   }
 
   QuicPacketSequenceNumber largest_observed() const {
@@ skipping 50 matching lines @@
 
   // Process the incoming ack looking for newly ack'd data packets.
   void HandleAckForSentPackets(const QuicAckFrame& ack_frame);
 
   // Returns the current retransmission mode.
   RetransmissionTimeoutMode GetRetransmissionMode() const;
 
   // Retransmits all crypto stream packets.
   void RetransmitCryptoPackets();
 
+  // Retransmits two packets for an RTO and removes any non-retransmittable
+  // packets from flight.
+  void RetransmitRtoPackets();
+
   // Retransmits all the packets and abandons by invoking a full RTO.
   void RetransmitAllPackets();
 
   // Returns the timer for retransmitting crypto handshake packets.
   const QuicTime::Delta GetCryptoRetransmissionDelay() const;
 
   // Returns the timer for a new tail loss probe.
   const QuicTime::Delta GetTailLossProbeDelay() const;
 
   // Returns the retransmission timeout, after which a full RTO occurs.
@@ skipping 83 matching lines @@
 
   // Tracks the first RTO packet.  If any packet before that packet gets acked,
   // it indicates the RTO was spurious and should be reversed(F-RTO).
   QuicPacketSequenceNumber first_rto_transmission_;
   // Number of times the RTO timer has fired in a row without receiving an ack.
   size_t consecutive_rto_count_;
   // Number of times the tail loss probe has been sent.
   size_t consecutive_tlp_count_;
   // Number of times the crypto handshake has been retransmitted.
   size_t consecutive_crypto_retransmission_count_;
-  // Number of pending transmissions of TLP or crypto packets.
+  // Number of pending transmissions of TLP, RTO, or crypto packets.
   size_t pending_timer_transmission_count_;
   // Maximum number of tail loss probes to send before firing an RTO.
   size_t max_tail_loss_probes_;
   bool using_pacing_;
 
   // Vectors packets acked and lost as a result of the last congestion event.
   SendAlgorithmInterface::CongestionVector packets_acked_;
   SendAlgorithmInterface::CongestionVector packets_lost_;
 
   // Set to true after the crypto handshake has successfully completed. After
   // this is true we no longer use HANDSHAKE_MODE, and further frames sent on
   // the crypto stream (i.e. SCUP messages) are treated like normal
   // retransmittable frames.
   bool handshake_confirmed_;
 
   // Records bandwidth from server to client in normal operation, over periods
   // of time with no loss events.
   QuicSustainedBandwidthRecorder sustained_bandwidth_recorder_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSentPacketManager);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_SENT_PACKET_MANAGER_H_