Split HttpNetworkSession::Params into two structs.

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 <utility>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 600 matching lines @@
 
   CreateDefaultAuthHandlerFactory();
   globals_->dns_probe_service.reset(new chrome_browser_net::DnsProbeService());
   globals_->host_mapping_rules.reset(new net::HostMappingRules());
   if (command_line.HasSwitch(switches::kHostRules)) {
     TRACE_EVENT_BEGIN0("startup", "IOThread::InitAsync:SetRulesFromString");
     globals_->host_mapping_rules->SetRulesFromString(
         command_line.GetSwitchValueASCII(switches::kHostRules));
     TRACE_EVENT_END0("startup", "IOThread::InitAsync:SetRulesFromString");
   }
-  params_.host_mapping_rules = *globals_->host_mapping_rules.get();
+
+  session_params_.host_mapping_rules = *globals_->host_mapping_rules.get();
   globals_->enable_brotli =
       base::FeatureList::IsEnabled(features::kBrotliEncoding);
-  params_.enable_token_binding =
+  session_params_.enable_token_binding =
       base::FeatureList::IsEnabled(features::kTokenBinding);
 
   // Check for OS support of TCP FastOpen, and turn it on for all connections if
   // indicated by user.
   // 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.
   bool always_enable_tfo_if_supported =
       command_line.HasSwitch(switches::kEnableTcpFastOpen);
   net::CheckSupportAndMaybeEnableTCPFastOpen(always_enable_tfo_if_supported);
 
   ConfigureParamsFromFieldTrialsAndCommandLine(
       command_line, is_quic_allowed_by_policy_,
-      http_09_on_non_default_ports_enabled_, &params_);
+      http_09_on_non_default_ports_enabled_, &session_params_);
 
 #if defined(OS_MACOSX)
   // Start observing Keychain events. This needs to be done on the UI thread,
   // as Keychain services requires a CFRunLoop.
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(&ObserveKeychainEvents));
 #endif
 
 #if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
@@ skipping 121 matching lines @@
 void IOThread::ClearHostCache(
     const base::Callback<bool(const std::string&)>& host_filter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
     host_cache->ClearForHosts(host_filter);
 }
 
 const net::HttpNetworkSession::Params& IOThread::NetworkSessionParams() const {
-  return params_;
+  return session_params_;
 }
 
 void IOThread::DisableQuic() {
-  params_.enable_quic = false;
+  session_params_.enable_quic = false;
 
   if (globals_->system_request_context_storage)
     globals_->system_request_context_storage->http_network_session()
         ->DisableQuic();
 }
 
 base::TimeTicks IOThread::creation_time() const {
   return creation_time_;
 }
 
@@ skipping 75 matching lines @@
 
   context_storage->set_transport_security_state(
       base::MakeUnique<net::TransportSecurityState>());
 
   context_storage->set_http_server_properties(
       base::MakeUnique<net::HttpServerPropertiesImpl>());
 
   context->set_cert_verifier(globals_->cert_verifier.get());
   context->set_cert_transparency_verifier(
       globals_->cert_transparency_verifier.get());
+
   context_storage->set_ct_policy_enforcer(
       base::MakeUnique<net::CTPolicyEnforcer>());
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   context_storage->set_proxy_service(ProxyServiceFactory::CreateProxyService(
       net_log_, context, context->network_delegate(),
       std::move(system_proxy_config_service_), command_line,
       WpadQuickCheckEnabled(), PacHttpsUrlStrippingEnabled()));
 
-  net::HttpNetworkSession::Params system_params(params_);
+  net::HttpNetworkSession::Context session_context;
   net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
-      context, &system_params);
+      context, &session_context);
 
   context_storage->set_http_network_session(
-      base::MakeUnique<net::HttpNetworkSession>(system_params));
+      base::MakeUnique<net::HttpNetworkSession>(session_params_,
+                                                session_context));
   context_storage->set_http_transaction_factory(
       base::MakeUnique<net::HttpNetworkLayer>(
           context_storage->http_network_session()));
 
   std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory(
       new net::URLRequestJobFactoryImpl());
 
   job_factory->SetProtocolHandler(url::kDataScheme,
                                   base::MakeUnique<net::DataProtocolHandler>());
   job_factory->SetProtocolHandler(
@@ skipping 101 matching lines @@
         GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpsPort);
   }
 
   params->http_09_on_non_default_ports_enabled =
       http_09_on_non_default_ports_enabled;
 }
 
 metrics::UpdateUsagePrefCallbackType IOThread::GetMetricsDataUseForwarder() {
   return base::Bind(&UpdateMetricsUsagePrefsOnUIThread);
 }