Revert https://codereview.chromium.org/2860033003

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 92 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 69 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 172 matching lines @@
   gssapi_library_name_ = local_state->GetString(prefs::kGSSAPILibraryName);
 #endif
 #if defined(OS_CHROMEOS)
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   allow_gssapi_library_load_ = connector->IsActiveDirectoryManaged();
 #endif
   pref_proxy_config_tracker_.reset(
       ProxyServiceFactory::CreatePrefProxyConfigTrackerOfLocalState(
           local_state));
-  system_proxy_config_service_ = ProxyServiceFactory::CreateProxyConfigService(
-      pref_proxy_config_tracker_.get());
   ChromeNetworkDelegate::InitializePrefsOnUIThread(
       &system_enable_referrers_,
       nullptr,
       nullptr,
       nullptr,
       nullptr,
       local_state);
   ssl_config_service_manager_.reset(
       ssl_config::SSLConfigServiceManager::CreateDefaultManager(
           local_state,
@@ skipping 71 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::BindOnce(&IOThread::ChangedToOnTheRecordOnIOThread,
                      base::Unretained(this)));
 }
 
 net::URLRequestContextGetter* IOThread::system_url_request_context_getter() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!system_url_request_context_getter_.get()) {
-    system_url_request_context_getter_ =
-        new SystemURLRequestContextGetter(this);
+    InitSystemRequestContext();
   }
   return system_url_request_context_getter_.get();
 }
 
 void IOThread::Init() {
   TRACE_EVENT0("startup", "IOThread::InitAsync");
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
 #if defined(USE_NSS_CERTS)
   net::SetMessageLoopForNSSHttpIO();
@@ skipping 127 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
 
+  // InitSystemRequestContext turns right around and posts a task back
+  // to the IO thread, so we can't let it run until we know the IO
+  // thread has started.
+  //
+  // Note that since we are at BrowserThread::Init time, the UI thread
+  // is blocked waiting for the thread to start.  Therefore, posting
+  // this task to the main thread's message loop here is guaranteed to
+  // get it onto the message loop while the IOThread object still
+  // exists.  However, the message might not be processed on the UI
+  // thread until after IOThread is gone, so use a weak pointer.
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          base::BindOnce(&IOThread::InitSystemRequestContext,
+                                         weak_factory_.GetWeakPtr()));
+
 #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
-
-  ConstructSystemRequestContext();
 }
 
 void IOThread::CleanUp() {
   base::debug::LeakTracker<SafeBrowsingURLRequestContext>::CheckForLeaks();
 
 #if defined(USE_NSS_CERTS)
   net::ShutdownNSSHttpIO();
 #endif
 
+#if defined(OS_ANDROID)
+  net::CertVerifyProcAndroid::ShutdownCertNetFetcher();
+#endif
+
   system_url_request_context_getter_ = NULL;
 
   // Unlink the ct_tree_tracker_ from the global cert_transparency_verifier
   // and unregister it from new STH notifications so it will take no actions
   // on anything observed during CleanUp process.
-  //
-  // Null checks are just for tests that use TestingIOThreadState.
-  if (globals()->cert_transparency_verifier)
-    globals()->cert_transparency_verifier->SetObserver(nullptr);
-  if (ct_tree_tracker_.get()) {
-    UnregisterSTHObserver(ct_tree_tracker_.get());
-    ct_tree_tracker_.reset();
-  }
+  globals()->cert_transparency_verifier->SetObserver(nullptr);
+  UnregisterSTHObserver(ct_tree_tracker_.get());
+
+  ct_tree_tracker_.reset();
 
   // Release objects that the net::URLRequestContext could have been pointing
   // to.
 
   // Shutdown the HistogramWatcher on the IO thread.
   net::NetworkChangeNotifier::ShutdownHistogramWatcher();
 
   // This must be reset before the ChromeNetLog is destroyed.
   network_change_observer_.reset();
 
@@ skipping 85 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_request_context_storage)
-    globals_->system_request_context_storage->http_network_session()
-        ->DisableQuic();
+  if (globals_->system_http_network_session)
+    globals_->system_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() {
   return ssl_config_service_manager_->Get();
 }
 
 void IOThread::ChangedToOnTheRecordOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Clear the host cache to avoid showing entries from the OTR session
   // in about:net-internals.
   ClearHostCache(base::Callback<bool(const std::string&)>());
 }
 
+void IOThread::InitSystemRequestContext() {
+  if (system_url_request_context_getter_.get())
+    return;
+  // If we're in unit_tests, IOThread may not be run.
+  if (!BrowserThread::IsMessageLoopValid(BrowserThread::IO))
+    return;
+  system_proxy_config_service_ = ProxyServiceFactory::CreateProxyConfigService(
+      pref_proxy_config_tracker_.get());
+  system_url_request_context_getter_ =
+      new SystemURLRequestContextGetter(this);
+  // Safe to post an unretained this pointer, since IOThread is
+  // guaranteed to outlive the IO BrowserThread.
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::BindOnce(&IOThread::InitSystemRequestContextOnIOThread,
+                     base::Unretained(this)));
+}
+
+void IOThread::InitSystemRequestContextOnIOThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(!globals_->system_proxy_service.get());
+  DCHECK(system_proxy_config_service_.get());
+
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+  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_));
+}
+
 void IOThread::UpdateDnsClientEnabled() {
   globals()->host_resolver->SetDnsClientEnabled(*dns_client_enabled_);
 }
 
 void IOThread::RegisterSTHObserver(net::ct::STHObserver* observer) {
   chrome_browser_net::GetGlobalSTHDistributor()->RegisterObserver(observer);
 }
 
 void IOThread::UnregisterSTHObserver(net::ct::STHObserver* observer) {
   chrome_browser_net::GetGlobalSTHDistributor()->UnregisterObserver(observer);
 }
 
 bool IOThread::WpadQuickCheckEnabled() const {
   return quick_check_enabled_.GetValue();
 }
 
 bool IOThread::PacHttpsUrlStrippingEnabled() const {
   return pac_https_url_stripping_enabled_.GetValue();
 }
 
-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();
+// static
+net::URLRequestContext* IOThread::ConstructSystemRequestContext(
+    IOThread::Globals* globals,
+    const net::HttpNetworkSession::Params& params,
+    net::NetLog* net_log) {
+  net::URLRequestContext* context = new SystemURLRequestContext;
 
   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());
+      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());
+  context->set_http_auth_handler_factory(
+      globals->http_auth_handler_factory.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_cookie_store(globals->system_cookie_store.get());
+  context->set_channel_id_service(
+      globals->system_channel_id_service.get());
+  context->set_transport_security_state(
+      globals->transport_security_state.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_http_server_properties(globals->http_server_properties.get());
 
-  context->set_transport_security_state(
-      globals_->transport_security_state.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());
 
-  context->set_http_server_properties(globals_->http_server_properties.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());
-
-  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()));
-
-  net::HttpNetworkSession::Params system_params(params_);
+  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(
-      base::MakeUnique<net::HttpNetworkLayer>(
-          context_storage->http_network_session()));
+  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_job_factory(
-      base::MakeUnique<net::URLRequestJobFactoryImpl>());
+  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;
 }
 
 // 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_request_context->cookie_store());
+  context->set_cookie_store(globals->system_cookie_store.get());
   context->set_channel_id_service(
-      globals->system_request_context->channel_id_service());
+      globals->system_channel_id_service.get());
   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);
 }