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

net/quic/quic_protocol.cc

 // 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.
 
 #include "net/quic/quic_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
@@ skipping 153 matching lines @@
     case QUIC_VERSION_18:
       return MakeQuicTag('Q', '0', '1', '8');
     case QUIC_VERSION_19:
       return MakeQuicTag('Q', '0', '1', '9');
     case QUIC_VERSION_20:
       return MakeQuicTag('Q', '0', '2', '0');
     case QUIC_VERSION_21:
       return MakeQuicTag('Q', '0', '2', '1');
     case QUIC_VERSION_22:
       return MakeQuicTag('Q', '0', '2', '2');
+    case QUIC_VERSION_23:
+      return MakeQuicTag('Q', '0', '2', '3');
     default:
       // This shold be an ERROR because we should never attempt to convert an
       // invalid QuicVersion to be written to the wire.
       LOG(ERROR) << "Unsupported QuicVersion: " << version;
       return 0;
   }
 }
 
 QuicVersion QuicTagToQuicVersion(const QuicTag version_tag) {
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
@@ skipping 12 matching lines @@
 return #x
 
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_16);
     RETURN_STRING_LITERAL(QUIC_VERSION_18);
     RETURN_STRING_LITERAL(QUIC_VERSION_19);
     RETURN_STRING_LITERAL(QUIC_VERSION_20);
     RETURN_STRING_LITERAL(QUIC_VERSION_21);
     RETURN_STRING_LITERAL(QUIC_VERSION_22);
+    RETURN_STRING_LITERAL(QUIC_VERSION_23);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
 }
 
 string QuicVersionVectorToString(const QuicVersionVector& versions) {
   string result = "";
   for (size_t i = 0; i < versions.size(); ++i) {
     if (i != 0) {
       result.append(",");
@@ skipping 51 matching lines @@
       largest_observed(0),
       delta_time_largest_observed(QuicTime::Delta::Infinite()),
       is_truncated(false) {}
 
 QuicAckFrame::~QuicAckFrame() {}
 
 CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
     : receive_window(0) {
 }
 
-CongestionFeedbackMessageTimestamp::CongestionFeedbackMessageTimestamp() {
-}
-
-CongestionFeedbackMessageTimestamp::~CongestionFeedbackMessageTimestamp() {}
-
 QuicCongestionFeedbackFrame::QuicCongestionFeedbackFrame() : type(kTCP) {}
 
 QuicCongestionFeedbackFrame::~QuicCongestionFeedbackFrame() {}
 
 QuicRstStreamErrorCode AdjustErrorForVersion(
     QuicRstStreamErrorCode error_code,
     QuicVersion version) {
   switch (error_code) {
     case QUIC_RST_FLOW_CONTROL_ACCOUNTING:
       if (version < QUIC_VERSION_18) {
@@ skipping 84 matching lines @@
 QuicFecData::QuicFecData() : fec_group(0) {}
 
 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
      << " least_unacked: " << sent_info.least_unacked;
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
   os << "entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
-     << " is_truncated: " << ack_frame.is_truncated
      << " largest_observed: " << ack_frame.largest_observed
      << " delta_time_largest_observed: "
      << ack_frame.delta_time_largest_observed.ToMicroseconds()
      << " missing_packets: [ ";
   for (SequenceNumberSet::const_iterator it = ack_frame.missing_packets.begin();
        it != ack_frame.missing_packets.end(); ++it) {
     os << *it << " ";
   }
-  os << " ] revived_packets: [ ";
+  os << " ] is_truncated: " << ack_frame.is_truncated;

[ramant (doing other things), 2014/08/23 23:55:29]

minor change to print the data in the same order as it was declared in
QuicAckFrame.

+  os << " revived_packets: [ ";
   for (SequenceNumberSet::const_iterator it = ack_frame.revived_packets.begin();
        it != ack_frame.revived_packets.end(); ++it) {
     os << *it << " ";
   }
+  os << " ] received_packets: [ ";
+  for (PacketTimeList::const_iterator it =
+           ack_frame.received_packet_times.begin();
+           it != ack_frame.received_packet_times.end(); ++it) {
+    os << it->first << " at " << it->second.ToDebuggingValue() << " ";
+  }
   os << " ]";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicFrame& frame) {
   switch (frame.type) {
   case PADDING_FRAME: {
       os << "type { PADDING_FRAME } ";
       break;
     }
@@ skipping 87 matching lines @@
      << "data { "
      << QuicUtils::StringToHexASCIIDump(*(stream_frame.GetDataAsString()))
      << " }\n";
   return os;
 }
 
 ostream& operator<<(ostream& os,
                     const QuicCongestionFeedbackFrame& congestion_frame) {
   os << "type: " << congestion_frame.type;
   switch (congestion_frame.type) {
-    case kTimestamp: {
-      const CongestionFeedbackMessageTimestamp& timestamp =
-          congestion_frame.timestamp;
-      os << " received packets: [ ";
-      for (TimeMap::const_iterator it = timestamp.received_packet_times.begin();
-           it != timestamp.received_packet_times.end(); ++it) {
-        os << it->first << "@" << it->second.ToDebuggingValue() << " ";
-      }
-      os << "]";
-      break;
-    }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
       os << " receive_window: " << tcp.receive_window;
       break;
     }
   }
   return os;
 }
 
 QuicGoAwayFrame::QuicGoAwayFrame()
@@ skipping 229 matching lines @@
       sent_time(QuicTime::Zero()),
       bytes_sent(0),
       nack_count(0),
       transmission_type(transmission_type),
       all_transmissions(all_transmissions),
       in_flight(false) {
   all_transmissions->insert(sequence_number);
 }
 
 }  // namespace net