Adds QUIC_VERSION_36 which adds support to force HOL blocking between streams for measurement purpo…

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 "base/strings/string_number_conversions.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
@@ skipping 174 matching lines @@
   for (QuicVersion version : versions) {
     if (version < QUIC_VERSION_30) {
       if (!FLAGS_quic_disable_pre_30) {
         filtered_versions.push_back(version);
       }
     } else {
       if (version == QUIC_VERSION_35) {
         if (FLAGS_quic_enable_version_35) {
           filtered_versions.push_back(version);
         }
+      } else if (version == QUIC_VERSION_36) {
+        if (FLAGS_quic_enable_version_35 && FLAGS_quic_enable_version_36) {
+          filtered_versions.push_back(version);
+        }
       } else {
         filtered_versions.push_back(version);
       }
     }
   }
   return filtered_versions;
 }
 
 QuicTag QuicVersionToQuicTag(const QuicVersion version) {
   switch (version) {
@@ skipping 12 matching lines @@
     case QUIC_VERSION_31:
       return MakeQuicTag('Q', '0', '3', '1');
     case QUIC_VERSION_32:
       return MakeQuicTag('Q', '0', '3', '2');
     case QUIC_VERSION_33:
       return MakeQuicTag('Q', '0', '3', '3');
     case QUIC_VERSION_34:
       return MakeQuicTag('Q', '0', '3', '4');
     case QUIC_VERSION_35:
       return MakeQuicTag('Q', '0', '3', '5');
+    case QUIC_VERSION_36:
+      return MakeQuicTag('Q', '0', '3', '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 17 matching lines @@
     RETURN_STRING_LITERAL(QUIC_VERSION_26);
     RETURN_STRING_LITERAL(QUIC_VERSION_27);
     RETURN_STRING_LITERAL(QUIC_VERSION_28);
     RETURN_STRING_LITERAL(QUIC_VERSION_29);
     RETURN_STRING_LITERAL(QUIC_VERSION_30);
     RETURN_STRING_LITERAL(QUIC_VERSION_31);
     RETURN_STRING_LITERAL(QUIC_VERSION_32);
     RETURN_STRING_LITERAL(QUIC_VERSION_33);
     RETURN_STRING_LITERAL(QUIC_VERSION_34);
     RETURN_STRING_LITERAL(QUIC_VERSION_35);
+    RETURN_STRING_LITERAL(QUIC_VERSION_36);
     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 598 matching lines @@
       is_unackable(false),
       has_crypto_handshake(has_crypto_handshake),
       num_padding_bytes(num_padding_bytes),
       retransmission(0) {}
 
 TransmissionInfo::TransmissionInfo(const TransmissionInfo& other) = default;
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net