Update from https://crrev.com/308331

net/http/http_network_session.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/http/http_network_session.h"
 
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_response_body_drainer.h"
 #include "net/http/http_stream_factory_impl.h"
 #include "net/http/url_security_manager.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_crypto_client_stream_factory.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_stream_factory.h"
 #include "net/quic/quic_utils.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_pool_manager_impl.h"
 #include "net/socket/next_proto.h"
+#include "net/socket/ssl_client_socket.h"
 #include "net/spdy/hpack_huffman_aggregator.h"
 #include "net/spdy/spdy_session_pool.h"
 
 namespace {
 
 net::ClientSocketPoolManager* CreateSocketPoolManager(
     net::HttpNetworkSession::SocketPoolType pool_type,
     const net::HttpNetworkSession::Params& params) {
   // TODO(yutak): Differentiate WebSocket pool manager and allow more
   // simultaneous connections for WebSockets.
@@ skipping 120 matching lines @@
 
   // TODO(rtenneti): bug 116575 - consider combining the NextProto and
   // AlternateProtocol.
   for (std::vector<NextProto>::const_iterator it = params_.next_protos.begin();
        it != params_.next_protos.end(); ++it) {
     NextProto proto = *it;
 
     // Add the protocol to the TLS next protocol list, except for QUIC
     // since it uses UDP.
     if (proto != kProtoQUIC1SPDY3) {
-      next_protos_.push_back(SSLClientSocket::NextProtoToString(proto));
+      next_protos_.push_back(proto);
     }
 
     // Enable the corresponding alternate protocol, except for HTTP
     // which has not corresponding alternative.
     if (proto != kProtoHTTP11) {
       AlternateProtocol alternate = AlternateProtocolFromNextProto(proto);
       if (!IsAlternateProtocolValid(alternate)) {
         NOTREACHED() << "Invalid next proto: " << proto;
         continue;
       }
@@ skipping 97 matching lines @@
   websocket_socket_pool_manager_->CloseIdleSockets();
   spdy_session_pool_.CloseCurrentIdleSessions();
 }
 
 bool HttpNetworkSession::IsProtocolEnabled(AlternateProtocol protocol) const {
   DCHECK(IsAlternateProtocolValid(protocol));
   return enabled_protocols_[
       protocol - ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION];
 }
 
-void HttpNetworkSession::GetNextProtos(
-    std::vector<std::string>* next_protos) const {
+void HttpNetworkSession::GetNextProtos(NextProtoVector* next_protos) const {
   if (HttpStreamFactory::spdy_enabled()) {
     *next_protos = next_protos_;
   } else {
     next_protos->clear();
   }
 }
 
 bool HttpNetworkSession::HasSpdyExclusion(
     HostPortPair host_port_pair) const {
   return params_.forced_spdy_exclusions.find(host_port_pair) !=
       params_.forced_spdy_exclusions.end();
 }
 
 ClientSocketPoolManager* HttpNetworkSession::GetSocketPoolManager(
     SocketPoolType pool_type) {
   switch (pool_type) {
     case NORMAL_SOCKET_POOL:
       return normal_socket_pool_manager_.get();
     case WEBSOCKET_SOCKET_POOL:
       return websocket_socket_pool_manager_.get();
     default:
       NOTREACHED();
       break;
   }
   return NULL;
 }
 
 }  //  namespace net