Landing Recent QUIC changes until Fri Nov 18 23:21:04 2016 +0000

net/quic/core/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 <stddef.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "net/base/linked_hash_map.h"
 #include "net/base/net_export.h"
 #include "net/quic/core/congestion_control/general_loss_algorithm.h"
 #include "net/quic/core/congestion_control/loss_detection_interface.h"
 #include "net/quic/core/congestion_control/pacing_sender.h"
 #include "net/quic/core/congestion_control/rtt_stats.h"
 #include "net/quic/core/congestion_control/send_algorithm_interface.h"
-#include "net/quic/core/quic_protocol.h"
+#include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_sent_packet_manager_interface.h"
 #include "net/quic/core/quic_unacked_packet_map.h"
 
 namespace net {
 
 namespace test {
 class QuicConnectionPeer;
 class QuicSentPacketManagerPeer;
 }  // namespace test
 
@@ skipping 78 matching lines @@
   // Removes the retransmittable frames from all unencrypted packets to ensure
   // they don't get retransmitted.
   void NeuterUnencryptedPackets() override;
 
   // Returns true if there are pending retransmissions.
   // Not const because retransmissions may be cancelled before returning.
   bool HasPendingRetransmissions() const override;
 
   // Retrieves the next pending retransmission.  You must ensure that
   // there are pending retransmissions prior to calling this function.
-  PendingRetransmission NextPendingRetransmission() override;
+  QuicPendingRetransmission NextPendingRetransmission() override;
 
   bool HasUnackedPackets() const override;
 
   // Returns the smallest packet number of a serialized packet which has not
   // been acked by the peer.
   QuicPacketNumber GetLeastUnacked(QuicPathId) const override;
 
   // 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.
@@ skipping 67 matching lines @@
   void SetNetworkChangeVisitor(NetworkChangeVisitor* visitor) override;
 
   bool InSlowStart() const override;
 
   size_t GetConsecutiveRtoCount() const override;
 
   size_t GetConsecutiveTlpCount() const override;
 
   void OnApplicationLimited() override;
 
+  const SendAlgorithmInterface* GetSendAlgorithm() const override;
+
  private:
   friend class test::QuicConnectionPeer;
   friend class test::QuicSentPacketManagerPeer;
 
   // The retransmission timer is a single timer which switches modes depending
   // upon connection state.
   enum RetransmissionTimeoutMode {
     // A conventional TCP style RTO.
     RTO_MODE,
     // A tail loss probe.  By default, QUIC sends up to two before RTOing.
@@ skipping 29 matching lines @@
 
   // Returns the timer for a new tail loss probe.
   const QuicTime::Delta GetTailLossProbeDelay() const;
 
   // Returns the retransmission timeout, after which a full RTO occurs.
   const QuicTime::Delta GetRetransmissionDelay() const;
 
   // Returns the newest transmission associated with a packet.
   QuicPacketNumber GetNewestRetransmission(
       QuicPacketNumber packet_number,
-      const TransmissionInfo& transmission_info) const;
+      const QuicTransmissionInfo& transmission_info) const;
 
   // Update the RTT if the ack is for the largest acked packet number.
   // Returns true if the rtt was updated.
   bool MaybeUpdateRTT(const QuicAckFrame& ack_frame, QuicTime ack_receive_time);
 
   // Invokes the loss detection algorithm and loses and retransmits packets if
   // necessary.
   void InvokeLossDetection(QuicTime time);
 
   // Invokes OnCongestionEvent if |rtt_updated| is true, there are pending acks,
@@ skipping 13 matching lines @@
   // landed.
   // The packet needs no longer to be retransmitted, but the packet remains
   // pending if it is and the congestion control does not consider the packet
   // acked.
   void MarkPacketNotRetransmittable(QuicPacketNumber packet_number,
                                     QuicTime::Delta ack_delay_time);
 
   // Removes the retransmittability and in flight properties from the packet at
   // |info| due to receipt by the peer.
   void MarkPacketHandled(QuicPacketNumber packet_number,
-                         TransmissionInfo* info,
+                         QuicTransmissionInfo* info,
                          QuicTime::Delta ack_delay_time);
 
   // Request that |packet_number| be retransmitted after the other pending
   // retransmissions.  Does not add it to the retransmissions if it's already
   // a pending retransmission.
   void MarkForRetransmission(QuicPacketNumber packet_number,
                              TransmissionType transmission_type);
 
-  // Notify observers that packet with TransmissionInfo |info| is a spurious
+  // Notify observers that packet with QuicTransmissionInfo |info| is a spurious
   // retransmission. It is caller's responsibility to guarantee the packet with
-  // TransmissionInfo |info| is a spurious retransmission before calling this
-  // function.
-  void RecordOneSpuriousRetransmission(const TransmissionInfo& info);
+  // QuicTransmissionInfo |info| is a spurious retransmission before calling
+  // this function.
+  void RecordOneSpuriousRetransmission(const QuicTransmissionInfo& info);
 
-  // Notify observers about spurious retransmits of packet with TransmissionInfo
-  // |info|.
-  void RecordSpuriousRetransmissions(const TransmissionInfo& info,
+  // Notify observers about spurious retransmits of packet with
+  // QuicTransmissionInfo |info|.
+  void RecordSpuriousRetransmissions(const QuicTransmissionInfo& info,
                                      QuicPacketNumber acked_packet_number);
 
-  // Returns mutable TransmissionInfo associated with |packet_number|, which
+  // Returns mutable QuicTransmissionInfo associated with |packet_number|, which
   // must be unacked.
-  TransmissionInfo* GetMutableTransmissionInfo(QuicPacketNumber packet_number);
+  QuicTransmissionInfo* GetMutableTransmissionInfo(
+      QuicPacketNumber packet_number);
 
   // Remove any packets no longer needed for retransmission, congestion, or
   // RTT measurement purposes.
   void RemoveObsoletePackets();
 
   // Sets the send algorithm to the given congestion control type and points the
   // pacing sender at |send_algorithm_|. Can be called any number of times.
   void SetSendAlgorithm(CongestionControlType congestion_control_type);
 
   // Sets the send algorithm to |send_algorithm| and points the pacing sender at
@@ skipping 87 matching lines @@
   // 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_