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

chrome/browser/io_thread.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 "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 749 matching lines @@
           command_line.GetSwitchValueASCII(switches::kTrustedSpdyProxy));
     }
     if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
       net::URLFetcher::SetIgnoreCertificateRequests(true);
 
     if (command_line.HasSwitch(switches::kUseSpdy)) {
       std::string spdy_mode =
           command_line.GetSwitchValueASCII(switches::kUseSpdy);
       EnableSpdy(spdy_mode);
     } else if (command_line.HasSwitch(switches::kEnableSpdy4)) {
-      net::HttpStreamFactory::EnableNpnSpdy4Http2();
+      globals_->next_protos = net::NextProtosSpdy4Http2();
+      globals_->use_alternate_protocols.set(true);
     } else if (command_line.HasSwitch(switches::kDisableSpdy31)) {
-      net::HttpStreamFactory::EnableNpnSpdy3();
+      globals_->next_protos = net::NextProtosSpdy3();
+      globals_->use_alternate_protocols.set(true);
     } else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
-      net::HttpStreamFactory::EnableNpnHttpOnly();
+      globals_->next_protos = net::NextProtosHttpOnly();
+      globals_->use_alternate_protocols.set(false);
     } else {
       if (spdy_trial_group == kSpdyFieldTrialDisabledGroupName &&
           !command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
-         net::HttpStreamFactory::set_spdy_enabled(false);
+        net::HttpStreamFactory::set_spdy_enabled(false);
       } else {
         // Use SPDY/3.1 by default.
-        net::HttpStreamFactory::EnableNpnSpdy31();
+        globals_->next_protos = net::NextProtosSpdy31();
+        globals_->use_alternate_protocols.set(true);
       }
     }
   }
 
   // TODO(rch): Make the client socket factory a per-network session
   // instance, constructed from a NetworkSession::Params, to allow us
   // to move this option to IOThread::Globals &
   // HttpNetworkSession::Params.
   if (command_line.HasSwitch(switches::kEnableTcpFastOpen))
     net::SetTCPFastOpenEnabled(true);
@@ skipping 22 matching lines @@
     base::SplitString(element, '=', &name_value);
     const std::string& option =
         name_value.size() > 0 ? name_value[0] : std::string();
     const std::string value =
         name_value.size() > 1 ? name_value[1] : std::string();
 
     if (option == kOff) {
       net::HttpStreamFactory::set_spdy_enabled(false);
     } else if (option == kDisableSSL) {
       globals_->spdy_default_protocol.set(net::kProtoSPDY3);
-      net::HttpStreamFactory::set_force_spdy_over_ssl(false);
-      net::HttpStreamFactory::set_force_spdy_always(true);
+      globals_->force_spdy_over_ssl.set(false);
+      globals_->force_spdy_always.set(true);
     } else if (option == kSSL) {
       globals_->spdy_default_protocol.set(net::kProtoSPDY3);
-      net::HttpStreamFactory::set_force_spdy_over_ssl(true);
-      net::HttpStreamFactory::set_force_spdy_always(true);
+      globals_->force_spdy_over_ssl.set(true);
+      globals_->force_spdy_always.set(true);
     } else if (option == kDisablePing) {
       globals_->enable_spdy_ping_based_connection_checking.set(false);
     } else if (option == kExclude) {
-      net::HttpStreamFactory::add_forced_spdy_exclusion(value);
+      globals_->forced_spdy_exclusions.insert(
+          net::HostPortPair::FromURL(GURL(value)));
     } else if (option == kDisableCompression) {
       globals_->enable_spdy_compression.set(false);
     } else if (option == kDisableAltProtocols) {
-      net::HttpStreamFactory::set_use_alternate_protocols(false);
+      globals_->use_alternate_protocols.set(false);
     } else if (option == kForceAltProtocols) {
       net::PortAlternateProtocolPair pair;
       pair.port = 443;
       pair.protocol = net::NPN_SPDY_3;
       net::HttpServerPropertiesImpl::ForceAlternateProtocol(pair);
     } else if (option == kSingleDomain) {
       DVLOG(1) << "FORCING SINGLE DOMAIN";
       globals_->force_spdy_single_domain.set(true);
     } else if (option == kInitialMaxConcurrentStreams) {
       int streams;
@@ skipping 89 matching lines @@
   globals_->initial_max_spdy_concurrent_streams.CopyToIfSet(
       &params->spdy_initial_max_concurrent_streams);
   globals_->force_spdy_single_domain.CopyToIfSet(
       &params->force_spdy_single_domain);
   globals_->enable_spdy_compression.CopyToIfSet(
       &params->enable_spdy_compression);
   globals_->enable_spdy_ping_based_connection_checking.CopyToIfSet(
       &params->enable_spdy_ping_based_connection_checking);
   globals_->spdy_default_protocol.CopyToIfSet(
       &params->spdy_default_protocol);
-  globals_->trusted_spdy_proxy.CopyToIfSet(
-      &params->trusted_spdy_proxy);
+  params->next_protos = globals_->next_protos;
+  globals_->trusted_spdy_proxy.CopyToIfSet(&params->trusted_spdy_proxy);
+  globals_->force_spdy_over_ssl.CopyToIfSet(&params->force_spdy_over_ssl);
+  globals_->force_spdy_always.CopyToIfSet(&params->force_spdy_always);
+  globals_->forced_spdy_exclusions = params->forced_spdy_exclusions;
+  globals_->use_alternate_protocols.CopyToIfSet(
+      &params->use_alternate_protocols);
+
   globals_->enable_quic.CopyToIfSet(&params->enable_quic);
   globals_->enable_quic_https.CopyToIfSet(&params->enable_quic_https);
   globals_->enable_quic_pacing.CopyToIfSet(
       &params->enable_quic_pacing);
   globals_->enable_quic_time_based_loss_detection.CopyToIfSet(
       &params->enable_quic_time_based_loss_detection);
   globals_->enable_quic_persist_server_info.CopyToIfSet(
       &params->enable_quic_persist_server_info);
   globals_->enable_quic_port_selection.CopyToIfSet(
       &params->enable_quic_port_selection);
@@ skipping 233 matching lines @@
   std::string version_flag =
       command_line.GetSwitchValueASCII(switches::kQuicVersion);
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == version_flag) {
       return version;
     }
   }
   return net::QUIC_VERSION_UNSUPPORTED;
 }