IOThread: Move more stuff into system context's URLRequestContextStore.

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 535 matching lines @@
 #endif  // defined(OS_ANDROID)
 
   globals_->data_use_ascriber =
       base::MakeUnique<data_use_measurement::ChromeDataUseAscriber>();
 
   globals_->data_use_aggregator.reset(new data_usage::DataUseAggregator(
       std::unique_ptr<data_usage::DataUseAnnotator>(
           new chrome_browser_data_usage::TabIdAnnotator()),
       std::move(data_use_amortizer)));
 
-  std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate(
-      new ChromeNetworkDelegate(extension_event_router_forwarder(),
-                                &system_enable_referrers_));
-  // By default, data usage is considered off the record.
-  chrome_network_delegate->set_data_use_aggregator(
-      globals_->data_use_aggregator.get(),
-      true /* is_data_usage_off_the_record */);
-
 #if defined(OS_ANDROID)
   globals_->external_data_use_observer.reset(
       new chrome::android::ExternalDataUseObserver(
           globals_->data_use_aggregator.get(),
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
           BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)));
 #endif  // defined(OS_ANDROID)
 
-  globals_->system_network_delegate =
-      globals_->data_use_ascriber->CreateNetworkDelegate(
-          std::move(chrome_network_delegate), GetMetricsDataUseForwarder());
-
   globals_->host_resolver = CreateGlobalHostResolver(net_log_);
 
   std::map<std::string, std::string> network_quality_estimator_params;
   variations::GetVariationParams(kNetworkQualityEstimatorFieldTrialName,
                                  &network_quality_estimator_params);
 
   if (command_line.HasSwitch(switches::kForceEffectiveConnectionType)) {
     const std::string force_ect_value =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
             switches::kForceEffectiveConnectionType);
@@ skipping 25 matching lines @@
       base::MakeUnique<net::MultiThreadedCertVerifier>(
           new chromeos::CertVerifyProcChromeOS()));
 #else
   globals_->cert_verifier = IgnoreErrorsCertVerifier::MaybeWrapCertVerifier(
       command_line, net::CertVerifier::CreateDefault());
   UMA_HISTOGRAM_BOOLEAN(
       "Net.Certificate.IgnoreCertificateErrorsSPKIListPresent",
       command_line.HasSwitch(switches::kIgnoreCertificateErrorsSPKIList));
 #endif
 
-  globals_->transport_security_state.reset(new net::TransportSecurityState());
-
   std::vector<scoped_refptr<const net::CTLogVerifier>> ct_logs(
       net::ct::CreateLogVerifiersForKnownLogs());
 
   globals_->ct_logs.assign(ct_logs.begin(), ct_logs.end());
 
   net::MultiLogCTVerifier* ct_verifier = new net::MultiLogCTVerifier();
   globals_->cert_transparency_verifier.reset(ct_verifier);
   // Add built-in logs
   ct_verifier->AddLogs(globals_->ct_logs);
 
   ct_tree_tracker_.reset(new certificate_transparency::TreeStateTracker(
       globals_->ct_logs, net_log_));
   // Register the ct_tree_tracker_ as observer for new STHs.
   RegisterSTHObserver(ct_tree_tracker_.get());
   // Register the ct_tree_tracker_ as observer for verified SCTs.
   globals_->cert_transparency_verifier->SetObserver(ct_tree_tracker_.get());
 
-  globals_->ct_policy_enforcer.reset(new net::CTPolicyEnforcer());
-  params_.ct_policy_enforcer = globals_->ct_policy_enforcer.get();
-
-  globals_->ssl_config_service = GetSSLConfigService();
-
   CreateDefaultAuthHandlerFactory();
-  globals_->http_server_properties.reset(new net::HttpServerPropertiesImpl());
   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();
-  globals_->http_user_agent_settings.reset(
-      new net::StaticHttpUserAgentSettings(std::string(), GetUserAgent()));
   globals_->enable_brotli =
       base::FeatureList::IsEnabled(features::kBrotliEncoding);
   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.
@@ skipping 199 matching lines @@
   globals_->system_request_context_storage =
       base::MakeUnique<net::URLRequestContextStorage>(context);
   net::URLRequestContextStorage* context_storage =
       globals_->system_request_context_storage.get();
 
   context->set_network_quality_estimator(
       globals_->network_quality_estimator.get());
   context->set_enable_brotli(globals_->enable_brotli);
   context->set_name("system");
 
-  context->set_http_user_agent_settings(
-      globals_->http_user_agent_settings.get());
-  context->set_network_delegate(globals_->system_network_delegate.get());
+  context_storage->set_http_user_agent_settings(
+      base::MakeUnique<net::StaticHttpUserAgentSettings>(std::string(),
+                                                         GetUserAgent()));
+  std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate(
+      new ChromeNetworkDelegate(extension_event_router_forwarder(),
+                                &system_enable_referrers_));
+  // By default, data usage is considered off the record.
+  chrome_network_delegate->set_data_use_aggregator(
+      globals_->data_use_aggregator.get(),
+      true /* is_data_usage_off_the_record */);
+  context_storage->set_network_delegate(
+      globals_->data_use_ascriber->CreateNetworkDelegate(
+          std::move(chrome_network_delegate), GetMetricsDataUseForwarder()));
   context->set_net_log(net_log_);
   context->set_host_resolver(globals_->host_resolver.get());
 
-  context->set_ssl_config_service(globals_->ssl_config_service.get());
+  context_storage->set_ssl_config_service(GetSSLConfigService());
   context->set_http_auth_handler_factory(
       globals_->http_auth_handler_factory.get());
 
   // In-memory cookie store.
   context_storage->set_cookie_store(
       content::CreateCookieStore(content::CookieStoreConfig()));
   // In-memory channel ID store.
   context_storage->set_channel_id_service(
       base::MakeUnique<net::ChannelIDService>(
           new net::DefaultChannelIDStore(nullptr)));
   context->cookie_store()->SetChannelIDServiceID(
       context->channel_id_service()->GetUniqueID());
 
-  context->set_transport_security_state(
-      globals_->transport_security_state.get());
+  context_storage->set_transport_security_state(
+      base::MakeUnique<net::TransportSecurityState>());
 
-  context->set_http_server_properties(globals_->http_server_properties.get());
+  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->set_ct_policy_enforcer(globals_->ct_policy_enforcer.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, globals_->system_network_delegate.get(),
+      net_log_, context, context->network_delegate(),
       std::move(system_proxy_config_service_), command_line,
       WpadQuickCheckEnabled(), PacHttpsUrlStrippingEnabled()));
 
   net::HttpNetworkSession::Params system_params(params_);
   net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
       context, &system_params);
 
   context_storage->set_http_network_session(
       base::MakeUnique<net::HttpNetworkSession>(system_params));
   context_storage->set_http_transaction_factory(
@@ skipping 110 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);
 }