Adding transmission times for every QUIC packet received in the AckFrame.

net/quic/quic_protocol.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.
 
 #ifndef NET_QUIC_QUIC_PROTOCOL_H_
 #define NET_QUIC_QUIC_PROTOCOL_H_
 
 #include <limits>
+#include <map>
 #include <ostream>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "net/base/int128.h"
 #include "net/base/net_export.h"
@@ skipping 142 matching lines @@
   bool fin;
   uint64 offset;
   base::StringPiece data;
 };
 
 typedef base::hash_set<QuicPacketSequenceNumber> SequenceSet;
 
 struct NET_EXPORT_PRIVATE ReceivedPacketInfo {
   ReceivedPacketInfo();
   ~ReceivedPacketInfo();
+
+  void RecordAck(QuicPacketSequenceNumber sequence_number, QuicTime time);
+  bool ContainsAck(QuicPacketSequenceNumber sequence_number) const;
+  void ClearAcksBefore(QuicPacketSequenceNumber least_unacked);
+
   // The highest packet sequence number we've received from the peer.
   QuicPacketSequenceNumber largest_received;
-  // The time at which we received the above packet.
-  QuicTime time_received;
-  // The set of packets which we're expecting and have not received.
-  // This includes any packets between the lowest and largest_received
-  // which we have neither seen nor been informed are non-retransmitting.
-  SequenceSet missing_packets;
+
+  // The set of all received packets and their arrival times.
+  std::map<QuicPacketSequenceNumber, QuicTime> received_packet_times;
 };
 
 struct NET_EXPORT_PRIVATE SentPacketInfo {
   SentPacketInfo();
   ~SentPacketInfo();
   // The lowest packet we've sent which is unacked, and we expect an ack for.
   QuicPacketSequenceNumber least_unacked;
-  // The set of packets between least_unacked and the last packet we have sent
-  // which we will not resend.
-  SequenceSet non_retransmiting;
 };
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
 // kTCP MUST be supported by all QUIC implementations to guarentee 100%
 // compatibility.
 enum CongestionFeedbackType {
   kNone = 0,  // No feedback provided
   kTCP,  // Used to mimic TCP.
   kInterArrival,  // Use additional inter arrival information.
   kFixRate,  // Provided for testing.
@@ skipping 35 matching lines @@
   CongestionFeedbackType type;
   union {
     CongestionFeedbackMessageTCP tcp;
     CongestionFeedbackMessageInterArrival inter_arrival;
     CongestionFeedbackMessageFixRate fix_rate;
   };
 };
 
 struct NET_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame() {}
+  // Testing convenience method to construct a QuicAckFrame with all packets
+  // from least_unacked to largest_received acked at time_received.
   QuicAckFrame(QuicPacketSequenceNumber largest_received,
                QuicTime time_received,
-               QuicPacketSequenceNumber least_unacked) {
-    received_info.largest_received = largest_received;
-    received_info.time_received = time_received;
-    sent_info.least_unacked = least_unacked;
-    congestion_info.type = kNone;
-  }
+               QuicPacketSequenceNumber least_unacked);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
                                                      const QuicAckFrame& s);
 
   SentPacketInfo sent_info;
   ReceivedPacketInfo received_info;
   CongestionInfo congestion_info;
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
@@ skipping 136 matching lines @@
     return base::StringPiece(data() + kStartOfHashData, kStartOfEncryptedData);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuicEncryptedPacket);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_