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

net/quic/quic_protocol.cc

Index: net/quic/quic_protocol.cc
diff --git a/net/quic/quic_protocol.cc b/net/quic/quic_protocol.cc
index 878ffee329138f2ae25f5988dbc0c3db3e353640..4923ae193bbe1190dfd97251b544ffe0338b205e 100644
--- a/net/quic/quic_protocol.cc
+++ b/net/quic/quic_protocol.cc
@@ -3,8 +3,10 @@
 // found in the LICENSE file.
 
 #include "net/quic/quic_protocol.h"
+#include "base/stl_util.h"
 
 using base::StringPiece;
+using std::map;
 using std::ostream;
 
 namespace net {
@@ -21,30 +23,89 @@ QuicStreamFrame::QuicStreamFrame(QuicStreamId stream_id,
       data(data) {
 }
 
-ReceivedPacketInfo::ReceivedPacketInfo() {}
+// TODO(ianswett): Initializing largest_received to 0 should not be necessary.
+ReceivedPacketInfo::ReceivedPacketInfo() : largest_received(0) {}
 
 ReceivedPacketInfo::~ReceivedPacketInfo() {}
 
+void ReceivedPacketInfo::RecordAck(QuicPacketSequenceNumber sequence_number,
+                                   QuicTime time) {
+  DCHECK(!ContainsAck(sequence_number));
+  received_packet_times[sequence_number] = time;
+  if (largest_received < sequence_number) {
+    largest_received = sequence_number;
+  }
+}
+
+bool ReceivedPacketInfo::ContainsAck(
+    QuicPacketSequenceNumber sequence_number) const {
+  return ContainsKey(received_packet_times, sequence_number);
+}
+
+void ReceivedPacketInfo::ClearAcksBefore(
+    QuicPacketSequenceNumber least_unacked) {
+  for (QuicPacketSequenceNumber i = received_packet_times.begin()->first;
+       i < least_unacked; ++i) {
+    received_packet_times.erase(i);
+  }
+}
+
 SentPacketInfo::SentPacketInfo() {}
 
 SentPacketInfo::~SentPacketInfo() {}
 
+QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_received,
+                           QuicTime time_received,
+                           QuicPacketSequenceNumber least_unacked) {
+  received_info.largest_received = largest_received;
+  if (largest_received > 0) {
+    for (QuicPacketSequenceNumber seq_num = 0;
+         seq_num <= largest_received; ++seq_num) {
+      received_info.RecordAck(seq_num, time_received);
+    }
+  }
+  sent_info.least_unacked = least_unacked;
+  congestion_info.type = kNone;
+}
+
 ostream& operator<<(ostream& os, const QuicAckFrame& s) {
-  os << "largest_received: " << s.received_info.largest_received
-     << " time: " << s.received_info.time_received.ToMicroseconds()
-     << " missing: ";
-  for (SequenceSet::const_iterator it = s.received_info.missing_packets.begin();
-       it != s.received_info.missing_packets.end(); ++it) {
-    os << *it << " ";
+  os << "sent info { least_waiting: " << s.sent_info.least_unacked << " } "
+     << "received info { largest_received: "
+     << s.received_info.largest_received
+     << " received packets: [ ";
+  for (map<QuicPacketSequenceNumber, QuicTime>::const_iterator it =
+           s.received_info.received_packet_times.begin();
+       it != s.received_info.received_packet_times.end(); ++it) {
+    os << it->first << "@" << it->second.ToMilliseconds() << " ";
   }
 
-  os << " least_waiting: " << s.sent_info.least_unacked
-     << " no_retransmit: ";
-  for (SequenceSet::const_iterator it = s.sent_info.non_retransmiting.begin();
-       it != s.sent_info.non_retransmiting.end(); ++it) {
-    os << *it << " ";
+  os << "] } congestion info { type: " << s.congestion_info.type;
+  switch (s.congestion_info.type) {
+    case kNone:
+      break;
+    case kInterArrival: {
+      const CongestionFeedbackMessageInterArrival& inter_arrival =
+          s.congestion_info.inter_arrival;
+      os << " accumulated_number_of_lost_packets: "
+         << inter_arrival.accumulated_number_of_lost_packets;
+      os << " offset_time: " << inter_arrival.offset_time;
+      os << " delta_time: " << inter_arrival.delta_time;
+      break;
+    }
+    case kFixRate: {
+      os << " bitrate_in_bytes_per_second: "
+         << s.congestion_info.fix_rate.bitrate_in_bytes_per_second;
+      break;
+    }
+    case kTCP: {
+      const CongestionFeedbackMessageTCP& tcp = s.congestion_info.tcp;
+      os << " accumulated_number_of_lost_packets: "
+         << tcp.accumulated_number_of_lost_packets;
+      os << " receive_window: " << tcp.receive_window;
+      break;
+    }
   }
-  os << "\n";
+  os << " }\n";
   return os;
 }