Use URLRequestContextStorage for the SystemURLRequestContext.

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 90 matching lines @@
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/file_protocol_handler.h"
 #include "net/url_request/ftp_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "url/url_constants.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/event_router_forwarder.h"
 #endif
 
 #if defined(USE_NSS_CERTS)
 #include "net/cert_net/nss_ocsp.h"
 #endif
@@ skipping 68 matching lines @@
   SystemURLRequestContext() {
 #if defined(USE_NSS_CERTS)
     net::SetURLRequestContextForNSSHttpIO(this);
 #endif
 #if defined(OS_ANDROID)
     net::CertVerifyProcAndroid::SetCertNetFetcher(
         net::CreateCertNetFetcher(this));
 #endif
   }
 
- private:
   ~SystemURLRequestContext() override {
     AssertNoURLRequests();
 #if defined(USE_NSS_CERTS)
     net::SetURLRequestContextForNSSHttpIO(NULL);
 #endif
 
 #if defined(OS_ANDROID)
     net::CertVerifyProcAndroid::ShutdownCertNetFetcher();
 #endif
   }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SystemURLRequestContext);
 };
 
 std::unique_ptr<net::HostResolver> CreateGlobalHostResolver(
     net::NetLog* net_log) {
   TRACE_EVENT0("startup", "IOThread::CreateGlobalHostResolver");
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
   net::HostResolver::Options options;
 
@@ skipping 403 matching lines @@
   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());
   // For the ProxyScriptFetcher, we use a direct ProxyService.
   globals_->proxy_script_fetcher_proxy_service =
       net::ProxyService::CreateDirectWithNetLog(net_log_);
-  // In-memory cookie store.
-  globals_->system_cookie_store =
-      content::CreateCookieStore(content::CookieStoreConfig());
-  // In-memory channel ID store.
-  globals_->system_channel_id_service.reset(
-      new net::ChannelIDService(new net::DefaultChannelIDStore(NULL)));
-  globals_->system_cookie_store->SetChannelIDServiceID(
-      globals_->system_channel_id_service->GetUniqueID());
   globals_->dns_probe_service.reset(new chrome_browser_net::DnsProbeService());
   globals_->host_mapping_rules.reset(new net::HostMappingRules());
   params_.host_mapping_rules = globals_->host_mapping_rules.get();
   globals_->http_user_agent_settings.reset(
       new net::StaticHttpUserAgentSettings(std::string(), GetUserAgent()));
   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");
   }
   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.
   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_);
 
-  TRACE_EVENT_BEGIN0("startup",
-                     "IOThread::Init:ProxyScriptFetcherRequestContext");
-  globals_->proxy_script_fetcher_context.reset(
-      ConstructProxyScriptFetcherContext(globals_, params_, net_log_));
-  TRACE_EVENT_END0("startup",
-                   "IOThread::Init:ProxyScriptFetcherRequestContext");
-
 #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)
   // Record how common CPUs with broken NEON units are. See
   // https://crbug.com/341598.
   crypto::EnsureOpenSSLInit();
   UMA_HISTOGRAM_BOOLEAN("Net.HasBrokenNEON", CRYPTO_has_broken_NEON());
 #endif
 
-  globals_->system_proxy_service = ProxyServiceFactory::CreateProxyService(
-      net_log_, globals_->proxy_script_fetcher_context.get(),
-      globals_->system_network_delegate.get(),
-      std::move(system_proxy_config_service_), command_line,
-      WpadQuickCheckEnabled(), PacHttpsUrlStrippingEnabled());
-
-  globals_->system_request_context.reset(
-      ConstructSystemRequestContext(globals_, params_, net_log_));
+  ConstructSystemRequestContext();
 }
 
 void IOThread::CleanUp() {
   base::debug::LeakTracker<SafeBrowsingURLRequestContext>::CheckForLeaks();
 
 #if defined(USE_NSS_CERTS)
   net::ShutdownNSSHttpIO();
 #endif
 
   system_url_request_context_getter_ = NULL;
@@ skipping 103 matching lines @@
     host_cache->ClearForHosts(host_filter);
 }
 
 const net::HttpNetworkSession::Params& IOThread::NetworkSessionParams() const {
   return params_;
 }
 
 void IOThread::DisableQuic() {
   params_.enable_quic = false;
 
-  if (globals_->system_http_network_session)
-    globals_->system_http_network_session->DisableQuic();
+  if (globals_->system_request_context_storage)
+    globals_->system_request_context_storage->http_network_session()
+        ->DisableQuic();
 
   if (globals_->proxy_script_fetcher_http_network_session)
     globals_->proxy_script_fetcher_http_network_session->DisableQuic();
 }
 
 base::TimeTicks IOThread::creation_time() const {
   return creation_time_;
 }
 
 net::SSLConfigService* IOThread::GetSSLConfigService() {
@@ skipping 21 matching lines @@
 }
 
 bool IOThread::WpadQuickCheckEnabled() const {
   return quick_check_enabled_.GetValue();
 }
 
 bool IOThread::PacHttpsUrlStrippingEnabled() const {
   return pac_https_url_stripping_enabled_.GetValue();
 }
 
-// static
-net::URLRequestContext* IOThread::ConstructSystemRequestContext(
-    IOThread::Globals* globals,
-    const net::HttpNetworkSession::Params& params,
-    net::NetLog* net_log) {
-  net::URLRequestContext* context = new SystemURLRequestContext;
+void IOThread::ConstructSystemRequestContext() {
+  globals_->system_request_context =
+      base::MakeUnique<SystemURLRequestContext>();
+  net::URLRequestContext* context = globals_->system_request_context.get();
+  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);
+      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->set_net_log(net_log);
-  context->set_host_resolver(globals->host_resolver.get());
-  context->set_proxy_service(globals->system_proxy_service.get());
-  context->set_ssl_config_service(globals->ssl_config_service.get());
+      globals_->http_user_agent_settings.get());
+  context->set_network_delegate(globals_->system_network_delegate.get());
+  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->set_http_auth_handler_factory(
-      globals->http_auth_handler_factory.get());
+      globals_->http_auth_handler_factory.get());
 
-  context->set_cookie_store(globals->system_cookie_store.get());
-  context->set_channel_id_service(
-      globals->system_channel_id_service.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());
+      globals_->transport_security_state.get());
 
-  context->set_http_server_properties(globals->http_server_properties.get());
+  context->set_http_server_properties(globals_->http_server_properties.get());
 
-  context->set_cert_verifier(globals->cert_verifier.get());
+  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());
+      globals_->cert_transparency_verifier.get());
+  context->set_ct_policy_enforcer(globals_->ct_policy_enforcer.get());
 
-  net::HttpNetworkSession::Params system_params(params);
+  TRACE_EVENT_BEGIN0("startup",
+                     "IOThread::Init:ProxyScriptFetcherRequestContext");
+  globals_->proxy_script_fetcher_context.reset(
+      ConstructProxyScriptFetcherContext(globals_, params_, net_log_));
+  TRACE_EVENT_END0("startup",
+                   "IOThread::Init:ProxyScriptFetcherRequestContext");
+
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+  context_storage->set_proxy_service(ProxyServiceFactory::CreateProxyService(
+      net_log_, globals_->proxy_script_fetcher_context.get(),
+      globals_->system_network_delegate.get(),
+      std::move(system_proxy_config_service_), command_line,
+      WpadQuickCheckEnabled(), PacHttpsUrlStrippingEnabled()));

[mmenke, 2017/05/10 18:07:54]

Had to move proxy creation to just before it's used in the
SetHttpNetworkSessionComponents below, since it now relies on some parts of the
system URLRequestContext.  I'll switch this over to using the system request
context at some point.

[Randy Smith (Not in Mondays), 2017/05/10 21:54:48]

I'm missing the dependencies; can you spell them out?

(Not gonna block the CL on this because this a perfectly fine place for the
creation to happen--I just want to understand for future CLs.)

+
+  net::HttpNetworkSession::Params system_params(params_);
   net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
       context, &system_params);
 
-  globals->system_http_network_session.reset(
-      new net::HttpNetworkSession(system_params));
-  globals->system_http_transaction_factory.reset(
-      new net::HttpNetworkLayer(globals->system_http_network_session.get()));
+  context_storage->set_http_network_session(
+      base::MakeUnique<net::HttpNetworkSession>(system_params));
+  context_storage->set_http_transaction_factory(
+      base::MakeUnique<net::HttpNetworkLayer>(
+          context_storage->http_network_session()));
 
-  context->set_http_transaction_factory(
-      globals->system_http_transaction_factory.get());
-
-  globals->system_url_request_job_factory.reset(
-      new net::URLRequestJobFactoryImpl());
-  context->set_job_factory(globals->system_url_request_job_factory.get());
-
-  return context;
+  context_storage->set_job_factory(
+      base::MakeUnique<net::URLRequestJobFactoryImpl>());
 }
 
 // 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();
   if (!quic_user_agent_id.empty())
@@ skipping 98 matching lines @@
       globals->cert_transparency_verifier.get());
   context->set_ct_policy_enforcer(globals->ct_policy_enforcer.get());
   context->set_ssl_config_service(globals->ssl_config_service.get());
   context->set_http_auth_handler_factory(
       globals->http_auth_handler_factory.get());
   context->set_proxy_service(globals->proxy_script_fetcher_proxy_service.get());
 
   context->set_job_factory(
       globals->proxy_script_fetcher_url_request_job_factory.get());
 
-  context->set_cookie_store(globals->system_cookie_store.get());
+  context->set_cookie_store(globals->system_request_context->cookie_store());
   context->set_channel_id_service(
-      globals->system_channel_id_service.get());
+      globals->system_request_context->channel_id_service());
   context->set_network_delegate(globals->system_network_delegate.get());
   context->set_http_user_agent_settings(
       globals->http_user_agent_settings.get());
   context->set_http_server_properties(globals->http_server_properties.get());
 
   context->set_enable_brotli(globals->enable_brotli);
 
   net::HttpNetworkSession::Params session_params(params);
   net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
       context, &session_params);
@@ skipping 31 matching lines @@
 
   // TODO(rtenneti): We should probably use HttpServerPropertiesManager for the
   // system URLRequestContext too. There's no reason this should be tied to a
   // profile.
   return context;
 }
 
 metrics::UpdateUsagePrefCallbackType IOThread::GetMetricsDataUseForwarder() {
   return base::Bind(&UpdateMetricsUsagePrefsOnUIThread);
 }