Make ProfileIOData's ProxyService fetch PACs with the main URLRequestContext

chrome/browser/profiles/profile_io_data.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/profiles/profile_io_data.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 656 matching lines @@
     transport_security_state_->SetExpectCTReporter(nullptr);
   expect_ct_reporter_.reset();
 
   if (transport_security_state_)
     transport_security_state_->SetRequireCTDelegate(nullptr);
 
   // And the same for the ReportingService.
   main_request_context_storage()->set_reporting_service(
       std::unique_ptr<net::ReportingService>());
 
+  // This should be shut down last, as any other requests may initiate more
+  // activity when the ProxyService aborts lookups.
+  if (proxy_service_)
+    proxy_service_->OnShutdown();
+
   // TODO(ajwong): These AssertNoURLRequests() calls are unnecessary since they
   // are already done in the URLRequestContext destructor.
   if (main_request_context_)
     main_request_context_->AssertNoURLRequests();
   if (extensions_request_context_)
     extensions_request_context_->AssertNoURLRequests();
 
   current_context = 0;
   for (URLRequestContextMap::iterator it = app_request_context_map_.begin();
        it != app_request_context_map_.end(); ++it) {
@@ skipping 297 matching lines @@
   // Create the common request contexts.
   main_request_context_.reset(new net::URLRequestContext());
   main_request_context_storage_.reset(
       new net::URLRequestContextStorage(main_request_context_.get()));
   extensions_request_context_.reset(new net::URLRequestContext());
   main_request_context_->set_name("main");
   extensions_request_context_->set_name("extensions");
 
   main_request_context_->set_enable_brotli(io_thread_globals->enable_brotli);
 
-  std::unique_ptr<ChromeNetworkDelegate> network_delegate(
+  std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate(
       new ChromeNetworkDelegate(
 #if BUILDFLAG(ENABLE_EXTENSIONS)
           io_thread_globals->extension_event_router_forwarder.get(),
 #else
           NULL,
 #endif
           &enable_referrers_));
 #if BUILDFLAG(ENABLE_EXTENSIONS)
-  network_delegate->set_extension_info_map(
+  chrome_network_delegate->set_extension_info_map(
       profile_params_->extension_info_map.get());
   if (!command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling)) {
     extension_throttle_manager_.reset(
         new extensions::ExtensionThrottleManager());
   }
 #endif
 
-  network_delegate->set_url_blacklist_manager(url_blacklist_manager_.get());
-  network_delegate->set_profile(profile_params_->profile);
-  network_delegate->set_profile_path(profile_params_->path);
-  network_delegate->set_cookie_settings(profile_params_->cookie_settings.get());
-  network_delegate->set_enable_do_not_track(&enable_do_not_track_);
-  network_delegate->set_force_google_safe_search(&force_google_safesearch_);
-  network_delegate->set_force_youtube_restrict(&force_youtube_restrict_);
-  network_delegate->set_allowed_domains_for_apps(&allowed_domains_for_apps_);
-  network_delegate->set_data_use_aggregator(
+  chrome_network_delegate->set_url_blacklist_manager(
+      url_blacklist_manager_.get());
+  chrome_network_delegate->set_profile(profile_params_->profile);
+  chrome_network_delegate->set_profile_path(profile_params_->path);
+  chrome_network_delegate->set_cookie_settings(
+      profile_params_->cookie_settings.get());
+  chrome_network_delegate->set_enable_do_not_track(&enable_do_not_track_);
+  chrome_network_delegate->set_force_google_safe_search(
+      &force_google_safesearch_);
+  chrome_network_delegate->set_force_youtube_restrict(&force_youtube_restrict_);
+  chrome_network_delegate->set_allowed_domains_for_apps(
+      &allowed_domains_for_apps_);
+  chrome_network_delegate->set_data_use_aggregator(
       io_thread_globals->data_use_aggregator.get(), IsOffTheRecord());
 
+  std::unique_ptr<net::NetworkDelegate> network_delegate =
+      ConfigureNetworkDelegate(profile_params_->io_thread,
+                               std::move(chrome_network_delegate));
+
+  main_request_context_->set_host_resolver(
+      io_thread_globals->host_resolver.get());
+
   // NOTE: Proxy service uses the default io thread network delegate, not the
   // delegate just created.
   proxy_service_ = ProxyServiceFactory::CreateProxyService(
-      io_thread->net_log(),
-      io_thread_globals->proxy_script_fetcher_context.get(),
-      io_thread_globals->system_network_delegate.get(),
+      io_thread->net_log(), main_request_context_.get(), network_delegate.get(),
       std::move(profile_params_->proxy_config_service), command_line,
       io_thread->WpadQuickCheckEnabled(),
       io_thread->PacHttpsUrlStrippingEnabled());
+
+  main_request_context_storage_->set_network_delegate(
+      std::move(network_delegate));
+
   transport_security_state_.reset(new net::TransportSecurityState());
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   transport_security_persister_.reset(
       new net::TransportSecurityPersister(
           transport_security_state_.get(),
           profile_params_->path,
           pool->GetSequencedTaskRunnerWithShutdownBehavior(
               pool->GetSequenceToken(),
               base::SequencedWorkerPool::BLOCK_SHUTDOWN),
           IsOffTheRecord()));
@@ skipping 71 matching lines @@
   ct_tree_tracker_.reset(new certificate_transparency::TreeStateTracker(
       io_thread_globals->ct_logs, io_thread->net_log()));
   ct_verifier->SetObserver(ct_tree_tracker_.get());
 
   cert_transparency_verifier_ = std::move(ct_verifier);
   io_thread->RegisterSTHObserver(ct_tree_tracker_.get());
   ct_tree_tracker_unregistration_ =
       base::Bind(&IOThread::UnregisterSTHObserver, base::Unretained(io_thread),
                  ct_tree_tracker_.get());
 
-  InitializeInternal(std::move(network_delegate), profile_params_.get(),
-                     protocol_handlers, std::move(request_interceptors));
+  InitializeInternal(profile_params_.get(), protocol_handlers,
+                     std::move(request_interceptors));
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 void ProfileIOData::ApplyProfileParamsToContext(
     net::URLRequestContext* context) const {
   context->set_http_user_agent_settings(
       chrome_http_user_agent_settings_.get());
   context->set_ssl_config_service(profile_params_->ssl_config_service.get());
@@ skipping 169 matching lines @@
     net::HttpTransactionFactory* main_http_factory,
     std::unique_ptr<net::HttpCache::BackendFactory> backend) const {
   DCHECK(main_http_factory);
   net::HttpNetworkSession* shared_session = main_http_factory->GetSession();
   return base::MakeUnique<net::HttpCache>(
       base::WrapUnique(new DevToolsNetworkTransactionFactory(
           network_controller_handle_.GetController(), shared_session)),
       std::move(backend), false /* is_main_cache */);
 }
 
+std::unique_ptr<net::NetworkDelegate> ProfileIOData::ConfigureNetworkDelegate(
+    IOThread* io_thread,
+    std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate) const {
+  return base::WrapUnique<net::NetworkDelegate>(

[eroman, 2017/05/02 21:29:34]

does this work?

return std::move(chrome_network_delegate);

[mmenke, 2017/05/02 21:33:59]

Fails to build on Android only.  :(

+      chrome_network_delegate.release());
+}
+
 void ProfileIOData::SetCookieSettingsForTesting(
     content_settings::CookieSettings* cookie_settings) {
   DCHECK(!cookie_settings_.get());
   cookie_settings_ = cookie_settings;
 }
 
 policy::URLBlacklist::URLBlacklistState ProfileIOData::GetURLBlacklistState(
     const GURL& url) const {
   return url_blacklist_manager_->GetURLBlacklistState(url);
 }