Land Recent QUIC Changes.

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 141 matching lines @@
 QuicVersionVector QuicSupportedVersions() {
   QuicVersionVector supported_versions;
   for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) {
     supported_versions.push_back(kSupportedQuicVersions[i]);
   }
   return supported_versions;
 }
 
 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
   switch (version) {
-    case QUIC_VERSION_15:
-      return MakeQuicTag('Q', '0', '1', '5');
     case QUIC_VERSION_16:
       return MakeQuicTag('Q', '0', '1', '6');
     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');
@@ skipping 16 matching lines @@
            << QuicUtils::TagToString(version_tag);
   return QUIC_VERSION_UNSUPPORTED;
 }
 
 #define RETURN_STRING_LITERAL(x) \
 case x: \
 return #x
 
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
-    RETURN_STRING_LITERAL(QUIC_VERSION_15);
     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);
     default:
       return "QUIC_VERSION_UNSUPPORTED";
   }
 }
 
@@ skipping 23 matching lines @@
   }
   os << ", fec_flag: " << header.fec_flag
      << ", entropy_flag: " << header.entropy_flag
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", sequence_number: " << header.packet_sequence_number
      << ", is_in_fec_group:" << header.is_in_fec_group
      << ", fec_group: " << header.fec_group<< "}\n";
   return os;
 }
 
-ReceivedPacketInfo::ReceivedPacketInfo()
-    : entropy_hash(0),
-      largest_observed(0),
-      delta_time_largest_observed(QuicTime::Delta::Infinite()),
-      is_truncated(false) {}
-
-ReceivedPacketInfo::~ReceivedPacketInfo() {}
-
-bool IsAwaitingPacket(const ReceivedPacketInfo& received_info,
+bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
                       QuicPacketSequenceNumber sequence_number) {
-  return sequence_number > received_info.largest_observed ||
-      ContainsKey(received_info.missing_packets, sequence_number);
+  return sequence_number > ack_frame.largest_observed ||
+      ContainsKey(ack_frame.missing_packets, sequence_number);
 }
 
-void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
+void InsertMissingPacketsBetween(QuicAckFrame* ack_frame,
                                  QuicPacketSequenceNumber lower,
                                  QuicPacketSequenceNumber higher) {
   for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
-    received_info->missing_packets.insert(i);
+    ack_frame->missing_packets.insert(i);
   }
 }
 
 QuicStopWaitingFrame::QuicStopWaitingFrame()
     : entropy_hash(0),
       least_unacked(0) {
 }
 
 QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 
-QuicAckFrame::QuicAckFrame() {}
+QuicAckFrame::QuicAckFrame()
+    : entropy_hash(0),
+      largest_observed(0),
+      delta_time_largest_observed(QuicTime::Delta::Infinite()),
+      is_truncated(false) {}
+
+QuicAckFrame::~QuicAckFrame() {}
 
 CongestionFeedbackMessageTCP::CongestionFeedbackMessageTCP()
     : receive_window(0) {
 }
 
 CongestionFeedbackMessageInterArrival::CongestionFeedbackMessageInterArrival() {
 }
 
 CongestionFeedbackMessageInterArrival::
     ~CongestionFeedbackMessageInterArrival() {}
@@ skipping 93 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 ReceivedPacketInfo& received_info) {
-  os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
-     << " is_truncated: " << received_info.is_truncated
-     << " largest_observed: " << received_info.largest_observed
+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: "
-     << received_info.delta_time_largest_observed.ToMicroseconds()
+     << ack_frame.delta_time_largest_observed.ToMicroseconds()
      << " missing_packets: [ ";
-  for (SequenceNumberSet::const_iterator it =
-           received_info.missing_packets.begin();
-       it != received_info.missing_packets.end(); ++it) {
+  for (SequenceNumberSet::const_iterator it = ack_frame.missing_packets.begin();
+       it != ack_frame.missing_packets.end(); ++it) {
     os << *it << " ";
   }
   os << " ] revived_packets: [ ";
-  for (SequenceNumberSet::const_iterator it =
-           received_info.revived_packets.begin();
-       it != received_info.revived_packets.end(); ++it) {
+  for (SequenceNumberSet::const_iterator it = ack_frame.revived_packets.begin();
+       it != ack_frame.revived_packets.end(); ++it) {
     os << *it << " ";
   }
   os << " ]";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicFrame& frame) {
   switch (frame.type) {
   case PADDING_FRAME: {
       os << "type { PADDING_FRAME } ";
@@ skipping 30 matching lines @@
     }
     case CONGESTION_FEEDBACK_FRAME: {
       os << "type { CONGESTION_FEEDBACK_FRAME } "
          << *(frame.congestion_feedback_frame);
       break;
     }
     case STOP_WAITING_FRAME: {
       os << "type { STOP_WAITING_FRAME } " << *(frame.stop_waiting_frame);
       break;
     }
+    case PING_FRAME: {
+      os << "type { PING_FRAME } ";
+      break;
+    }
     default: {
       LOG(ERROR) << "Unknown frame type: " << frame.type;
       break;
     }
   }
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicRstStreamFrame& rst_frame) {
   os << "stream_id { " << rst_frame.stream_id << " } "
@@ skipping 31 matching lines @@
 ostream& operator<<(ostream& os, const QuicStreamFrame& stream_frame) {
   os << "stream_id { " << stream_frame.stream_id << " } "
      << "fin { " << stream_frame.fin << " } "
      << "offset { " << stream_frame.offset << " } "
      << "data { "
      << QuicUtils::StringToHexASCIIDump(*(stream_frame.GetDataAsString()))
      << " }\n";
   return os;
 }
 
-ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
-  os << "sent info { " << ack_frame.sent_info << " } "
-     << "received info { " << ack_frame.received_info << " }\n";
-  return os;
-}
-
 ostream& operator<<(ostream& os,
                     const QuicCongestionFeedbackFrame& congestion_frame) {
   os << "type: " << congestion_frame.type;
   switch (congestion_frame.type) {
     case kInterArrival: {
       const CongestionFeedbackMessageInterArrival& inter_arrival =
           congestion_frame.inter_arrival;
       os << " received packets: [ ";
       for (TimeMap::const_iterator it =
                inter_arrival.received_packet_times.begin();
            it != inter_arrival.received_packet_times.end(); ++it) {
         os << it->first << "@" << it->second.ToDebuggingValue() << " ";
       }
       os << "]";
       break;
     }
-    case kFixRate: {
-      os << " bitrate_in_bytes_per_second: "
-         << congestion_frame.fix_rate.bitrate.ToBytesPerSecond();
-      break;
-    }
     case kTCP: {
       const CongestionFeedbackMessageTCP& tcp = congestion_frame.tcp;
       os << " receive_window: " << tcp.receive_window;
       break;
     }
   }
   return os;
 }
 
-CongestionFeedbackMessageFixRate::CongestionFeedbackMessageFixRate()
-    : bitrate(QuicBandwidth::Zero()) {
-}
-
 QuicGoAwayFrame::QuicGoAwayFrame()
     : error_code(QUIC_NO_ERROR),
       last_good_stream_id(0) {
 }
 
 QuicGoAwayFrame::QuicGoAwayFrame(QuicErrorCode error_code,
                                  QuicStreamId last_good_stream_id,
                                  const string& reason)
     : error_code(error_code),
       last_good_stream_id(last_good_stream_id),
@@ skipping 226 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