Deprecate FLAGS_quic_disable_pre_30. Remove QUIC versions [25-29].

net/quic/crypto/quic_crypto_client_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_client_config.h"
 
 #include <memory>
 
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 445 matching lines @@
   if (disable_ecdsa_) {
     out->SetVector(kPDMD, QuicTagVector{kX59R});
   } else {
     out->SetVector(kPDMD, QuicTagVector{kX509});
   }
 
   if (common_cert_sets) {
     out->SetStringPiece(kCCS, common_cert_sets->GetCommonHashes());
   }
 
-  if (preferred_version > QUIC_VERSION_29) {
-    out->SetStringPiece(kCertificateSCTTag, "");
-  }
+  out->SetStringPiece(kCertificateSCTTag, "");
 
   const vector<string>& certs = cached->certs();
   // We save |certs| in the QuicCryptoNegotiatedParameters so that, if the
   // client config is being used for multiple connections, another connection
   // doesn't update the cached certificates and cause us to be unable to
   // process the server's compressed certificate chain.
   out_params->cached_certs = certs;
   if (!certs.empty()) {
     vector<uint64_t> hashes;
     hashes.reserve(certs.size());
@@ skipping 30 matching lines @@
     return QUIC_CRYPTO_INTERNAL_ERROR;
   }
 
   StringPiece scid;
   if (!scfg->GetStringPiece(kSCID, &scid)) {
     *error_details = "SCFG missing SCID";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
   out->SetStringPiece(kSCID, scid);
 
-  if (preferred_version > QUIC_VERSION_29) {
-    out->SetStringPiece(kCertificateSCTTag, "");
-  }
+  out->SetStringPiece(kCertificateSCTTag, "");
 
   const QuicTag* their_aeads;
   const QuicTag* their_key_exchanges;
   size_t num_their_aeads, num_their_key_exchanges;
   if (scfg->GetTaglist(kAEAD, &their_aeads, &num_their_aeads) !=
           QUIC_NO_ERROR ||
       scfg->GetTaglist(kKEXS, &their_key_exchanges, &num_their_key_exchanges) !=
           QUIC_NO_ERROR) {
     *error_details = "Missing AEAD or KEXS";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
@@ skipping 74 matching lines @@
   }
 
   if (!out_params->client_key_exchange->CalculateSharedKey(
           public_value, &out_params->initial_premaster_secret)) {
     *error_details = "Key exchange failure";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
   out->SetStringPiece(kPUBS, out_params->client_key_exchange->public_value());
 
   const vector<string>& certs = cached->certs();
-  if (preferred_version > QUIC_VERSION_25) {
-    if (certs.empty()) {
-      *error_details = "No certs to calculate XLCT";
-      return QUIC_CRYPTO_INTERNAL_ERROR;
-    }
-    out->SetValue(kXLCT, CryptoUtils::ComputeLeafCertHash(certs[0]));
+  if (certs.empty()) {
+    *error_details = "No certs to calculate XLCT";
+    return QUIC_CRYPTO_INTERNAL_ERROR;
   }
+  out->SetValue(kXLCT, CryptoUtils::ComputeLeafCertHash(certs[0]));
 
   if (channel_id_key) {
     // In order to calculate the encryption key for the CETV block we need to
     // serialise the client hello as it currently is (i.e. without the CETV
     // block). For this, the client hello is serialized without padding.
     const size_t orig_min_size = out->minimum_size();
     out->set_minimum_size(0);
 
     CryptoHandshakeMessage cetv;
     cetv.set_tag(kCETV);
@@ skipping 51 matching lines @@
   // Set the following members of out_params:
   //   out_params->hkdf_input_suffix
   //   out_params->initial_crypters
   out_params->hkdf_input_suffix.clear();
   out_params->hkdf_input_suffix.append(reinterpret_cast<char*>(&connection_id),
                                        sizeof(connection_id));
   const QuicData& client_hello_serialized = out->GetSerialized();
   out_params->hkdf_input_suffix.append(client_hello_serialized.data(),
                                        client_hello_serialized.length());
   out_params->hkdf_input_suffix.append(cached->server_config());
-  if (preferred_version > QUIC_VERSION_25) {
-    if (certs.empty()) {
-      *error_details = "No certs found to include in KDF";
-      return QUIC_CRYPTO_INTERNAL_ERROR;
-    }
-    out_params->hkdf_input_suffix.append(certs[0]);
+  if (certs.empty()) {
+    *error_details = "No certs found to include in KDF";
+    return QUIC_CRYPTO_INTERNAL_ERROR;
   }
+  out_params->hkdf_input_suffix.append(certs[0]);
 
   string hkdf_input;
   const size_t label_len = strlen(QuicCryptoConfig::kInitialLabel) + 1;
   hkdf_input.reserve(label_len + out_params->hkdf_input_suffix.size());
   hkdf_input.append(QuicCryptoConfig::kInitialLabel, label_len);
   hkdf_input.append(out_params->hkdf_input_suffix);
 
   string* subkey_secret = &out_params->initial_subkey_secret;
 
   // Only perform key diversification for QUIC versions 33 and later.
@@ skipping 50 matching lines @@
   bool has_proof = message.GetStringPiece(kPROF, &proof);
   bool has_cert = message.GetStringPiece(kCertificateTag, &cert_bytes);
   if (has_proof && has_cert) {
     vector<string> certs;
     if (!CertCompressor::DecompressChain(cert_bytes, cached_certs,
                                          common_cert_sets, &certs)) {
       *error_details = "Certificate data invalid";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
 
-    if (version > QUIC_VERSION_29) {
-      message.GetStringPiece(kCertificateSCTTag, &cert_sct);
-    }
+    message.GetStringPiece(kCertificateSCTTag, &cert_sct);
     cached->SetProof(certs, cert_sct, chlo_hash, proof);
   } else {
     // Secure QUIC: clear existing proof as we have been sent a new SCFG
     // without matching proof/certs.
     cached->ClearProof();
 
     if (has_proof && !has_cert) {
       *error_details = "Certificate missing";
       return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
     }
@@ skipping 66 matching lines @@
     return valid;
   }
 
   // Learn about updated source address tokens.
   StringPiece token;
   if (server_hello.GetStringPiece(kSourceAddressTokenTag, &token)) {
     cached->set_source_address_token(token);
   }
 
   StringPiece shlo_nonce;
-  if (version > QUIC_VERSION_26 &&
-      !server_hello.GetStringPiece(kServerNonceTag, &shlo_nonce)) {
+  if (!server_hello.GetStringPiece(kServerNonceTag, &shlo_nonce)) {
     *error_details = "server hello missing server nonce";
     return QUIC_INVALID_CRYPTO_MESSAGE_PARAMETER;
   }
 
   // TODO(agl):
   //   learn about updated SCFGs.
 
   StringPiece public_value;
   if (!server_hello.GetStringPiece(kPUBS, &public_value)) {
     *error_details = "server hello missing forward secure public value";
@@ skipping 121 matching lines @@
   }
 
   // Update canonical version to point at the "most recent" entry.
   canonical_server_map_[suffix_server_id] = server_id;
 
   server_state->InitializeFrom(*canonical_state);
   return true;
 }
 
 }  // namespace net