Use URLRequestContextBuilderMojo to create 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 18 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/data_usage/tab_id_annotator.h"
 #include "chrome/browser/data_use_measurement/chrome_data_use_ascriber.h"
 #include "chrome/browser/net/async_dns_field_trial.h"
+#include "chrome/browser/net/chrome_mojo_proxy_resolver_factory.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/dns_probe_service.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/net/sth_distributor_provider.h"
 #include "chrome/browser/ssl/ignore_errors_cert_verifier.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/certificate_transparency/tree_state_tracker.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_prefs.h"
 #include "components/data_usage/core/data_use_aggregator.h"
 #include "components/data_usage/core/data_use_amortizer.h"
 #include "components/data_usage/core/data_use_annotator.h"
 #include "components/data_use_measurement/core/data_use_ascriber.h"
 #include "components/metrics/metrics_service.h"
 #include "components/net_log/chrome_net_log.h"
 #include "components/network_session_configurator/browser/network_session_configurator.h"
 #include "components/policy/core/common/policy_service.h"
 #include "components/policy/policy_constants.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/proxy_config/pref_proxy_config_tracker.h"
 #include "components/variations/variations_associated_data.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/cookie_store_factory.h"
 #include "content/public/browser/network_quality_observer_factory.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/user_agent.h"
 #include "extensions/features/features.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/logging_network_change_observer.h"
 #include "net/base/sdch_manager.h"
 #include "net/cert/caching_cert_verifier.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/ct_known_logs.h"
 #include "net/cert/ct_log_verifier.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/ct_verifier.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/cert/multi_threaded_cert_verifier.h"
 #include "net/cert/sth_distributor.h"
 #include "net/cert/sth_observer.h"
-#include "net/cookies/cookie_store.h"
 #include "net/dns/host_cache.h"
 #include "net/dns/host_resolver.h"
 #include "net/dns/mapped_host_resolver.h"
 #include "net/http/http_auth_filter.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_auth_preferences.h"
-#include "net/http/http_network_layer.h"
+#include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/net_features.h"
 #include "net/nqe/external_estimate_provider.h"
 #include "net/nqe/network_quality_estimator_params.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_script_fetcher_impl.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/chromium/quic_utils_chromium.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
-#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_builder_mojo.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
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "chrome/browser/android/data_usage/external_data_use_observer.h"
 #include "chrome/browser/android/net/external_estimate_provider_android.h"
 #include "components/data_usage/android/traffic_stats_amortizer.h"
 #include "net/cert/cert_net_fetcher.h"
 #include "net/cert/cert_verify_proc_android.h"
 #include "net/cert_net/cert_net_fetcher_impl.h"
 #endif  // defined(OS_ANDROID)
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/net/cert_verify_proc_chromeos.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
+#include "chromeos/network/dhcp_proxy_script_fetcher_factory_chromeos.h"
 #include "chromeos/network/host_resolver_impl_chromeos.h"
 #endif
 
 #if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
 #include "crypto/openssl_util.h"
 #include "third_party/boringssl/src/include/openssl/cpu.h"
 #endif
 
 using content::BrowserThread;
 
@@ skipping 607 matching lines @@
     host_cache->ClearForHosts(host_filter);
 }
 
 const net::HttpNetworkSession::Params& IOThread::NetworkSessionParams() const {
   return session_params_;
 }
 
 void IOThread::DisableQuic() {
   session_params_.enable_quic = false;
 
-  if (globals_->system_request_context_storage)
-    globals_->system_request_context_storage->http_network_session()
+  if (globals_->system_request_context)
+    globals_->system_request_context->http_transaction_factory()
+        ->GetSession()
         ->DisableQuic();
 }
 
 base::TimeTicks IOThread::creation_time() const {
   return creation_time_;
 }
 
 net::SSLConfigService* IOThread::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
@@ skipping 23 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;
 
-  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();
+  builder.set_network_quality_estimator(
+      globals_->network_quality_estimator.get());
+  builder.set_enable_brotli(globals_->enable_brotli);
+  builder.set_name("system");
 
-  context->set_network_quality_estimator(
-      globals_->network_quality_estimator.get());
-  context->set_enable_brotli(globals_->enable_brotli);
-  context->set_name("system");
-
-  context_storage->set_http_user_agent_settings(
-      base::MakeUnique<net::StaticHttpUserAgentSettings>(std::string(),
-                                                         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 */);
-  context_storage->set_network_delegate(
+  builder.set_network_delegate(
       globals_->data_use_ascriber->CreateNetworkDelegate(
           std::move(chrome_network_delegate), GetMetricsDataUseForwarder()));
-  context->set_net_log(net_log_);
-  context_storage->set_host_resolver(CreateGlobalHostResolver(net_log_));
+  builder.set_net_log(net_log_);
+  std::unique_ptr<net::HostResolver> host_resolver(
+      CreateGlobalHostResolver(net_log_));
 
-  context_storage->set_ssl_config_service(GetSSLConfigService());
-  context_storage->set_http_auth_handler_factory(
-      CreateDefaultAuthHandlerFactory(context->host_resolver()));
+  builder.set_ssl_config_service(GetSSLConfigService());
+  builder.SetHttpAuthHandlerFactory(
+      CreateDefaultAuthHandlerFactory(host_resolver.get()));

[Randy Smith (Not in Mondays), 2017/06/13 16:42:14]

nit, random thought, not necessary for this CL: Would it be reasonable for
URLRequestContextBuilder to have this behavior by default?

[mmenke, 2017/06/13 17:02:22]

This is an IOThread method, not a net one, and depends on a number of prefs. 
I'm not sure if we update the factory when they change - we may.  Regardless,
think this is complicated enough that it's premature to worry about it.

 
-  // 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_storage->set_transport_security_state(
-      base::MakeUnique<net::TransportSecurityState>());
-
-  context_storage->set_http_server_properties(
-      base::MakeUnique<net::HttpServerPropertiesImpl>());
+  builder.set_host_resolver(std::move(host_resolver));
 
 #if defined(OS_CHROMEOS)
   // Creates a CertVerifyProc that doesn't allow any profile-provided certs.
-  context_storage->set_cert_verifier(base::MakeUnique<net::CachingCertVerifier>(
+  builder.SetCertVerifier(base::MakeUnique<net::CachingCertVerifier>(
       base::MakeUnique<net::MultiThreadedCertVerifier>(
           new chromeos::CertVerifyProcChromeOS())));
 #else
-  context_storage->set_cert_verifier(
-      IgnoreErrorsCertVerifier::MaybeWrapCertVerifier(
-          command_line, net::CertVerifier::CreateDefault()));
+  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());
 
-  context_storage->set_cert_transparency_verifier(std::move(ct_verifier));
+  builder.set_ct_verifier(std::move(ct_verifier));
 
-  context_storage->set_ct_policy_enforcer(
-      base::MakeUnique<net::CTPolicyEnforcer>());
+  // 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

[Randy Smith (Not in Mondays), 2017/06/13 16:42:15]

Sorry, I poked around a bit but eventually decided I'd rather just ask: Where
does this code come from/map to in the current tree?

[mmenke, 2017/06/13 17:02:21]

There was a comment about that in the previous patch set, but then I merged for
the dependent patch set, making the comment harder to find.  :(

These two blocks are basically inlining ProxyServiceFactory::CreateProxyService
(Though the URLRequestContextBuilderMojo here is what actually creates the
service here, we just pass it the requisite parameters)

+  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(
+          ChromeMojoProxyResolverFactory::GetInstance());
+    }
+  }
 
-  context_storage->set_proxy_service(ProxyServiceFactory::CreateProxyService(
-      net_log_, context, context->network_delegate(),
-      std::move(system_proxy_config_service_), command_line,
-      WpadQuickCheckEnabled(), PacHttpsUrlStrippingEnabled()));
+  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(
+      base::MakeUnique<chromeos::DhcpProxyScriptFetcherFactoryChromeos>());
+#endif
+  builder.set_proxy_config_service(std::move(system_proxy_config_service_));
 
-  net::HttpNetworkSession::Context session_context;
-  net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
-      context, &session_context);
+  builder.set_http_network_session_params(session_params_);
 
-  context_storage->set_http_network_session(
-      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>());

[Randy Smith (Not in Mondays), 2017/06/13 16:42:15]

nit, not sure if it should be in this CL: The code that is now being executed
for this, in URLRequestContextBuilder, uses "data" rather than kDataScheme,
which seems a step backwards in terms of modularity.  Is there a way to fix
that?

(Also applies to file and ftp.)

[mmenke, 2017/06/13 17:02:21]

Sure, I'll update it in another CL.  net can certainly depend on URL.

-  job_factory->SetProtocolHandler(
-      url::kFileScheme,
-      base::MakeUnique<net::FileProtocolHandler>(
-          base::CreateTaskRunnerWithTraits(
-              {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
-               base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));

[Randy Smith (Not in Mondays), 2017/06/13 16:42:15]

So the conversion to using URLRequestContextBuilder is a step backwards in that
(URLRCB) uses base::Thread rather than CreateTaskRunnerWithTraits().  Reasonable
to convert that, either in this CL or a separate one?

[mmenke, 2017/06/13 17:02:22]

Good point, completely forgot about that.  I'll update builder in another CL
(Since that could break Cronet if task runners aren't fully set up there - I
suspect they are, but best to be careful).

[mmenke, 2017/06/13 17:34:41]

Actually, I'm going to set the task runner via the URLRequestContextBuilder API,
and do it in this CL.  Using a TaskRunnerWithTraits in the builder potentially
changes behavior in Cronet when shutting down a URLRequestContext.  Current code
blocks on shutting down the file thread, new code will not.  It may be what we
want there, but I'm not sure it is.

+  builder.set_data_enabled(true);
+  builder.set_file_enabled(true);
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
-  job_factory->SetProtocolHandler(
-      url::kFtpScheme,
-      net::FtpProtocolHandler::Create(context->host_resolver()));
+  builder.set_ftp_enabled(true);
 #endif
 
-  context_storage->set_job_factory(std::move(job_factory));
+  globals_->system_request_context = builder.Build();
 }
 
 // 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())
     quic_user_agent_id.push_back(' ');
   quic_user_agent_id.append(
       version_info::GetProductNameAndVersionForUserAgent());
   quic_user_agent_id.push_back(' ');
   quic_user_agent_id.append(content::BuildOSCpuInfo());
 
   network_session_configurator::ParseCommandLineAndFieldTrials(
       command_line, !is_quic_allowed_by_policy, quic_user_agent_id, params);
 
   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);
 }