Add a InitializeNetworkSessionParams method IOThread to remove duplicate code.

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 204 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;
+}
+
 }  // 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)
       : net_log_(net_log) {
     net::NetworkChangeNotifier::AddIPAddressObserver(this);
@@ skipping 254 matching lines @@
   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();
+  InitializeNetworkSessionParams(*globals_, &session_params);
+  session_params.net_log = net_log_;
   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.net_log = net_log_;
-  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_->testing_fixed_https_port;
 
   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()));
 
@@ skipping 293 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;
-  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();
+  InitializeNetworkSessionParams(*globals_, &system_params);
+  system_params.net_log = net_log_;
   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()));
 }
 
 void IOThread::UpdateDnsClientEnabled() {
   globals()->host_resolver->SetDnsClientEnabled(*dns_client_enabled_);
 }