Move a number of static variables SPDY to HttpNetworkSession::Params.

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/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 35 matching lines @@
 #include "net/base/host_resolver.h"
 #include "net/base/mapped_host_resolver.h"
 #include "net/base/net_util.h"
 #include "net/base/sdch_manager.h"
 #include "net/base/server_bound_cert_service.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_network_layer.h"
-#include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/spdy/spdy_session.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_throttler_manager.h"
 #include "net/websockets/websocket_job.h"
 
 #if defined(ENABLE_CONFIGURATION_POLICY)
@@ skipping 148 matching lines @@
   context->set_cookie_store(globals->system_cookie_store.get());
   context->set_server_bound_cert_service(
       globals->system_server_bound_cert_service.get());
   context->set_throttler_manager(globals->throttler_manager.get());
   context->set_network_delegate(globals->system_network_delegate.get());
   context->set_http_user_agent_settings(
       globals->http_user_agent_settings.get());
   return context;
 }
 
-void InitializeNetworkSessionParams(
-    const IOThread::Globals& globals,
-    net::HttpNetworkSession::Params* params) {
-  params->host_resolver = globals.host_resolver.get();
-  params->cert_verifier = globals.cert_verifier.get();
-  params->server_bound_cert_service =
-      globals.system_server_bound_cert_service.get();
-  params->transport_security_state = globals.transport_security_state.get();
-  params->ssl_config_service = globals.ssl_config_service.get();
-  params->http_auth_handler_factory = globals.http_auth_handler_factory.get();
-  params->http_server_properties = globals.http_server_properties.get();
-  params->network_delegate = globals.system_network_delegate.get();
-  params->host_mapping_rules = globals.host_mapping_rules.get();
-  params->ignore_certificate_errors = globals.ignore_certificate_errors;
-  params->http_pipelining_enabled = globals.http_pipelining_enabled;
-  params->testing_fixed_http_port = globals.testing_fixed_http_port;
-  params->testing_fixed_https_port = globals.testing_fixed_https_port;
+int GetSwitchValueAsInt(const CommandLine& command_line,
+                        const std::string& switch_name) {
+  int value;
+  if (!base::StringToInt(command_line.GetSwitchValueASCII(switch_name),
+                         &value)) {
+    return 0;
+  }
+  return value;
 }
 
 }  // namespace
 
 class IOThread::LoggingNetworkChangeObserver
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public net::NetworkChangeNotifier::ConnectionTypeObserver {
  public:
   // |net_log| must remain valid throughout our lifetime.
   explicit LoggingNetworkChangeObserver(net::NetLog* net_log)
@@ skipping 239 matching lines @@
       new BasicHttpUserAgentSettings(EmptyString(), EmptyString()));
   if (command_line.HasSwitch(switches::kHostRules)) {
     globals_->host_mapping_rules->SetRulesFromString(
         command_line.GetSwitchValueASCII(switches::kHostRules));
   }
   if (command_line.HasSwitch(switches::kIgnoreCertificateErrors))
     globals_->ignore_certificate_errors = true;
   if (command_line.HasSwitch(switches::kEnableHttpPipelining))
     globals_->http_pipelining_enabled = true;
   if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
-    int value;
-    base::StringToInt(
-        command_line.GetSwitchValueASCII(
-            switches::kTestingFixedHttpPort),
-        &value);
-    globals_->testing_fixed_http_port = value;
+    globals_->testing_fixed_http_port =
+        GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpPort);
   }
   if (command_line.HasSwitch(switches::kTestingFixedHttpsPort)) {
-    int value;
-    base::StringToInt(
-        command_line.GetSwitchValueASCII(
-            switches::kTestingFixedHttpsPort),
-        &value);
-    globals_->testing_fixed_https_port = value;
+    globals_->testing_fixed_https_port =
+        GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpsPort);
   }
 
+  InitializeNetworkOptions(command_line);
+
   net::HttpNetworkSession::Params session_params;
-  InitializeNetworkSessionParams(*globals_, &session_params);
+  InitializeNetworkSessionParams(&session_params);
   session_params.net_log = net_log_;
   session_params.proxy_service =
       globals_->proxy_script_fetcher_proxy_service.get();
 
-  InitializeNetworkOptions(command_line);
-
   scoped_refptr<net::HttpNetworkSession> network_session(
       new net::HttpNetworkSession(session_params));
   globals_->proxy_script_fetcher_http_transaction_factory.reset(
       new net::HttpNetworkLayer(network_session));
   globals_->proxy_script_fetcher_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
 
   globals_->throttler_manager.reset(new net::URLRequestThrottlerManager());
   globals_->throttler_manager->set_net_log(net_log_);
   // Always done in production, disabled only for unit tests.
@@ skipping 52 matching lines @@
   network_change_observer_.reset();
 
   system_proxy_config_service_.reset();
 
   delete globals_;
   globals_ = NULL;
 
   base::debug::LeakTracker<SystemURLRequestContextGetter>::CheckForLeaks();
 }
 
-void IOThread::InitializeNetworkOptions(
-    const CommandLine& parsed_command_line) {
-  if (parsed_command_line.HasSwitch(switches::kEnableFileCookies)) {
+void IOThread::InitializeNetworkOptions(const CommandLine& command_line) {
+  if (command_line.HasSwitch(switches::kEnableFileCookies)) {
     // Enable cookie storage for file:// URLs.  Must do this before the first
     // Profile (and therefore the first CookieMonster) is created.
     net::CookieMonster::EnableFileScheme();
   }
 
   // If "spdy.disabled" preference is controlled via policy, then skip use-spdy
   // command line flags.
   if (is_spdy_disabled_by_policy_)
     return;
 
-  if (parsed_command_line.HasSwitch(switches::kEnableIPPooling))
-    net::SpdySessionPool::enable_ip_pooling(true);
+  if (command_line.HasSwitch(switches::kEnableIPPooling))
+    globals_->enable_spdy_ip_pooling.set(true);
 
-  if (parsed_command_line.HasSwitch(switches::kDisableIPPooling))
-    net::SpdySessionPool::enable_ip_pooling(false);
+  if (command_line.HasSwitch(switches::kDisableIPPooling))
+    globals_->enable_spdy_ip_pooling.set(false);
 
-  if (parsed_command_line.HasSwitch(switches::kEnableSpdyCredentialFrames))
-    net::SpdySession::set_enable_credential_frames(true);
-  if (parsed_command_line.HasSwitch(switches::kMaxSpdySessionsPerDomain)) {
-    int value;
-    base::StringToInt(
-        parsed_command_line.GetSwitchValueASCII(
-            switches::kMaxSpdySessionsPerDomain),
-        &value);
-    net::SpdySessionPool::set_max_sessions_per_domain(value);
-  }
+  if (command_line.HasSwitch(switches::kEnableSpdyCredentialFrames))
+    globals_->enable_spdy_credential_frames.set(true);
 
-  if (parsed_command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
+  if (command_line.HasSwitch(switches::kEnableWebSocketOverSpdy)) {
     // Enable WebSocket over SPDY.
     net::WebSocketJob::set_websocket_over_spdy_enabled(true);
   }
+  if (command_line.HasSwitch(switches::kMaxSpdySessionsPerDomain)) {
+    globals_->max_spdy_sessions_per_domain.set(
+        GetSwitchValueAsInt(command_line, switches::kMaxSpdySessionsPerDomain));
+  }
+  if (command_line.HasSwitch(switches::kMaxSpdyConcurrentStreams)) {
+    globals_->max_spdy_concurrent_streams_limit.set(
+        GetSwitchValueAsInt(command_line, switches::kMaxSpdyConcurrentStreams));
+  }
 
   bool used_spdy_switch = false;
-  if (parsed_command_line.HasSwitch(switches::kUseSpdy)) {
+  if (command_line.HasSwitch(switches::kUseSpdy)) {
     std::string spdy_mode =
-      parsed_command_line.GetSwitchValueASCII(switches::kUseSpdy);
+        command_line.GetSwitchValueASCII(switches::kUseSpdy);
     EnableSpdy(spdy_mode);
     used_spdy_switch = true;
   }
-  if (parsed_command_line.HasSwitch(switches::kEnableSpdy3)) {
+  if (command_line.HasSwitch(switches::kEnableSpdy3)) {
     net::HttpStreamFactory::EnableNpnSpdy3();
     used_spdy_switch = true;
-  } else if (parsed_command_line.HasSwitch(switches::kEnableNpn)) {
+  } else if (command_line.HasSwitch(switches::kEnableNpn)) {
     net::HttpStreamFactory::EnableNpnSpdy();
     used_spdy_switch = true;
-  } else if (parsed_command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
+  } else if (command_line.HasSwitch(switches::kEnableNpnHttpOnly)) {
     net::HttpStreamFactory::EnableNpnHttpOnly();
     used_spdy_switch = true;
   }
   if (!used_spdy_switch) {
     net::HttpStreamFactory::EnableNpnSpdy3();
   }
 }
 
 void IOThread::EnableSpdy(const std::string& mode) {
   static const char kOff[] = "off";
@@ skipping 15 matching lines @@
        it != spdy_options.end(); ++it) {
     const std::string& element = *it;
     std::vector<std::string> name_value;
     base::SplitString(element, '=', &name_value);
     const std::string& option = name_value.size() > 0 ? name_value[0] : "";
     const std::string value = name_value.size() > 1 ? name_value[1] : "";
 
     if (option == kOff) {
       net::HttpStreamFactory::set_spdy_enabled(false);
     } else if (option == kDisableSSL) {
-      net::SpdySession::set_default_protocol(net::kProtoSPDY2);
+      globals_->spdy_default_protocol.set(net::kProtoSPDY2);
       net::HttpStreamFactory::set_force_spdy_over_ssl(false);
       net::HttpStreamFactory::set_force_spdy_always(true);
     } else if (option == kSSL) {
-      net::SpdySession::set_default_protocol(net::kProtoSPDY2);
+      globals_->spdy_default_protocol.set(net::kProtoSPDY2);
       net::HttpStreamFactory::set_force_spdy_over_ssl(true);
       net::HttpStreamFactory::set_force_spdy_always(true);
     } else if (option == kDisablePing) {
-      net::SpdySession::set_enable_ping_based_connection_checking(false);
+      globals_->enable_spdy_ping_based_connection_checking.set(false);
     } else if (option == kExclude) {
       net::HttpStreamFactory::add_forced_spdy_exclusion(value);
     } else if (option == kDisableCompression) {
-      net::BufferedSpdyFramer::set_enable_compression_default(false);
+      globals_->enable_spdy_compression.set(false);
     } else if (option == kDisableAltProtocols) {
       net::HttpStreamFactory::set_use_alternate_protocols(false);
     } else if (option == kForceAltProtocols) {
       net::PortAlternateProtocolPair pair;
       pair.port = 443;
       pair.protocol = net::NPN_SPDY_2;
       net::HttpServerPropertiesImpl::ForceAlternateProtocol(pair);
     } else if (option == kSingleDomain) {
       DLOG(INFO) << "FORCING SINGLE DOMAIN";
-      net::SpdySessionPool::ForceSingleDomain();
+      globals_->force_spdy_single_domain.set(true);
     } else if (option == kInitialMaxConcurrentStreams) {
       int streams;
-      if (base::StringToInt(value, &streams) && streams > 0)
-        net::SpdySession::set_init_max_concurrent_streams(streams);
+      if (base::StringToInt(value, &streams))
+        globals_->initial_max_spdy_concurrent_streams.set(streams);
     } else if (option.empty() && it == spdy_options.begin()) {
       continue;
     } else {
       LOG(DFATAL) << "Unrecognized spdy option: " << option;
     }
   }
 }
 
 // static
 void IOThread::RegisterPrefs(PrefService* local_state) {
@@ skipping 56 matching lines @@
 }
 
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
     host_cache->clear();
 }
 
+void IOThread::InitializeNetworkSessionParams(
+    net::HttpNetworkSession::Params* params) {
+  params->host_resolver = globals_->host_resolver.get();
+  params->cert_verifier = globals_->cert_verifier.get();
+  params->server_bound_cert_service =
+      globals_->system_server_bound_cert_service.get();
+  params->transport_security_state = globals_->transport_security_state.get();
+  params->ssl_config_service = globals_->ssl_config_service.get();
+  params->http_auth_handler_factory = globals_->http_auth_handler_factory.get();
+  params->http_server_properties = globals_->http_server_properties.get();
+  params->network_delegate = globals_->system_network_delegate.get();
+  params->host_mapping_rules = globals_->host_mapping_rules.get();
+  params->ignore_certificate_errors = globals_->ignore_certificate_errors;
+  params->http_pipelining_enabled = globals_->http_pipelining_enabled;
+  params->testing_fixed_http_port = globals_->testing_fixed_http_port;
+  params->testing_fixed_https_port = globals_->testing_fixed_https_port;
+
+  globals_->max_spdy_sessions_per_domain.CopyToIfSet(
+      &params->max_spdy_sessions_per_domain);
+  globals_->initial_max_spdy_concurrent_streams.CopyToIfSet(
+      &params->spdy_initial_max_concurrent_streams);
+  globals_->max_spdy_concurrent_streams_limit.CopyToIfSet(
+      &params->spdy_max_concurrent_streams_limit);
+  globals_->force_spdy_single_domain.CopyToIfSet(
+      &params->force_spdy_single_domain);
+  globals_->enable_spdy_ip_pooling.CopyToIfSet(
+      &params->enable_spdy_ip_pooling);
+  globals_->enable_spdy_credential_frames.CopyToIfSet(
+      &params->enable_spdy_credential_frames);
+  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);
+}
+
 net::SSLConfigService* IOThread::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
 void IOThread::ChangedToOnTheRecordOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Clear the host cache to avoid showing entries from the OTR session
   // in about:net-internals.
   ClearHostCache();
@@ skipping 31 matching lines @@
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   globals_->system_proxy_service.reset(
       ProxyServiceFactory::CreateProxyService(
           net_log_,
           globals_->proxy_script_fetcher_context.get(),
           system_proxy_config_service_.release(),
           command_line));
 
   net::HttpNetworkSession::Params system_params;
-  InitializeNetworkSessionParams(*globals_, &system_params);
+  InitializeNetworkSessionParams(&system_params);
   system_params.net_log = net_log_;
   system_params.proxy_service = globals_->system_proxy_service.get();
 
   globals_->system_http_transaction_factory.reset(
       new net::HttpNetworkLayer(
           new net::HttpNetworkSession(system_params)));
   globals_->system_ftp_transaction_factory.reset(
       new net::FtpNetworkLayer(globals_->host_resolver.get()));
   globals_->system_request_context.reset(
       ConstructSystemRequestContext(globals_, net_log_));
 
   sdch_manager_->set_sdch_fetcher(
       new SdchDictionaryFetcher(system_url_request_context_getter_.get()));
 }
 
 void IOThread::UpdateDnsClientEnabled() {
   globals()->host_resolver->SetDnsClientEnabled(*dns_client_enabled_);
 }