Make ProfileIOData use URLRequestContextBuilder

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 88 matching lines @@
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/client_cert_store.h"
 #include "net/traffic_annotation/network_traffic_annotation.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/report_sender.h"
 #include "net/url_request/url_request.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_storage.h"
 #include "net/url_request/url_request_file_job.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "third_party/WebKit/public/public_features.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/extension_cookie_monster_delegate.h"
 #include "extensions/browser/extension_protocols.h"
@@ skipping 243 matching lines @@
 // For safe shutdown, must be called before the ProfileIOData is destroyed.
 void NotifyContextGettersOfShutdownOnIO(
     std::unique_ptr<ProfileIOData::ChromeURLRequestContextGetterVector>
         getters) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ProfileIOData::ChromeURLRequestContextGetterVector::iterator iter;
   for (auto& chrome_context_getter : *getters)
     chrome_context_getter->NotifyContextShuttingDown();
 }
 
+// Wraps |inner_job_factory| with |protocol_handler_interceptor|.
+std::unique_ptr<net::URLRequestJobFactory> CreateURLRequestJobFactory(
+    std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
+        protocol_handler_interceptor,
+    std::unique_ptr<net::URLRequestJobFactory> inner_job_factory) {
+  protocol_handler_interceptor->Chain(std::move(inner_job_factory));
+  return std::move(protocol_handler_interceptor);
+}
+
 }  // namespace
 
 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();
@@ skipping 288 matching lines @@
     // since the former has a reference to the latter.
     main_request_context_->transport_security_state()->SetReportSender(nullptr);
     certificate_report_sender_.reset();
 
     main_request_context_->transport_security_state()->SetExpectCTReporter(
         nullptr);
     expect_ct_reporter_.reset();
 
     main_request_context_->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.
-    main_request_context_->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) {
     if (current_context < kMaxCachedContexts) {
       CHECK_EQ(app_context_cache[current_context], it->second);
       memcpy(&tmp_vtable, static_cast<void*>(it->second), sizeof(void*));
       CHECK_EQ(app_context_vtable_cache[current_context], tmp_vtable);
@@ skipping 76 matching lines @@
        it != protocol_handlers->end();
        ++it) {
     bool set_protocol = job_factory->SetProtocolHandler(
         it->first, base::WrapUnique(it->second.release()));
     DCHECK(set_protocol);
   }
   protocol_handlers->clear();
 }
 
 // static
+void ProfileIOData::AddProtocolHandlersToBuilder(
+    net::URLRequestContextBuilder* builder,
+    content::ProtocolHandlerMap* protocol_handlers) {
+  for (auto& protocol_handler : *protocol_handlers) {
+    builder->SetProtocolHandler(
+        protocol_handler.first,
+        base::WrapUnique(protocol_handler.second.release()));
+  }
+  protocol_handlers->clear();
+}
+
+// static
 void ProfileIOData::SetCertVerifierForTesting(
     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 {
@@ skipping 138 matching lines @@
 #else
 #error Unknown platform.
 #endif
 }
 
 void ProfileIOData::DisableQuicOnIOThread() {
   // If the URLRequestContext has not been created yet, it will not be updated
   // here. Instead, it will inherit its QUIC enablement from IOThread on
   // construction, which is fine, as NetHttpSessionParamsObserver also disables
   // QUIC there.
-  if (!main_request_context_storage_ ||
-      !main_request_context_storage_->http_network_session())
+  if (!main_request_context_)
     return;
 
-  main_request_context_storage_->http_network_session()->DisableQuic();
+  main_request_context_->http_transaction_factory()
+      ->GetSession()
+      ->DisableQuic();
 }
 
 void ProfileIOData::set_data_reduction_proxy_io_data(
     std::unique_ptr<data_reduction_proxy::DataReductionProxyIOData>
         data_reduction_proxy_io_data) const {
   data_reduction_proxy_io_data_ = std::move(data_reduction_proxy_io_data);
 }
 
 void ProfileIOData::set_previews_io_data(
     std::unique_ptr<previews::PreviewsIOData> previews_io_data) const {
@@ skipping 26 matching lines @@
     content::URLRequestInterceptorScopedVector request_interceptors) const {
   // The basic logic is implemented here. The specific initialization
   // is done in InitializeInternal(), implemented by subtypes. Static helper
   // functions have been provided to assist in common operations.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!initialized_);
   DCHECK(profile_params_.get());
 
   IOThread* const io_thread = profile_params_->io_thread;
   IOThread::Globals* const io_thread_globals = io_thread->globals();
-  const base::CommandLine& command_line =
-      *base::CommandLine::ForCurrentProcess();
 
   // 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.
-  main_request_context_.reset(new net::URLRequestContext());
-  main_request_context_storage_.reset(
-      new net::URLRequestContextStorage(main_request_context_.get()));
-  main_request_context_->set_name("main");
+  net::URLRequestContextBuilderMojo builder;
+  builder.set_name("main");
 
-  ApplyProfileParamsToContext(main_request_context_.get());
-  main_request_context_->set_net_log(io_thread->net_log());
+  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);
 
-  main_request_context_->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)
   chrome_network_delegate->set_extension_info_map(
       profile_params_->extension_info_map.get());
-  if (!command_line.HasSwitch(switches::kDisableExtensionsHttpThrottling)) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableExtensionsHttpThrottling)) {
     extension_throttle_manager_.reset(
         new extensions::ExtensionThrottleManager());
   }
 #endif
 
   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(
+  builder.set_shared_host_resolver(
       io_thread_globals->system_request_context->host_resolver());
 
-  main_request_context_->set_http_auth_handler_factory(
+  builder.set_shared_http_auth_handler_factory(
       io_thread_globals->system_request_context->http_auth_handler_factory());
 
-  main_request_context_storage_->set_proxy_service(
-      ProxyServiceFactory::CreateProxyService(
-          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()));
+  io_thread->SetUpProxyConfigService(
+      &builder, std::move(profile_params_->proxy_config_service));
 
-  main_request_context_storage_->set_network_delegate(
-      std::move(network_delegate));
+  builder.set_network_delegate(std::move(network_delegate));
 
-  std::unique_ptr<net::TransportSecurityState> transport_security_state(
-      base::MakeUnique<net::TransportSecurityState>());
-  transport_security_persister_.reset(new net::TransportSecurityPersister(
-      transport_security_state.get(), profile_params_->path,
-      base::CreateSequencedTaskRunnerWithTraits(
-          {base::MayBlock(), base::TaskPriority::BACKGROUND,
-           base::TaskShutdownBehavior::BLOCK_SHUTDOWN}),
-      IsOffTheRecord()));
-  main_request_context_storage_->set_transport_security_state(
-      std::move(transport_security_state));
+  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
 
-  resource_context_->host_resolver_ =
-      io_thread_globals->system_request_context->host_resolver();
-  resource_context_->request_context_ = main_request_context_.get();
-
   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) {
-    main_request_context_->set_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()));
     }
-    main_request_context_->set_cert_verifier(cert_verifier_.get());
+    builder.set_shared_cert_verifier(cert_verifier_.get());
 #else
-    main_request_context_->set_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());
 
-  main_request_context_storage_->set_cert_transparency_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());
 
-  main_request_context_storage_->set_ct_policy_enforcer(
-      base::MakeUnique<net::CTPolicyEnforcer>());
+  builder.set_http_network_session_params(
+      profile_params_->io_thread->NetworkSessionParams());
+  if (data_reduction_proxy_io_data_.get()) {
+    builder.set_shared_proxy_delegate(
+        data_reduction_proxy_io_data_->proxy_delegate());
+  }
 
-  InitializeInternal(profile_params_.get(), protocol_handlers,
+  InitializeInternal(&builder, profile_params_.get(), protocol_handlers,
                      std::move(request_interceptors));
 
+  main_request_context_ = builder.Build();
+
+  // 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:
             "Websites can opt in to have Chrome send reports to them when "
             "Chrome observes connections to that website that do not meet "
             "stricter security policies, such as with HTTP Public Key Pinning. "
             "Websites can use this feature to discover misconfigurations that "
             "prevent them from complying with stricter security policies that "
@@ skipping 21 matching lines @@
       certificate_report_sender_.get());
 
   expect_ct_reporter_.reset(
       new ChromeExpectCTReporter(main_request_context_.get()));
   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();
+
+  OnMainRequestContextCreated(profile_params_.get());
+
   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());
-}
-
 std::unique_ptr<net::URLRequestJobFactory>
 ProfileIOData::SetUpJobFactoryDefaults(
     std::unique_ptr<net::URLRequestJobFactoryImpl> job_factory,
     content::URLRequestInterceptorScopedVector request_interceptors,
     std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
         protocol_handler_interceptor,
     net::NetworkDelegate* network_delegate,
     net::HostResolver* host_resolver) const {
   // NOTE(willchan): Keep these protocol handlers in sync with
   // ProfileIOData::IsHandledProtocol().
@@ skipping 59 matching lines @@
   request_interceptors.clear();
 
   if (protocol_handler_interceptor) {
     protocol_handler_interceptor->Chain(std::move(top_job_factory));
     return std::move(protocol_handler_interceptor);
   } else {
     return top_job_factory;
   }
 }
 
+void ProfileIOData::SetUpJobFactoryDefaultsForBuilder(
+    net::URLRequestContextBuilder* builder,
+    content::URLRequestInterceptorScopedVector request_interceptors,
+    std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
+        protocol_handler_interceptor,
+    net::HostResolver* host_resolver) const {
+  // NOTE(willchan): Keep these protocol handlers in sync with
+  // ProfileIOData::IsHandledProtocol().
+  builder->SetProtocolHandler(
+      url::kFileScheme,
+      base::MakeUnique<net::FileProtocolHandler>(
+          base::CreateTaskRunnerWithTraits(
+              {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+               base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  DCHECK(extension_info_map_.get());
+  // Check only for incognito (and not Chrome OS guest mode GUEST_PROFILE).
+  bool is_incognito = profile_type() == Profile::INCOGNITO_PROFILE;
+  builder->SetProtocolHandler(extensions::kExtensionScheme,
+                              extensions::CreateExtensionProtocolHandler(
+                                  is_incognito, extension_info_map_.get()));
+#endif
+  builder->SetProtocolHandler(url::kDataScheme,
+                              base::MakeUnique<net::DataProtocolHandler>());
+#if defined(OS_CHROMEOS)
+  if (profile_params_) {
+    builder->SetProtocolHandler(
+        content::kExternalFileScheme,
+        base::MakeUnique<chromeos::ExternalFileProtocolHandler>(
+            profile_params_->profile));
+  }
+#endif  // defined(OS_CHROMEOS)
+#if defined(OS_ANDROID)
+  builder->SetProtocolHandler(
+      url::kContentScheme,
+      content::ContentProtocolHandler::Create(base::CreateTaskRunnerWithTraits(
+          {base::MayBlock(), base::TaskPriority::USER_VISIBLE,
+           base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})));
+#endif
+
+  builder->SetProtocolHandler(
+      url::kAboutScheme,
+      base::MakeUnique<about_handler::AboutProtocolHandler>());
+
+#if !BUILDFLAG(DISABLE_FTP_SUPPORT)
+  builder->SetProtocolHandler(url::kFtpScheme,
+                              net::FtpProtocolHandler::Create(host_resolver));
+#endif  // !BUILDFLAG(DISABLE_FTP_SUPPORT)
+
+#if BUILDFLAG(DEBUG_DEVTOOLS)
+  request_interceptors.push_back(base::MakeUnique<DebugDevToolsInterceptor>());
+#endif
+
+  builder->SetInterceptors(std::move(request_interceptors));
+
+  if (protocol_handler_interceptor) {
+    builder->set_create_intercepting_job_factory(
+        base::BindOnce(&CreateURLRequestJobFactory,
+                       base::Passed(std::move(protocol_handler_interceptor))));
+  }
+}
+
 void ProfileIOData::ShutdownOnUIThread(
     std::unique_ptr<ChromeURLRequestContextGetterVector> context_getters) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   google_services_user_account_id_.Destroy();
   sync_suppress_start_.Destroy();
   sync_first_setup_complete_.Destroy();
   enable_referrers_.Destroy();
   enable_do_not_track_.Destroy();
   force_google_safesearch_.Destroy();
@@ skipping 22 matching lines @@
 
   bool posted = BrowserThread::DeleteSoon(BrowserThread::IO, FROM_HERE, this);
   if (!posted)
     delete this;
 }
 
 void ProfileIOData::DestroyResourceContext() {
   resource_context_.reset();
 }
 
-std::unique_ptr<net::HttpNetworkSession>
-ProfileIOData::CreateHttpNetworkSession(
-    const ProfileParams& profile_params) const {
-  net::URLRequestContext* context = main_request_context();
-
-  IOThread* const io_thread = profile_params.io_thread;
-
-  net::HttpNetworkSession::Context session_context;
-  net::URLRequestContextBuilder::SetHttpNetworkSessionComponents(
-      context, &session_context);
-  if (data_reduction_proxy_io_data_.get()) {
-    session_context.proxy_delegate =
-        data_reduction_proxy_io_data_->proxy_delegate();
-  }
-
-  return std::unique_ptr<net::HttpNetworkSession>(new net::HttpNetworkSession(
-      io_thread->NetworkSessionParams(), session_context));
-}
-
 std::unique_ptr<net::HttpCache> ProfileIOData::CreateMainHttpFactory(
     net::HttpNetworkSession* session,
     std::unique_ptr<net::HttpCache::BackendFactory> main_backend) const {
   return base::MakeUnique<net::HttpCache>(
       base::WrapUnique(new DevToolsNetworkTransactionFactory(
           network_controller_handle_.GetController(), session)),
       std::move(main_backend), true /* is_main_cache */);
 }
 
 std::unique_ptr<net::HttpCache> ProfileIOData::CreateHttpFactory(
@@ skipping 17 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);
 }