Introduce SystemNetworkContextManager.

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 247 matching lines @@
 SystemURLRequestContextGetter::SystemURLRequestContextGetter(
     IOThread* io_thread)
     : io_thread_(io_thread),
       network_task_runner_(
           BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)) {}
 
 SystemURLRequestContextGetter::~SystemURLRequestContextGetter() {}
 
 net::URLRequestContext* SystemURLRequestContextGetter::GetURLRequestContext() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(io_thread_->globals()->system_request_context.get());
+  DCHECK(io_thread_->globals()->system_request_context);
 
-  return io_thread_->globals()->system_request_context.get();
+  return io_thread_->globals()->system_request_context;
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 SystemURLRequestContextGetter::GetNetworkTaskRunner() const {
   return network_task_runner_;
 }
 
 IOThread::Globals::
 SystemRequestContextLeakChecker::SystemRequestContextLeakChecker(
     Globals* globals)
     : globals_(globals) {
   DCHECK(globals_);
 }
 
 IOThread::Globals::
 SystemRequestContextLeakChecker::~SystemRequestContextLeakChecker() {
-  if (globals_->system_request_context.get())
+  if (globals_->system_request_context)
     globals_->system_request_context->AssertNoURLRequests();
 }
 
-IOThread::Globals::Globals() : system_request_context_leak_checker(this),
-                               enable_brotli(false) {}
+IOThread::Globals::Globals()
+    : system_request_context(nullptr),
+      system_request_context_leak_checker(this),
+      enable_brotli(false) {}
 
 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,
     policy::PolicyService* policy_service,
     net_log::ChromeNetLog* net_log,
     extensions::EventRouterForwarder* extension_event_router_forwarder)
@@ skipping 89 matching lines @@
               ->GetPolicies(policy::PolicyNamespace(
                   policy::POLICY_DOMAIN_CHROME, std::string()))
               .GetValue(policy::key::kHttp09OnNonDefaultPortsEnabled);
   if (value)
     value->GetAsBoolean(&http_09_on_non_default_ports_enabled_);
 
   chrome_browser_net::SetGlobalSTHDistributor(
       std::unique_ptr<net::ct::STHDistributor>(new net::ct::STHDistributor()));
 
   BrowserThread::SetIOThreadDelegate(this);
+
+  SystemNetworkContextManager::SetUp(&network_context_request_,
+                                     &network_context_params_);
 }
 
 IOThread::~IOThread() {
   // This isn't needed for production code, but in tests, IOThread may
   // be multiply constructed.
   BrowserThread::SetIOThreadDelegate(nullptr);
 
   pref_proxy_config_tracker_->DetachFromPrefService();
   DCHECK(!globals_);
 
@@ skipping 364 matching lines @@
   return quick_check_enabled_.GetValue();
 }
 
 bool IOThread::PacHttpsUrlStrippingEnabled() const {
   return pac_https_url_stripping_enabled_.GetValue();
 }
 
 void IOThread::ConstructSystemRequestContext() {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
-  net::URLRequestContextBuilderMojo builder;
+  std::unique_ptr<net::URLRequestContextBuilderMojo> builder =
+      base::MakeUnique<net::URLRequestContextBuilderMojo>();
 
-  builder.set_network_quality_estimator(
+  builder->set_network_quality_estimator(
       globals_->network_quality_estimator.get());
-  builder.set_enable_brotli(globals_->enable_brotli);
-  builder.set_name("system");
+  builder->set_enable_brotli(globals_->enable_brotli);
+  builder->set_name("system");
 
-  builder.set_user_agent(GetUserAgent());
+  builder->set_user_agent(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 */);
-  builder.set_network_delegate(
+  builder->set_network_delegate(
       globals_->data_use_ascriber->CreateNetworkDelegate(
           std::move(chrome_network_delegate), GetMetricsDataUseForwarder()));
-  builder.set_net_log(net_log_);
+  builder->set_net_log(net_log_);
   std::unique_ptr<net::HostResolver> host_resolver(
       CreateGlobalHostResolver(net_log_));
 
-  builder.set_ssl_config_service(GetSSLConfigService());
-  builder.SetHttpAuthHandlerFactory(
+  builder->set_ssl_config_service(GetSSLConfigService());
+  builder->SetHttpAuthHandlerFactory(
       CreateDefaultAuthHandlerFactory(host_resolver.get()));
 
-  builder.set_host_resolver(std::move(host_resolver));
+  builder->set_host_resolver(std::move(host_resolver));
 
 #if defined(OS_CHROMEOS)
   // Creates a CertVerifyProc that doesn't allow any profile-provided certs.
-  builder.SetCertVerifier(base::MakeUnique<net::CachingCertVerifier>(
+  builder->SetCertVerifier(base::MakeUnique<net::CachingCertVerifier>(
       base::MakeUnique<net::MultiThreadedCertVerifier>(
           new chromeos::CertVerifyProcChromeOS())));
 #else
-  builder.SetCertVerifier(IgnoreErrorsCertVerifier::MaybeWrapCertVerifier(
+  builder->SetCertVerifier(IgnoreErrorsCertVerifier::MaybeWrapCertVerifier(
       command_line, net::CertVerifier::CreateDefault()));
   UMA_HISTOGRAM_BOOLEAN(
       "Net.Certificate.IgnoreCertificateErrorsSPKIListPresent",
       command_line.HasSwitch(switches::kIgnoreCertificateErrorsSPKIList));
 #endif
 
   std::unique_ptr<net::MultiLogCTVerifier> ct_verifier =
       base::MakeUnique<net::MultiLogCTVerifier>();
   // Add built-in logs
   ct_verifier->AddLogs(globals_->ct_logs);
 
   // Register the ct_tree_tracker_ as observer for verified SCTs.
   ct_verifier->SetObserver(ct_tree_tracker_.get());
 
-  builder.set_ct_verifier(std::move(ct_verifier));
+  builder->set_ct_verifier(std::move(ct_verifier));
 
   // TODO(eroman): Figure out why this doesn't work in single-process mode.
   // Should be possible now that a private isolate is used.
   // http://crbug.com/474654
   if (!command_line.HasSwitch(switches::kWinHttpProxyResolver)) {
     if (command_line.HasSwitch(switches::kSingleProcess)) {
       LOG(ERROR) << "Cannot use V8 Proxy resolver in single process mode.";
     } else {
-      builder.set_mojo_proxy_resolver_factory(
+      builder->set_mojo_proxy_resolver_factory(
           ChromeMojoProxyResolverFactory::GetInstance());
     }
   }
 
-  builder.set_pac_quick_check_enabled(WpadQuickCheckEnabled());
-  builder.set_pac_sanitize_url_policy(
+  builder->set_pac_quick_check_enabled(WpadQuickCheckEnabled());
+  builder->set_pac_sanitize_url_policy(
       PacHttpsUrlStrippingEnabled()
           ? net::ProxyService::SanitizeUrlPolicy::SAFE
           : net::ProxyService::SanitizeUrlPolicy::UNSAFE);
 #if defined(OS_CHROMEOS)
-  builder.set_dhcp_fetcher_factory(
+  builder->set_dhcp_fetcher_factory(
       base::MakeUnique<chromeos::DhcpProxyScriptFetcherFactoryChromeos>());
 #endif
-  builder.set_proxy_config_service(std::move(system_proxy_config_service_));
+  builder->set_proxy_config_service(std::move(system_proxy_config_service_));
 
-  builder.set_http_network_session_params(session_params_);
+  builder->set_http_network_session_params(session_params_);
 
-  builder.set_data_enabled(true);
-  builder.set_file_enabled(true);
+  builder->set_data_enabled(true);
+  builder->set_file_enabled(true);
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
-  builder.set_ftp_enabled(true);
+  builder->set_ftp_enabled(true);
 #endif
 
-  builder.DisableHttpCache();
+  builder->DisableHttpCache();
 
-  globals_->system_request_context = builder.Build();
+  globals_->network_service = content::NetworkService::Create();
+  globals_->system_network_context =
+      globals_->network_service->CreateNetworkContextWithBuilder(
+          std::move(network_context_request_),
+          std::move(network_context_params_), std::move(builder),
+          &globals_->system_request_context);
 
 #if defined(USE_NSS_CERTS)
-  net::SetURLRequestContextForNSSHttpIO(globals_->system_request_context.get());
+  net::SetURLRequestContextForNSSHttpIO(globals_->system_request_context);
 #endif
 #if defined(OS_ANDROID)
   net::CertVerifyProcAndroid::SetCertNetFetcher(
-      net::CreateCertNetFetcher(globals_->system_request_context.get()));
+      net::CreateCertNetFetcher(globals_->system_request_context));
 #endif
 }
 
 // static
 void IOThread::ConfigureParamsFromFieldTrialsAndCommandLine(
     const base::CommandLine& command_line,
     bool is_quic_allowed_by_policy,
     bool http_09_on_non_default_ports_enabled,
     net::HttpNetworkSession::Params* params) {
   std::string quic_user_agent_id = chrome::GetChannelString();
@@ skipping 10 matching lines @@
   if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
     net::URLFetcher::SetIgnoreCertificateRequests(true);
 
   params->http_09_on_non_default_ports_enabled =
       http_09_on_non_default_ports_enabled;
 }
 
 metrics::UpdateUsagePrefCallbackType IOThread::GetMetricsDataUseForwarder() {
   return base::Bind(&UpdateMetricsUsagePrefsOnUIThread);
 }