Remove static variables from HttpStreamFactory.

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 21 matching lines @@
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_client.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/default_server_bound_cert_store.h"
 #include "net/base/host_cache.h"
+#include "net/base/host_mapping_rules.h"
 #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"
@@ skipping 263 matching lines @@
 }
 
 IOThread::Globals::
 SystemRequestContextLeakChecker::~SystemRequestContextLeakChecker() {
   if (globals_->system_request_context.get())
     globals_->system_request_context->AssertNoURLRequests();
 }
 
 IOThread::Globals::Globals()
     : ALLOW_THIS_IN_INITIALIZER_LIST(
-        system_request_context_leak_checker(this)) {}
+        system_request_context_leak_checker(this)),
+      ignore_certificate_errors(false),
+      http_pipelining_enabled(false),
+      testing_fixed_http_port(0),
+      testing_fixed_https_port(0) {}
+
 IOThread::Globals::~Globals() {}
 
 // |local_state| is passed in explicitly in order to (1) reduce implicit
 // dependencies and (2) make IOThread more flexible for testing.
 IOThread::IOThread(
     PrefService* local_state,
     ChromeNetLog* net_log,
     extensions::EventRouterForwarder* extension_event_router_forwarder)
     : net_log_(net_log),
       extension_event_router_forwarder_(extension_event_router_forwarder),
@@ skipping 58 matching lines @@
   return system_url_request_context_getter_;
 }
 
 void IOThread::Init() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
 #if defined(USE_NSS)
   net::SetMessageLoopForNSSHttpIO();
 #endif  // defined(USE_NSS)
 
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+
   DCHECK(!globals_);
   globals_ = new Globals;
 
   // Add an observer that will emit network change events to the ChromeNetLog.
   // Assuming NetworkChangeNotifier dispatches in FIFO order, we should be
   // logging the network change before other IO thread consumers respond to it.
   network_change_observer_.reset(
       new LoggingNetworkChangeObserver(net_log_));
 
   // Setup the HistogramWatcher to run on the IO thread.
   net::NetworkChangeNotifier::InitHistogramWatcher();
 
   globals_->extension_event_router_forwarder =
       extension_event_router_forwarder_;
   ChromeNetworkDelegate* network_delegate = new ChromeNetworkDelegate(
       extension_event_router_forwarder_,
       NULL,
       NULL,
       NULL,
       NULL,
       NULL,
       &system_enable_referrers_,
       NULL);
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableExtensionsHttpThrottling)) {
+  if (command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling))
     network_delegate->NeverThrottleRequests();
-  }
   globals_->system_network_delegate.reset(network_delegate);
   globals_->host_resolver.reset(
       CreateGlobalHostResolver(net_log_));
   globals_->cert_verifier.reset(net::CertVerifier::CreateDefault());
   globals_->transport_security_state.reset(new net::TransportSecurityState());
   globals_->ssl_config_service = GetSSLConfigService();
   globals_->http_auth_handler_factory.reset(CreateDefaultAuthHandlerFactory(
       globals_->host_resolver.get()));
   globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl);
   // For the ProxyScriptFetcher, we use a direct ProxyService.
   globals_->proxy_script_fetcher_proxy_service.reset(
       net::ProxyService::CreateDirectWithNetLog(net_log_));
   // In-memory cookie store.
   globals_->system_cookie_store = new net::CookieMonster(NULL, NULL);
   // In-memory server bound cert store.
   globals_->system_server_bound_cert_service.reset(
       new net::ServerBoundCertService(
           new net::DefaultServerBoundCertStore(NULL),
           base::WorkerPool::GetTaskRunner(true)));
   globals_->load_time_stats.reset(new chrome_browser_net::LoadTimeStats());
+  globals_->host_mapping_rules.reset(new net::HostMappingRules());
+  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;
+  }
+  if (command_line.HasSwitch(switches::kTestingFixedHttpsPort)) {
+    int value;
+    base::StringToInt(
+        command_line.GetSwitchValueASCII(
+            switches::kTestingFixedHttpsPort),
+        &value);
+    globals_->testing_fixed_https_port = value;
+  }
+
   net::HttpNetworkSession::Params session_params;
   session_params.host_resolver = globals_->host_resolver.get();
   session_params.cert_verifier = globals_->cert_verifier.get();
   session_params.server_bound_cert_service =
       globals_->system_server_bound_cert_service.get();
   session_params.transport_security_state =
       globals_->transport_security_state.get();
   session_params.proxy_service =
       globals_->proxy_script_fetcher_proxy_service.get();
+  session_params.ssl_config_service = globals_->ssl_config_service.get();
   session_params.http_auth_handler_factory =
       globals_->http_auth_handler_factory.get();
+  session_params.http_server_properties =
+      globals_->http_server_properties.get();
   session_params.network_delegate = globals_->system_network_delegate.get();
   // TODO(rtenneti): We should probably use HttpServerPropertiesManager for the
   // system URLRequestContext too. There's no reason this should be tied to a
   // profile.
-  session_params.http_server_properties =
-      globals_->http_server_properties.get();
   session_params.net_log = net_log_;
-  session_params.ssl_config_service = globals_->ssl_config_service;
+  session_params.host_mapping_rules = globals_->host_mapping_rules.get();
+  session_params.ignore_certificate_errors =
+      globals_->ignore_certificate_errors;
+  session_params.http_pipelining_enabled = globals_->http_pipelining_enabled;
+  session_params.testing_fixed_http_port = globals_->testing_fixed_http_port;
+  session_params.testing_fixed_https_port = globals_->http_pipelining_enabled;
+
   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 141 matching lines @@
   DCHECK(!globals_->system_proxy_service.get());
   DCHECK(system_proxy_config_service_.get());
 
   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;
   system_params.host_resolver = globals_->host_resolver.get();
   system_params.cert_verifier = globals_->cert_verifier.get();
   system_params.server_bound_cert_service =
       globals_->system_server_bound_cert_service.get();
   system_params.transport_security_state =
       globals_->transport_security_state.get();
   system_params.proxy_service = globals_->system_proxy_service.get();
   system_params.ssl_config_service = globals_->ssl_config_service.get();
   system_params.http_auth_handler_factory =
       globals_->http_auth_handler_factory.get();
   system_params.http_server_properties = globals_->http_server_properties.get();
   system_params.network_delegate = globals_->system_network_delegate.get();
   system_params.net_log = net_log_;
+  system_params.host_mapping_rules = globals_->host_mapping_rules.get();
+  system_params.ignore_certificate_errors = globals_->ignore_certificate_errors;
+  system_params.http_pipelining_enabled = globals_->http_pipelining_enabled;
+  system_params.testing_fixed_http_port = globals_->testing_fixed_http_port;
+  system_params.testing_fixed_https_port = globals_->testing_fixed_https_port;
+
   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()));
 }