Killing off QUICv12, including cleaning out all of the code for handling

net/quic/crypto/quic_crypto_server_config.cc

 // Copyright 2013 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/crypto/quic_crypto_server_config.h"
 
 #include <stdlib.h>
 #include <algorithm>
 
 #include "base/stl_util.h"
@@ skipping 224 matching lines @@
                                  p256_public_value.size());
   }
 
   msg.set_tag(kSCFG);
   if (options.p256) {
     msg.SetTaglist(kKEXS, kC255, kP256, 0);
   } else {
     msg.SetTaglist(kKEXS, kC255, 0);
   }
   msg.SetTaglist(kAEAD, kAESG, 0);
-  // TODO(rch): Remove once we remove QUIC_VERSION_12.
-  msg.SetValue(kVERS, static_cast<uint16>(0));
   msg.SetStringPiece(kPUBS, encoded_public_values);
 
   if (options.expiry_time.IsZero()) {
     const QuicWallTime now = clock->WallNow();
     const QuicWallTime expiry = now.Add(QuicTime::Delta::FromSeconds(
         60 * 60 * 24 * 180 /* 180 days, ~six months */));
     const uint64 expiry_seconds = expiry.ToUNIXSeconds();
     msg.SetValue(kEXPY, expiry_seconds);
   } else {
     msg.SetValue(kEXPY, options.expiry_time.ToUNIXSeconds());
@@ skipping 220 matching lines @@
 
   const CryptoHandshakeMessage& client_hello =
       validate_chlo_result.client_hello;
   const ClientHelloInfo& info = validate_chlo_result.info;
 
   // If the client's preferred version is not the version we are currently
   // speaking, then the client went through a version negotiation.  In this
   // case, we need to make sure that we actually do not support this version
   // and that it wasn't a downgrade attack.
   QuicTag client_version_tag;
-  // TODO(rch): Make this check mandatory when we remove QUIC_VERSION_12.
+  // TODO(rch): Make this check mandatory.
   if (client_hello.GetUint32(kVER, &client_version_tag) == QUIC_NO_ERROR) {
     QuicVersion client_version = QuicTagToQuicVersion(client_version_tag);
     if (client_version != version) {
       // Just because client_version is a valid version enum doesn't mean that
       // this server actually supports that version, so we check to see if
       // it's actually in the supported versions list.
       for (size_t i = 0; i < supported_versions.size(); ++i) {
         if (client_version == supported_versions[i]) {
           *error_details = "Downgrade attack detected";
           return QUIC_VERSION_NEGOTIATION_MISMATCH;
@@ skipping 325 matching lines @@
 void QuicCryptoServerConfig::EvaluateClientHello(
     const uint8* primary_orbit,
     ValidateClientHelloResultCallback::Result* client_hello_state,
     ValidateClientHelloResultCallback* done_cb) const {
   ValidateClientHelloHelper helper(client_hello_state, done_cb);
 
   const CryptoHandshakeMessage& client_hello =
       client_hello_state->client_hello;
   ClientHelloInfo* info = &(client_hello_state->info);
 
-  if (client_hello.size() < kClientHelloMinimumSizeOld) {
+  if (client_hello.size() < kClientHelloMinimumSize) {
     helper.ValidationComplete(QUIC_CRYPTO_INVALID_VALUE_LENGTH,
                               "Client hello too small");
     return;
   }
 
   if (client_hello.GetStringPiece(kSNI, &info->sni) &&
       !CryptoUtils::IsValidSNI(info->sni)) {
     helper.ValidationComplete(QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER,
                               "Invalid SNI name");
     return;
@@ skipping 128 matching lines @@
   const size_t kREJOverheadBytes = 166;
   // kMultiplier is the multiple of the CHLO message size that a REJ message
   // must stay under when the client doesn't present a valid source-address
   // token.
   const size_t kMultiplier = 2;
   // max_unverified_size is the number of bytes that the certificate chain
   // and signature can consume before we will demand a valid source-address
   // token.
   const size_t max_unverified_size =
       client_hello.size() * kMultiplier - kREJOverheadBytes;
-  COMPILE_ASSERT(kClientHelloMinimumSizeOld * kMultiplier >= kREJOverheadBytes,
+  COMPILE_ASSERT(kClientHelloMinimumSize * kMultiplier >= kREJOverheadBytes,
                  overhead_calculation_may_underflow);
   if (info.valid_source_address_token ||
       signature.size() + compressed.size() < max_unverified_size) {
     out->SetStringPiece(kCertificateTag, compressed);
     out->SetStringPiece(kPROF, signature);
   }
 }
 
 scoped_refptr<QuicCryptoServerConfig::Config>
 QuicCryptoServerConfig::ParseConfigProtobuf(
@@ skipping 332 matching lines @@
 
 QuicCryptoServerConfig::Config::Config()
     : channel_id_enabled(false),
       is_primary(false),
       primary_time(QuicWallTime::Zero()),
       priority(0) {}
 
 QuicCryptoServerConfig::Config::~Config() { STLDeleteElements(&key_exchanges); }
 
 }  // namespace net