Change the wire format of the ack frame to include a compressed version

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 <stddef.h>
 #include <limits>
+#include <list>
 #include <map>
 #include <ostream>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
@@ skipping 264 matching lines @@
 enum QuicVersion {
   // Special case to indicate unknown/unsupported QUIC version.
   QUIC_VERSION_UNSUPPORTED = 0,
 
   QUIC_VERSION_16 = 16,  // STOP_WAITING frame.
   QUIC_VERSION_18 = 18,  // PING frame.
   QUIC_VERSION_19 = 19,  // Connection level flow control.
   QUIC_VERSION_20 = 20,  // Independent stream/connection flow control windows.
   QUIC_VERSION_21 = 21,  // Headers/crypto streams are flow controlled.
   QUIC_VERSION_22 = 22,  // Send Server Config Update messages on crypto stream.
+  QUIC_VERSION_23 = 23,  // Timestamp in the ack frame.
 };
 
 // This vector contains QUIC versions which we currently support.
 // This should be ordered such that the highest supported version is the first
 // element, with subsequent elements in descending order (versions can be
 // skipped as necessary).
 //
 // IMPORTANT: if you are adding to this list, follow the instructions at
 // http://sites/quic/adding-and-removing-versions
-static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_22,
+static const QuicVersion kSupportedQuicVersions[] = {QUIC_VERSION_23,
+                                                     QUIC_VERSION_22,
                                                      QUIC_VERSION_21,
                                                      QUIC_VERSION_20,
                                                      QUIC_VERSION_19,
                                                      QUIC_VERSION_18,
                                                      QUIC_VERSION_16};
 
 typedef std::vector<QuicVersion> QuicVersionVector;
 
 // Returns a vector of QUIC versions in kSupportedQuicVersions.
 NET_EXPORT_PRIVATE QuicVersionVector QuicSupportedVersions();
@@ skipping 323 matching lines @@
   IOVector data;
 
   // If this is set, then when this packet is ACKed the AckNotifier will be
   // informed.
   QuicAckNotifier* notifier;
 };
 
 // TODO(ianswett): Re-evaluate the trade-offs of hash_set vs set when framing
 // is finalized.
 typedef std::set<QuicPacketSequenceNumber> SequenceNumberSet;
-// TODO(pwestin): Add a way to enforce the max size of this map.
-typedef std::map<QuicPacketSequenceNumber, QuicTime> TimeMap;
+
+typedef std::list<std::pair<QuicPacketSequenceNumber, QuicTime>> PacketTimeList;
 
 struct NET_EXPORT_PRIVATE QuicStopWaitingFrame {
   QuicStopWaitingFrame();
   ~QuicStopWaitingFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicStopWaitingFrame& s);
   // Entropy hash of all packets up to, but not including, the least unacked
   // packet.
   QuicPacketEntropyHash entropy_hash;
@@ skipping 30 matching lines @@
   // structure.
   // The set of packets which we're expecting and have not received.
   SequenceNumberSet missing_packets;
 
   // Whether the ack had to be truncated when sent.
   bool is_truncated;
 
   // Packets which have been revived via FEC.
   // All of these must also be in missing_packets.
   SequenceNumberSet revived_packets;
+
+  // List of <sequence_number, time> for when packets arrived.
+  PacketTimeList received_packet_times;
 };
 
 // True if the sequence number is greater than largest_observed or is listed
 // as missing.
 // Always returns false for sequence numbers less than least_unacked.
 bool NET_EXPORT_PRIVATE IsAwaitingPacket(
     const QuicAckFrame& ack_frame,
     QuicPacketSequenceNumber sequence_number);
 
 // Inserts missing packets between [lower, higher).
 void NET_EXPORT_PRIVATE InsertMissingPacketsBetween(
     QuicAckFrame* ack_frame,
     QuicPacketSequenceNumber lower,
     QuicPacketSequenceNumber higher);
 
 // Defines for all types of congestion feedback that will be negotiated in QUIC,
 // kTCP MUST be supported by all QUIC implementations to guarantee 100%
 // compatibility.
+// TODO(cyr): Remove this when removing QUIC_VERSION_22.
 enum CongestionFeedbackType {
   kTCP,  // Used to mimic TCP.
-  kTimestamp,  // Use additional inter arrival timestamp information.
 };
 
 // Defines for all types of congestion control algorithms that can be used in
 // QUIC. Note that this is separate from the congestion feedback type -
 // some congestion control algorithms may use the same feedback type
 // (Reno and Cubic are the classic example for that).
 enum CongestionControlType {
   kCubic,
   kReno,
   kBBR,
 };
 
 enum LossDetectionType {
   kNack,  // Used to mimic TCP's loss detection.
   kTime,  // Time based loss detection.
 };
 
+// TODO(cyr): Remove this when removing QUIC_VERSION_22.
 struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTCP {
   CongestionFeedbackMessageTCP();
 
   QuicByteCount receive_window;
 };
 
-struct NET_EXPORT_PRIVATE CongestionFeedbackMessageTimestamp {
-  CongestionFeedbackMessageTimestamp();
-  ~CongestionFeedbackMessageTimestamp();
-
-  // The set of received packets since the last feedback was sent, along with
-  // their arrival times.
-  TimeMap received_packet_times;
-};
-
+// TODO(cyr): Remove this when removing QUIC_VERSION_22.
 struct NET_EXPORT_PRIVATE QuicCongestionFeedbackFrame {
   QuicCongestionFeedbackFrame();
   ~QuicCongestionFeedbackFrame();
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicCongestionFeedbackFrame& c);
 
   CongestionFeedbackType type;
   // This should really be a union, but since the timestamp struct
   // is non-trivial, C++ prohibits it.
   CongestionFeedbackMessageTCP tcp;
-  CongestionFeedbackMessageTimestamp timestamp;
 };
 
 struct NET_EXPORT_PRIVATE QuicRstStreamFrame {
   QuicRstStreamFrame();
   QuicRstStreamFrame(QuicStreamId stream_id,
                      QuicRstStreamErrorCode error_code,
                      QuicStreamOffset bytes_written);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicRstStreamFrame& r);
@@ skipping 80 matching lines @@
   ENCRYPTION_FORWARD_SECURE = 2,
 
   NUM_ENCRYPTION_LEVELS,
 };
 
 struct NET_EXPORT_PRIVATE QuicFrame {
   QuicFrame();
   explicit QuicFrame(QuicPaddingFrame* padding_frame);
   explicit QuicFrame(QuicStreamFrame* stream_frame);
   explicit QuicFrame(QuicAckFrame* frame);
+
+  // TODO(cyr): Remove this when removing QUIC_VERSION_22.
   explicit QuicFrame(QuicCongestionFeedbackFrame* frame);
+
   explicit QuicFrame(QuicRstStreamFrame* frame);
   explicit QuicFrame(QuicConnectionCloseFrame* frame);
   explicit QuicFrame(QuicStopWaitingFrame* frame);
   explicit QuicFrame(QuicPingFrame* frame);
   explicit QuicFrame(QuicGoAwayFrame* frame);
   explicit QuicFrame(QuicWindowUpdateFrame* frame);
   explicit QuicFrame(QuicBlockedFrame* frame);
 
   NET_EXPORT_PRIVATE friend std::ostream& operator<<(
       std::ostream& os, const QuicFrame& frame);
 
   QuicFrameType type;
   union {
     QuicPaddingFrame* padding_frame;
     QuicStreamFrame* stream_frame;
     QuicAckFrame* ack_frame;
+
+    // TODO(cyr): Remove this when removing QUIC_VERSION_22.
     QuicCongestionFeedbackFrame* congestion_feedback_frame;
     QuicStopWaitingFrame* stop_waiting_frame;
+
     QuicPingFrame* ping_frame;
     QuicRstStreamFrame* rst_stream_frame;
     QuicConnectionCloseFrame* connection_close_frame;
     QuicGoAwayFrame* goaway_frame;
     QuicWindowUpdateFrame* window_update_frame;
     QuicBlockedFrame* blocked_frame;
   };
 };
 
 typedef std::vector<QuicFrame> QuicFrames;
@@ skipping 179 matching lines @@
   // Stores the sequence numbers of all transmissions of this packet.
   // Can never be null.
   SequenceNumberSet* all_transmissions;
   // In flight packets have not been abandoned or lost.
   bool in_flight;
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PROTOCOL_H_