Land Recent QUIC Changes.

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 <deque>
 #include <list>
 #include <map>
@@ skipping 74 matching lines @@
   // If this packet has been retransmitted, information on those packets
   // will be discarded as well.
   void DiscardUnackedPacket(QuicPacketSequenceNumber sequence_number);
 
   // Discards all information about fec packet |sequence_number|.
   void DiscardFecPacket(QuicPacketSequenceNumber sequence_number);
 
   // Returns true if |sequence_number| is a retransmission of a packet.
   bool IsRetransmission(QuicPacketSequenceNumber sequence_number) const;
 
-  // Returns the number of times the data in the packet |sequence_number|
-  // has been transmitted.
-  size_t GetRetransmissionCount(
-      QuicPacketSequenceNumber sequence_number) const;
-
   // Returns true if the non-FEC packet |sequence_number| is unacked.
   bool IsUnacked(QuicPacketSequenceNumber sequence_number) const;
 
   // Returns true if the FEC packet |sequence_number| is unacked.
   bool IsFecUnacked(QuicPacketSequenceNumber sequence_number) const;
 
   // Returns true if the unacked packet |sequence_number| has retransmittable
   // frames.  This will only return false if the packet has been acked, if a
   // previous transmission of this packet was ACK'd, or if this packet has been
   // retransmitted as with different sequence number.
@@ skipping 14 matching lines @@
 
   // Retrieves the next pending retransmission.
   PendingRetransmission NextPendingRetransmission();
 
   // Returns the time the fec packet was sent.
   QuicTime GetFecSentTime(QuicPacketSequenceNumber sequence_number) const;
 
   // Returns true if there are any unacked packets.
   bool HasUnackedPackets() const;
 
-  // Returns the number of unacked packets.
-  size_t GetNumUnackedPackets() const;
+  // Returns the number of unacked packets which have retransmittable frames.
+  size_t GetNumRetransmittablePackets() const;
 
   // Returns true if there are any unacked FEC packets.
   bool HasUnackedFecPackets() const;
 
   // Returns the smallest sequence number of a sent packet which has not been
   // acked by the peer.  Excludes any packets which have been retransmitted
   // with a new sequence number. If all packets have been acked, returns the
   // sequence number of the next packet that will be sent.
   QuicPacketSequenceNumber GetLeastUnackedSentPacket() const;
 
   // Returns the smallest sequence number of a sent fec packet which has not
   // been acked by the peer.  If all packets have been acked, returns the
   // sequence number of the next packet that will be sent.
   QuicPacketSequenceNumber GetLeastUnackedFecPacket() const;
 
   // Returns the set of sequence numbers of all unacked packets.
   SequenceNumberSet GetUnackedPackets() const;
 
   // Returns true if |sequence_number| is a previous transmission of packet.
   bool IsPreviousTransmission(QuicPacketSequenceNumber sequence_number) const;
 
  private:
-  struct RetransmissionInfo {
-    RetransmissionInfo() {}
-    explicit RetransmissionInfo(QuicPacketSequenceNumber sequence_number,
-                                QuicSequenceNumberLength sequence_number_length)
-        : sequence_number(sequence_number),
-          sequence_number_length(sequence_number_length),
-          number_nacks(0),
-          number_retransmissions(0) {
+  struct TransmissionInfo {
+    TransmissionInfo() {}
+    TransmissionInfo(RetransmittableFrames* retransmittable_frames,
+                     QuicSequenceNumberLength sequence_number_length)
+        : retransmittable_frames(retransmittable_frames),
+          sequence_number_length(sequence_number_length) {
     }
 
-    QuicPacketSequenceNumber sequence_number;
+    RetransmittableFrames* retransmittable_frames;
     QuicSequenceNumberLength sequence_number_length;
-    size_t number_nacks;
-    // TODO(ianswett): I believe this is now obsolete, or could at least be
-    // changed to a bool.
-    size_t number_retransmissions;
   };
 
   typedef linked_hash_map<QuicPacketSequenceNumber,
-                          RetransmittableFrames*> UnackedPacketMap;
+                          TransmissionInfo> UnackedPacketMap;
   typedef linked_hash_map<QuicPacketSequenceNumber,
                           QuicTime> UnackedFecPacketMap;
   typedef linked_hash_map<QuicPacketSequenceNumber,
                           TransmissionType> PendingRetransmissionMap;
-  typedef base::hash_map<QuicPacketSequenceNumber,
-                         RetransmissionInfo> RetransmissionMap;
+  typedef base::hash_map<QuicPacketSequenceNumber, size_t> NackMap;
   typedef base::hash_map<QuicPacketSequenceNumber, SequenceNumberSet*>
                          PreviousTransmissionMap;
 
   // Process the incoming ack looking for newly ack'd data packets.
   void HandleAckForSentPackets(const ReceivedPacketInfo& received_info,
                                bool is_truncated_ack);
 
   // Process the incoming ack looking for newly ack'd FEC packets.
   void HandleAckForSentFecPackets(const ReceivedPacketInfo& received_info);
 
@@ skipping 27 matching lines @@
   UnackedPacketMap unacked_packets_;
 
   // Pending fec packets that have not been acked yet. These packets need to be
   // cleared out of the cgst_window after a timeout since FEC packets are never
   // retransmitted.
   UnackedFecPacketMap unacked_fec_packets_;
 
   // Pending retransmissions which have not been packetized and sent yet.
   PendingRetransmissionMap pending_retransmissions_;
 
-  // Map from sequence number to the retransmission info for a packet.
-  // This includes the retransmission timeout, and the NACK count.  Only
-  // the new transmission of a packet will have entries in this map.
-  RetransmissionMap retransmission_map_;
+  // Map from sequence number to the number of nacks for the packet.
+  // Only the most recent transmission of packets are present in this map.
+  NackMap nack_map_;
 
   // Map from sequence number to set of all sequence number that this packet has
   // been transmitted as.  If a packet has not been retransmitted, it will not
   // have an entry in this map.  If any transmission of a packet has been acked
   // it will not have an entry in this map.
   PreviousTransmissionMap previous_transmissions_map_;
 
   // Tracks if the connection was created by the server.
   bool is_server_;
 
   HelperInterface* helper_;
 
   // An AckNotifier can register to be informed when ACKs have been received for
   // all packets that a given block of data was sent in. The AckNotifierManager
   // maintains the currently active notifiers.
   AckNotifierManager ack_notifier_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSentPacketManager);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_SENT_PACKET_MANAGER_H_