Add QUIC_VERSION_15 to add a revived_packets set to replace the

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 139 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');
     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) {
     if (version_tag == QuicVersionToQuicTag(kSupportedQuicVersions[i])) {
       return kSupportedQuicVersions[i];
     }
   }
   // Reading from the client so this should not be considered an ERROR.
   DVLOG(1) << "Unsupported QuicTag version: "
            << 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_12);
     RETURN_STRING_LITERAL(QUIC_VERSION_13);
     RETURN_STRING_LITERAL(QUIC_VERSION_14);
+    RETURN_STRING_LITERAL(QUIC_VERSION_15);
     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 154 matching lines @@
 
 ostream& operator<<(ostream& os, const ReceivedPacketInfo& received_info) {
   os << "entropy_hash: " << static_cast<int>(received_info.entropy_hash)
      << " largest_observed: " << received_info.largest_observed
      << " missing_packets: [ ";
   for (SequenceNumberSet::const_iterator it =
            received_info.missing_packets.begin();
        it != received_info.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) {
+    os << *it << " ";
+  }
   os << " ] ";
   return os;
 }
 
 ostream& operator<<(ostream& os, const QuicFrame& frame) {
   switch (frame.type) {
   case PADDING_FRAME: {
       os << "type { PADDING_FRAME } ";
       break;
     }
@@ skipping 331 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