Remove HttpStreamFactory's NPN/SPDY globals, except for spdy_enabled.

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"
@@ skipping 62 matching lines @@
       testing_fixed_http_port(0),
       testing_fixed_https_port(0),
       force_spdy_single_domain(false),
       enable_spdy_compression(true),
       enable_spdy_ping_based_connection_checking(true),
       spdy_default_protocol(kProtoUnknown),
       spdy_stream_initial_recv_window_size(0),
       spdy_initial_max_concurrent_streams(0),
       spdy_max_concurrent_streams_limit(0),
       time_func(&base::TimeTicks::Now),
+      force_spdy_over_ssl(true),
+      force_spdy_always(false),
+      use_alternate_protocols(false),
       enable_quic(false),
       enable_quic_https(false),
       enable_quic_port_selection(true),
       enable_quic_pacing(false),
       enable_quic_time_based_loss_detection(false),
       enable_quic_persist_server_info(false),
       quic_clock(NULL),
       quic_random(NULL),
       quic_max_packet_length(kDefaultMaxPacketSize),
       enable_user_alternate_protocol_ports(false),
@@ skipping 46 matching lines @@
                          params.time_func,
                          params.trusted_spdy_proxy),
       http_stream_factory_(new HttpStreamFactoryImpl(this, false)),
       http_stream_factory_for_websocket_(
           new HttpStreamFactoryImpl(this, true)),
       params_(params) {
   DCHECK(proxy_service_);
   DCHECK(ssl_config_service_.get());
   CHECK(http_server_properties_);
 
+  for (int i = ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION;

[Ryan Hamilton, 2014/05/22 17:30:45]

nit: I think you'll need to use size_t here (or some unsigned type) or else you
get a compiler error on some platforms about the signed/unsigned comparison on
the next line.

[mmenke, 2014/05/22 20:12:16]

I'm pretty sure enums are signed on all platforms.  This was actually just
copied from the old code, without modification, so presumably it compiles
everywhere.

+       i <= ALTERNATE_PROTOCOL_MAXIMUM_VALID_VERSION; ++i) {
+    enabled_protocols_[i - ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION] = false;
+  }
+
+  // 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));
+    }
+
+    // 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;
+      }
+      enabled_protocols_[alternate - ALTERNATE_PROTOCOL_MINIMUM_VALID_VERSION] =
+          true;
+    }
+  }
+
   if (HpackHuffmanAggregator::UseAggregator()) {
     huffman_aggregator_.reset(new HpackHuffmanAggregator());
   }
 }
 
 HttpNetworkSession::~HttpNetworkSession() {
   STLDeleteElements(&response_drainers_);
   spdy_session_pool_.CloseAllSessions();
 }
 
@@ skipping 71 matching lines @@
   spdy_session_pool_.CloseCurrentSessions(ERR_ABORTED);
   quic_stream_factory_.CloseAllSessions(ERR_ABORTED);
 }
 
 void HttpNetworkSession::CloseIdleConnections() {
   normal_socket_pool_manager_->CloseIdleSockets();
   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 {
+  if (HttpStreamFactory::spdy_enabled()) {
+    *next_protos = next_protos_;
+  } else {
+    next_protos->clear();
+  }

[mmenke, 2014/05/22 14:51:12]

Note:  This is a behavior change:  It used to be when next_protos_ was NULL, we
did nothing.  This is not the same as spdy_enabled being false, and it doesn't
look to me like we ever set the SSL config's next protos, anyways.

[mmenke, 2014/05/22 14:51:12]

Another behavior change:  If spdy is disabled and then enabled, we effectively
restore next_protos.  I suspect this is the behavior we want, anyways, though it
presumably doesn't happen often.

[Ryan Hamilton, 2014/05/22 17:30:45]

Oh, I see. That explains why this method doesn't simply return next_protos_;

[mmenke, 2014/05/22 20:12:16]

Yea, I thought this option was cleaner than having all callsites check if it
were "NULL" or not.  If you prefer the old pattern, or have another suggestion,
I'm certainly open to changing things.

+}
+
+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