Rename previous_transmissions to all_transmission in the QUIC unacked

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 172 matching lines @@
     NOT_RECEIVED_BY_PEER,
   };
 
   enum RetransmissionTimeoutMode {
     RTO_MODE,
     TLP_MODE,
     HANDSHAKE_MODE,
   };
 
   struct TransmissionInfo {
-    TransmissionInfo()
-        : retransmittable_frames(NULL),
-          sequence_number_length(PACKET_1BYTE_SEQUENCE_NUMBER),
-          sent_time(QuicTime::Zero()),
-          previous_transmissions(NULL),
-          pending(false) { }
+    TransmissionInfo();
+
+    // Constructs a Transmission with a new all_tranmissions set
+    // containing |sequence_number|.
     TransmissionInfo(RetransmittableFrames* retransmittable_frames,
-                     QuicSequenceNumberLength sequence_number_length)
-        : retransmittable_frames(retransmittable_frames),
-          sequence_number_length(sequence_number_length),
-          sent_time(QuicTime::Zero()),
-          previous_transmissions(NULL),
-          pending(false) {
-    }
+                     QuicPacketSequenceNumber sequence_number,
+                     QuicSequenceNumberLength sequence_number_length);
+
+    // Constructs a Transmission with the specified |all_tranmissions| set
+    // and inserts |sequence_number| into it.
+    TransmissionInfo(RetransmittableFrames* retransmittable_frames,
+                     QuicPacketSequenceNumber sequence_number,
+                     QuicSequenceNumberLength sequence_number_length,
+                     SequenceNumberSet* all_transmissions);
 
     RetransmittableFrames* retransmittable_frames;
     QuicSequenceNumberLength sequence_number_length;
     // Zero when the packet is serialized, non-zero once it's sent.
     QuicTime sent_time;
-    // Stores all previous transmissions if the packet has been retransmitted,
-    // and is NULL otherwise.
-    SequenceNumberSet* previous_transmissions;
+    // Stores the sequence numbers of all transmissions of this packet.
+    // Can never be null.
+    SequenceNumberSet* all_transmissions;
     // Pending packets have not been abandoned or lost.
     bool pending;
   };
 
   typedef linked_hash_map<QuicPacketSequenceNumber,
                           TransmissionInfo> UnackedPacketMap;
   typedef linked_hash_map<QuicPacketSequenceNumber,
                           TransmissionType> PendingRetransmissionMap;
 
   static bool HasCryptoHandshake(const TransmissionInfo& transmission_info);
@@ skipping 39 matching lines @@
                                  const QuicTime& ack_receive_time);
 
   // Marks |sequence_number| as being fully handled, either due to receipt
   // by the peer, or having been discarded as indecipherable.  Returns an
   // iterator to the next remaining unacked packet.
   UnackedPacketMap::iterator MarkPacketHandled(
       QuicPacketSequenceNumber sequence_number,
       ReceivedByPeer received_by_peer);
 
   // Removes entries from the unacked packet map.
-  void DiscardPacket(QuicPacketSequenceNumber sequence_number);
+  void RemovePacket(QuicPacketSequenceNumber sequence_number);
 
   // Request that |sequence_number| be retransmitted after the other pending
   // retransmissions.  Does not add it to the retransmissions if it's already
   // a pending retransmission.
   void MarkForRetransmission(QuicPacketSequenceNumber sequence_number,
                              TransmissionType transmission_type);
 
   // Clears up to |num_to_clear| previous transmissions in order to make room
   // in the ack frame for new acks.
   void ClearPreviousRetransmissions(size_t num_to_clear);
 
   void CleanupPacketHistory();
 
-  // Removes |sequence_number| as a previous transmission of any other packets.
-  void RemovePreviousTransmission(QuicPacketSequenceNumber sequence_number);
-
   // Newly serialized retransmittable and fec packets are added to this map,
   // which contains owning pointers to any contained frames.  If a packet is
   // retransmitted, this map will contain entries for both the old and the new
   // packet. The old packet's retransmittable frames entry will be NULL, while
   // the new packet's entry will contain the frames to retransmit.
   // If the old packet is acked before the new packet, then the old entry will
   // be removed from the map and the new entry's retransmittable frames will be
   // set to NULL.
   UnackedPacketMap unacked_packets_;
 
@@ skipping 26 matching lines @@
   // Maximum number of tail loss probes to send before firing an RTO.
   size_t max_tail_loss_probes_;
   bool using_pacing_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSentPacketManager);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_SENT_PACKET_MANAGER_H_