Hook up ProfileIOData's URLRequestContext to a NetworkService.

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 21 matching lines @@
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry_factory.h"
 #include "chrome/browser/devtools/devtools_network_controller.h"
 #include "chrome/browser/devtools/devtools_network_transaction_factory.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/net/chrome_http_user_agent_settings.h"
 #include "chrome/browser/net/chrome_network_delegate.h"
 #include "chrome/browser/net/chrome_url_request_context_getter.h"
 #include "chrome/browser/net/loading_predictor_observer.h"
+#include "chrome/browser/net/profile_network_context_service.h"
+#include "chrome/browser/net/profile_network_context_service_factory.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/policy/cloud/policy_header_service_factory.h"
 #include "chrome/browser/policy/policy_helpers.h"
 #include "chrome/browser/predictors/loading_predictor.h"
 #include "chrome/browser/predictors/loading_predictor_factory.h"
 #include "chrome/browser/profiles/net_http_session_params_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ssl/chrome_expect_ct_reporter.h"
 #include "chrome/browser/ui/search/new_tab_page_interceptor_service.h"
@@ skipping 331 matching lines @@
 
 void ProfileIOData::InitializeOnUIThread(Profile* profile) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrefService* pref_service = profile->GetPrefs();
 
   std::unique_ptr<ProfileParams> params(new ProfileParams);
   params->path = profile->GetPath();
 
   params->io_thread = g_browser_process->io_thread();
 
+  ProfileNetworkContextServiceFactory::GetForContext(profile)
+      ->SetUpProfileIODataMainContext(&params->main_network_context_request,
+                                      &params->main_network_context_params);
+
   params->cookie_settings = CookieSettingsFactory::GetForProfile(profile);
   params->host_content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(profile);
   params->ssl_config_service = profile->GetSSLConfigService();
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   params->extension_info_map =
       extensions::ExtensionSystem::Get(profile)->info_map();
   params->cookie_monster_delegate = new ExtensionCookieMonsterDelegate(profile);
 #endif
@@ skipping 205 matching lines @@
       use_system_key_slot(false),
 #endif
       profile(NULL) {
 }
 
 ProfileIOData::ProfileParams::~ProfileParams() {}
 
 ProfileIOData::ProfileIOData(Profile::ProfileType profile_type)
     : initialized_(false),
 #if defined(OS_CHROMEOS)
-      policy_cert_verifier_(NULL),
+      policy_cert_verifier_(nullptr),
       use_system_key_slot_(false),
 #endif
+      main_request_context_(nullptr),
       resource_context_(new ResourceContext(this)),
       profile_type_(profile_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 ProfileIOData::~ProfileIOData() {
   if (BrowserThread::IsMessageLoopValid(BrowserThread::IO))
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Pull the contents of the request context maps onto the stack for sanity
@@ skipping 172 matching lines @@
     net::CertVerifier* cert_verifier) {
   g_cert_verifier_for_testing = cert_verifier;
 }
 
 content::ResourceContext* ProfileIOData::GetResourceContext() const {
   return resource_context_.get();
 }
 
 net::URLRequestContext* ProfileIOData::GetMainRequestContext() const {
   DCHECK(initialized_);
-  return main_request_context_.get();
+  return main_request_context_;
 }
 
 net::URLRequestContext* ProfileIOData::GetMediaRequestContext() const {
   DCHECK(initialized_);
   net::URLRequestContext* context = AcquireMediaRequestContext();
   DCHECK(context);
   return context;
 }
 
 net::URLRequestContext* ProfileIOData::GetExtensionsRequestContext() const {
@@ skipping 184 matching lines @@
   DCHECK(profile_params_.get());
 
   IOThread* const io_thread = profile_params_->io_thread;
   IOThread::Globals* const io_thread_globals = io_thread->globals();
 
   // Create extension request context.  Only used for cookies.
   extensions_request_context_.reset(new net::URLRequestContext());
   extensions_request_context_->set_name("extensions");
 
   // Create the main request context.
-  net::URLRequestContextBuilderMojo builder;
-  builder.set_name("main");
+  std::unique_ptr<net::URLRequestContextBuilderMojo> builder =
+      base::MakeUnique<net::URLRequestContextBuilderMojo>();
+  builder->set_name("main");
 
-  builder.set_net_log(io_thread->net_log());
-  builder.set_shared_http_user_agent_settings(
+  builder->set_net_log(io_thread->net_log());
+  builder->set_shared_http_user_agent_settings(
       chrome_http_user_agent_settings_.get());
-  builder.set_ssl_config_service(profile_params_->ssl_config_service);
+  builder->set_ssl_config_service(profile_params_->ssl_config_service);
 
-  builder.set_enable_brotli(io_thread_globals->enable_brotli);
+  builder->set_enable_brotli(io_thread_globals->enable_brotli);
 
   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)
@@ skipping 18 matching lines @@
   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));
 
-  builder.set_shared_host_resolver(
+  builder->set_shared_host_resolver(
       io_thread_globals->system_request_context->host_resolver());
 
-  builder.set_shared_http_auth_handler_factory(
+  builder->set_shared_http_auth_handler_factory(
       io_thread_globals->system_request_context->http_auth_handler_factory());
 
   io_thread->SetUpProxyConfigService(
-      &builder, std::move(profile_params_->proxy_config_service));
+      builder.get(), std::move(profile_params_->proxy_config_service));
 
-  builder.set_network_delegate(std::move(network_delegate));
+  builder->set_network_delegate(std::move(network_delegate));
 
-  builder.set_transport_security_persister_path(profile_params_->path);
-  builder.set_transport_security_persister_readonly(IsOffTheRecord());
+  builder->set_transport_security_persister_path(profile_params_->path);
+  builder->set_transport_security_persister_readonly(IsOffTheRecord());
 
   // Take ownership over these parameters.
   cookie_settings_ = profile_params_->cookie_settings;
   host_content_settings_map_ = profile_params_->host_content_settings_map;
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   extension_info_map_ = profile_params_->extension_info_map;
 #endif
 
   if (profile_params_->loading_predictor_observer_) {
     loading_predictor_observer_ =
         std::move(profile_params_->loading_predictor_observer_);
   }
 
 #if defined(OS_CHROMEOS)
   username_hash_ = profile_params_->username_hash;
   use_system_key_slot_ = profile_params_->use_system_key_slot;
   if (use_system_key_slot_)
     EnableNSSSystemKeySlotForResourceContext(resource_context_.get());
 
   certificate_provider_ = std::move(profile_params_->certificate_provider);
 #endif
 
   if (g_cert_verifier_for_testing) {
-    builder.set_shared_cert_verifier(g_cert_verifier_for_testing);
+    builder->set_shared_cert_verifier(g_cert_verifier_for_testing);
   } else {
 #if defined(OS_CHROMEOS)
     crypto::ScopedPK11Slot public_slot =
         crypto::GetPublicSlotForChromeOSUser(username_hash_);
     // The private slot won't be ready by this point. It shouldn't be necessary
     // for cert trust purposes anyway.
     scoped_refptr<net::CertVerifyProc> verify_proc(
         new chromeos::CertVerifyProcChromeOS(std::move(public_slot)));
     if (policy_cert_verifier_) {
       DCHECK_EQ(policy_cert_verifier_, cert_verifier_.get());
       policy_cert_verifier_->InitializeOnIOThread(verify_proc);
     } else {
       cert_verifier_ = base::MakeUnique<net::CachingCertVerifier>(
           base::MakeUnique<net::MultiThreadedCertVerifier>(verify_proc.get()));
     }
-    builder.set_shared_cert_verifier(cert_verifier_.get());
+    builder->set_shared_cert_verifier(cert_verifier_.get());
 #else
-    builder.set_shared_cert_verifier(
+    builder->set_shared_cert_verifier(
         io_thread_globals->system_request_context->cert_verifier());
 #endif
   }
 
   // Install the New Tab Page Interceptor.
   if (profile_params_->new_tab_page_interceptor.get()) {
     request_interceptors.push_back(
         std::move(profile_params_->new_tab_page_interceptor));
   }
 
   std::unique_ptr<net::MultiLogCTVerifier> ct_verifier(
       new net::MultiLogCTVerifier());
   ct_verifier->AddLogs(io_thread_globals->ct_logs);
 
   ct_tree_tracker_.reset(new certificate_transparency::TreeStateTracker(
       io_thread_globals->ct_logs, io_thread->net_log()));
   ct_verifier->SetObserver(ct_tree_tracker_.get());
 
-  builder.set_ct_verifier(std::move(ct_verifier));
+  builder->set_ct_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());
 
-  builder.set_http_network_session_params(
+  builder->set_http_network_session_params(
       profile_params_->io_thread->NetworkSessionParams());
   if (data_reduction_proxy_io_data_.get()) {
-    builder.set_shared_proxy_delegate(
+    builder->set_shared_proxy_delegate(
         data_reduction_proxy_io_data_->proxy_delegate());
   }
 
-  InitializeInternal(&builder, profile_params_.get(), protocol_handlers,
+  InitializeInternal(builder.get(), profile_params_.get(), protocol_handlers,
                      std::move(request_interceptors));
 
-  main_request_context_ = builder.Build();
+  main_network_context_ =
+      io_thread_globals->network_service->CreateNetworkContextWithBuilder(
+          std::move(profile_params_->main_network_context_request),
+          std::move(profile_params_->main_network_context_params),
+          std::move(builder), &main_request_context_);
 
   // Attach some things to the URLRequestContextBuilder's
   // TransportSecurityState.  Since no requests have been made yet, safe to do
   // this even after the call to Build().
 
   net::NetworkTrafficAnnotationTag traffic_annotation =
       net::DefineNetworkTrafficAnnotation("domain_security_policy", R"(
         semantics {
           sender: "Domain Security Policy"
           description:
@@ skipping 14 matching lines @@
           destination: OTHER
         }
         policy {
           cookies_allowed: false
           setting: "This feature cannot be disabled by settings."
           policy_exception_justification:
             "Not implemented, this is a feature that websites can opt into and "
             "thus there is no Chrome-wide policy to disable it."
         })");
   certificate_report_sender_.reset(
-      new net::ReportSender(main_request_context_.get(), traffic_annotation));
+      new net::ReportSender(main_request_context_, traffic_annotation));
   main_request_context_->transport_security_state()->SetReportSender(
       certificate_report_sender_.get());
 
-  expect_ct_reporter_.reset(
-      new ChromeExpectCTReporter(main_request_context_.get()));
+  expect_ct_reporter_.reset(new ChromeExpectCTReporter(main_request_context_));
   main_request_context_->transport_security_state()->SetExpectCTReporter(
       expect_ct_reporter_.get());
 
   main_request_context_->transport_security_state()->SetRequireCTDelegate(
       ct_policy_manager_->GetDelegate());
 
   resource_context_->host_resolver_ =
       io_thread_globals->system_request_context->host_resolver();
-  resource_context_->request_context_ = main_request_context_.get();
+  resource_context_->request_context_ = main_request_context_;
 
   OnMainRequestContextCreated(profile_params_.get());
 
   profile_params_.reset();
   initialized_ = true;
 }
 
 std::unique_ptr<net::URLRequestJobFactory>
 ProfileIOData::SetUpJobFactoryDefaults(
     std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory,
@@ skipping 208 matching lines @@
 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);
 }