Make ProfileIOData use URLRequestContextBuilder

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 769 matching lines @@
 }
 
 bool IOThread::WpadQuickCheckEnabled() const {
   return quick_check_enabled_.GetValue();
 }
 
 bool IOThread::PacHttpsUrlStrippingEnabled() const {
   return pac_https_url_stripping_enabled_.GetValue();
 }
 
-void IOThread::ConstructSystemRequestContext() {
+void IOThread::SetUpProxyConfigService(
+    net::URLRequestContextBuilderMojo* builder,
+    std::unique_ptr<net::ProxyConfigService> proxy_config_service) const {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
+
+  // 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.";

[Randy Smith (Not in Mondays), 2017/07/18 18:26:54]

So this looks to me like a potential change from the original.  IIUC,
ProxyServiceFactory::CreateProxyService(), in this fallback case, would log the
error as above, would skip the ChromeMojoProxyResolverFactory as below, but
would also skip the dhcp_fetcher_factory assignment on ChromeOS.  Is there some
reason why the kSingleProcess switch couldn't occur on ChromeOS?

(I realize that we don't support kSingleProcess, but I don't think we want to
break it for ChromeOS unless there's a specific reason?)

[mmenke, 2017/07/18 18:52:37]

You're right that this is a change in behavior (I can't remember if it was
intentional or not, though I think I did it because it seemed a bit tangential
to whether we were using the V8 resolver or not).  I'll go back the old
behavior, since it is rather unrelated.  I don't think that it really matters
much, either way, as the DhcpFetcher still works, we just can't run PAC scripts.

I bet we could use the V8 resolver in single process mode now if we really
wanted to - the tracing resolver probably makes this a non-issue.  But not worth
the effort of looking into.  :)

+    } else {
+      builder->set_mojo_proxy_resolver_factory(
+          ChromeMojoProxyResolverFactory::GetInstance());
+    }
+  }
+
+  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(proxy_config_service));
+}
+
+void IOThread::ConstructSystemRequestContext() {
   std::unique_ptr<net::URLRequestContextBuilderMojo> builder =
       base::MakeUnique<net::URLRequestContextBuilderMojo>();
 
   builder->set_network_quality_estimator(
       globals_->network_quality_estimator.get());
   builder->set_enable_brotli(globals_->enable_brotli);
   builder->set_name("system");
 
   builder->set_user_agent(GetUserAgent());
   std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate(
@@ skipping 18 matching lines @@
 
   std::unique_ptr<net::CertVerifier> cert_verifier;
 #if defined(OS_CHROMEOS)
   // Creates a CertVerifyProc that doesn't allow any profile-provided certs.
   cert_verifier = base::MakeUnique<net::CachingCertVerifier>(
       base::MakeUnique<net::MultiThreadedCertVerifier>(
           new chromeos::CertVerifyProcChromeOS()));
 #else
   cert_verifier = net::CertVerifier::CreateDefault();
 #endif
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
   builder->SetCertVerifier(
       content::IgnoreErrorsCertVerifier::MaybeWrapCertVerifier(
           command_line, switches::kUserDataDir, std::move(cert_verifier)));
   UMA_HISTOGRAM_BOOLEAN(
       "Net.Certificate.IgnoreCertificateErrorsSPKIListPresent",
       command_line.HasSwitch(switches::kIgnoreCertificateErrorsSPKIList));
 
   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));
 
-  // 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(
-          ChromeMojoProxyResolverFactory::GetInstance());
-    }
-  }
-
-  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_));
+  SetUpProxyConfigService(builder.get(),
+                          std::move(system_proxy_config_service_));
 
   builder->set_http_network_session_params(session_params_);
 
   builder->set_data_enabled(true);
   builder->set_file_enabled(true);
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
   builder->set_ftp_enabled(true);
 #endif
 
   builder->DisableHttpCache();
@@ skipping 34 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);
 }