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 @@
 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
   switch (version) {
     case QUIC_VERSION_12:
       return MakeQuicTag('Q', '0', '1', '2');
     case QUIC_VERSION_13:
       return MakeQuicTag('Q', '0', '1', '3');
     case QUIC_VERSION_14:
       return MakeQuicTag('Q', '0', '1', '4');
     case QUIC_VERSION_15:
       return MakeQuicTag('Q', '0', '1', '5');
+    case QUIC_VERSION_16:
+      return MakeQuicTag('Q', '0', '1', '6');
     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 10 matching lines @@
 #define RETURN_STRING_LITERAL(x) \
 case x: \
 return #x
 
 string QuicVersionToString(const QuicVersion version) {
   switch (version) {
     RETURN_STRING_LITERAL(QUIC_VERSION_12);
     RETURN_STRING_LITERAL(QUIC_VERSION_13);
     RETURN_STRING_LITERAL(QUIC_VERSION_14);
     RETURN_STRING_LITERAL(QUIC_VERSION_15);
+    RETURN_STRING_LITERAL(QUIC_VERSION_16);
     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 40 matching lines @@
 }
 
 void InsertMissingPacketsBetween(ReceivedPacketInfo* received_info,
                                  QuicPacketSequenceNumber lower,
                                  QuicPacketSequenceNumber higher) {
   for (QuicPacketSequenceNumber i = lower; i < higher; ++i) {
     received_info->missing_packets.insert(i);
   }
 }
 
-SentPacketInfo::SentPacketInfo()
+QuicStopWaitingFrame::QuicStopWaitingFrame()
     : entropy_hash(0),
       least_unacked(0) {
 }
 
-SentPacketInfo::~SentPacketInfo() {}
+QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 
 QuicAckFrame::QuicAckFrame() {}
 
 QuicAckFrame::QuicAckFrame(QuicPacketSequenceNumber largest_observed,
                            QuicTime largest_observed_receive_time,
                            QuicPacketSequenceNumber least_unacked) {
   received_info.largest_observed = largest_observed;
   received_info.entropy_hash = 0;
   sent_info.least_unacked = least_unacked;
   sent_info.entropy_hash = 0;
@@ skipping 46 matching lines @@
 QuicFrame::QuicFrame(QuicAckFrame* frame)
     : type(ACK_FRAME),
       ack_frame(frame) {
 }
 
 QuicFrame::QuicFrame(QuicCongestionFeedbackFrame* frame)
     : type(CONGESTION_FEEDBACK_FRAME),
       congestion_feedback_frame(frame) {
 }
 
+QuicFrame::QuicFrame(QuicStopWaitingFrame* frame)
+    : type(STOP_WAITING_FRAME),
+      stop_waiting_frame(frame) {
+}
+
 QuicFrame::QuicFrame(QuicRstStreamFrame* frame)
     : type(RST_STREAM_FRAME),
       rst_stream_frame(frame) {
 }
 
 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame)
     : type(CONNECTION_CLOSE_FRAME),
       connection_close_frame(frame) {
 }
 
 QuicFrame::QuicFrame(QuicGoAwayFrame* frame)
     : type(GOAWAY_FRAME),
       goaway_frame(frame) {
 }
 
 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
     : type(WINDOW_UPDATE_FRAME),
       window_update_frame(frame) {
 }
 
 QuicFrame::QuicFrame(QuicBlockedFrame* frame)
     : type(BLOCKED_FRAME),
       blocked_frame(frame) {
 }
 
 QuicFecData::QuicFecData() : fec_group(0) {}
 
-ostream& operator<<(ostream& os, const SentPacketInfo& sent_info) {
+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
      << " missing_packets: [ ";
@@ skipping 45 matching lines @@
     }
     case ACK_FRAME: {
       os << "type { ACK_FRAME } " << *(frame.ack_frame);
       break;
     }
     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;
+    }
     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 187 matching lines @@
         break;
       case STREAM_FRAME:
         delete it->stream_frame;
         break;
       case ACK_FRAME:
         delete it->ack_frame;
         break;
       case CONGESTION_FEEDBACK_FRAME:
         delete it->congestion_feedback_frame;
         break;
+      case STOP_WAITING_FRAME:
+        delete it->stop_waiting_frame;
+        break;
       case RST_STREAM_FRAME:
         delete it->rst_stream_frame;
         break;
       case CONNECTION_CLOSE_FRAME:
         delete it->connection_close_frame;
         break;
       case GOAWAY_FRAME:
         delete it->goaway_frame;
         break;
       case WINDOW_UPDATE_FRAME:
@@ skipping 80 matching lines @@
   return os;
 }
 
 WriteResult::WriteResult(WriteStatus status,
                          int bytes_written_or_error_code)
     : status(status),
       bytes_written(bytes_written_or_error_code) {
 }
 
 }  // namespace net