Disable HTTP/2 over NPN (with OpenSSL).

net/socket/ssl_client_socket_openssl.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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <errno.h>
@@ skipping 908 matching lines @@
   // This will almost certainly result in the socket failing to complete the
   // handshake at which point the appropriate error is bubbled up to the client.
   LOG_IF(WARNING, rv != 1) << "SSL_set_cipher_list('" << command << "') "
                               "returned " << rv;
 
   // TLS channel ids.
   if (IsChannelIDEnabled(ssl_config_, channel_id_service_)) {
     SSL_enable_tls_channel_id(ssl_);
   }
 
-  if (!ssl_config_.next_protos.empty()) {
+  if (!ssl_config_.alpn_protos.empty()) {
     // Get list of ciphers that are enabled.
     STACK_OF(SSL_CIPHER)* enabled_ciphers = SSL_get_ciphers(ssl_);
     DCHECK(enabled_ciphers);
     std::vector<uint16> enabled_ciphers_vector;
     for (size_t i = 0; i < sk_SSL_CIPHER_num(enabled_ciphers); ++i) {
       const SSL_CIPHER* cipher = sk_SSL_CIPHER_value(enabled_ciphers, i);
       const uint16 id = static_cast<uint16>(SSL_CIPHER_get_id(cipher));
       enabled_ciphers_vector.push_back(id);
     }
 
-    NextProtoVector next_protos = ssl_config_.next_protos;
+    NextProtoVector alpn_protos = ssl_config_.alpn_protos;
     if (!HasCipherAdequateForHTTP2(enabled_ciphers_vector) ||
         !IsTLSVersionAdequateForHTTP2(ssl_config_)) {
-      DisableHTTP2(&next_protos);
+      DisableHTTP2(&alpn_protos);
     }
-    std::vector<uint8_t> wire_protos = SerializeNextProtos(next_protos);
+    std::vector<uint8_t> wire_protos = SerializeNextProtos(alpn_protos);
     SSL_set_alpn_protos(ssl_, wire_protos.empty() ? NULL : &wire_protos[0],
                         wire_protos.size());
   }
 
   if (ssl_config_.signed_cert_timestamps_enabled) {
     SSL_enable_signed_cert_timestamps(ssl_);
     SSL_enable_ocsp_stapling(ssl_);
   }
 
   if (cert_verifier_->SupportsOCSPStapling())
@@ skipping 929 matching lines @@
 }
 
 // SelectNextProtoCallback is called by OpenSSL during the handshake. If the
 // server supports NPN, selects a protocol from the list that the server
 // provides. According to third_party/openssl/openssl/ssl/ssl_lib.c, the
 // callback can assume that |in| is syntactically valid.
 int SSLClientSocketOpenSSL::SelectNextProtoCallback(unsigned char** out,
                                                     unsigned char* outlen,
                                                     const unsigned char* in,
                                                     unsigned int inlen) {
-  if (ssl_config_.next_protos.empty()) {
+  if (ssl_config_.npn_protos.empty()) {
     *out = reinterpret_cast<uint8*>(
         const_cast<char*>(kDefaultSupportedNPNProtocol));
     *outlen = arraysize(kDefaultSupportedNPNProtocol) - 1;
     npn_status_ = kNextProtoUnsupported;
     return SSL_TLSEXT_ERR_OK;
   }
 
   // Assume there's no overlap between our protocols and the server's list.
   npn_status_ = kNextProtoNoOverlap;
 
   // For each protocol in server preference order, see if we support it.
   for (unsigned int i = 0; i < inlen; i += in[i] + 1) {
-    for (NextProto next_proto : ssl_config_.next_protos) {
+    for (NextProto next_proto : ssl_config_.npn_protos) {
       const std::string proto = NextProtoToString(next_proto);
       if (in[i] == proto.size() &&
           memcmp(&in[i + 1], proto.data(), in[i]) == 0) {
         // We found a match.
         *out = const_cast<unsigned char*>(in) + i + 1;
         *outlen = in[i];
         npn_status_ = kNextProtoNegotiated;
         break;
       }
     }
     if (npn_status_ == kNextProtoNegotiated)
       break;
   }
 
   // If we didn't find a protocol, we select the last one from our list.
   if (npn_status_ == kNextProtoNoOverlap) {
     // NextProtoToString returns a pointer to a static string.
-    const char* proto = NextProtoToString(ssl_config_.next_protos.back());
+    const char* proto = NextProtoToString(ssl_config_.npn_protos.back());
     *out = reinterpret_cast<unsigned char*>(const_cast<char*>(proto));
     *outlen = strlen(proto);
   }
 
   npn_proto_.assign(reinterpret_cast<const char*>(*out), *outlen);
   DVLOG(2) << "next protocol: '" << npn_proto_ << "' status: " << npn_status_;
   set_negotiation_extension(kExtensionNPN);
   return SSL_TLSEXT_ERR_OK;
 }
 
@@ skipping 214 matching lines @@
     OnHandshakeIOComplete(signature_result_);
     return;
   }
 
   // During a renegotiation, either Read or Write calls may be blocked on an
   // asynchronous private key operation.
   PumpReadWriteEvents();
 }
 
 }  // namespace net