Reland of Make ProfileIOData use URLRequestContextBuilder

net/url_request/url_request_context_builder.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 "net/url_request/url_request_context_builder.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 174 matching lines @@
 
 URLRequestContextBuilder::HttpCacheParams::HttpCacheParams()
     : type(IN_MEMORY),
       max_size(0) {}
 URLRequestContextBuilder::HttpCacheParams::~HttpCacheParams() {}
 
 URLRequestContextBuilder::URLRequestContextBuilder()
     : name_(nullptr),
       enable_brotli_(false),
       network_quality_estimator_(nullptr),
+      shared_http_user_agent_settings_(nullptr),
       data_enabled_(false),
 #if !BUILDFLAG(DISABLE_FILE_SUPPORT)
       file_enabled_(false),
 #endif
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
       ftp_enabled_(false),
 #endif
       http_cache_enabled_(true),
       throttling_enabled_(false),
       sdch_enabled_(false),
       cookie_store_set_by_client_(false),
+      transport_security_persister_readonly_(false),
       net_log_(nullptr),
+      shared_host_resolver_(nullptr),
       pac_quick_check_enabled_(true),
-      pac_sanitize_url_policy_(ProxyService::SanitizeUrlPolicy::SAFE) {
+      pac_sanitize_url_policy_(ProxyService::SanitizeUrlPolicy::SAFE),
+      shared_proxy_delegate_(nullptr),
+      shared_http_auth_handler_factory_(nullptr),
+      shared_cert_verifier_(nullptr) {
 }
 
 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 
 void URLRequestContextBuilder::SetHttpNetworkSessionComponents(
     const URLRequestContext* request_context,
     HttpNetworkSession::Context* session_context) {
   session_context->host_resolver = request_context->host_resolver();
   session_context->cert_verifier = request_context->cert_verifier();
   session_context->transport_security_state =
@@ skipping 11 matching lines @@
   session_context->channel_id_service = request_context->channel_id_service();
   session_context->network_quality_provider =
       request_context->network_quality_estimator();
   if (request_context->network_quality_estimator()) {
     session_context->socket_performance_watcher_factory =
         request_context->network_quality_estimator()
             ->GetSocketPerformanceWatcherFactory();
   }
 }
 
+void URLRequestContextBuilder::set_accept_language(
+    const std::string& accept_language) {
+  DCHECK(!shared_http_user_agent_settings_);
+  accept_language_ = accept_language;
+}
+void URLRequestContextBuilder::set_user_agent(const std::string& user_agent) {
+  DCHECK(!shared_http_user_agent_settings_);
+  user_agent_ = user_agent;
+}
+void URLRequestContextBuilder::set_shared_http_user_agent_settings(
+    HttpUserAgentSettings* shared_http_user_agent_settings) {
+  DCHECK(accept_language_.empty());
+  DCHECK(user_agent_.empty());
+  shared_http_user_agent_settings_ = shared_http_user_agent_settings;
+}
+
 void URLRequestContextBuilder::EnableHttpCache(const HttpCacheParams& params) {
   http_cache_enabled_ = true;
   http_cache_params_ = params;
 }
 
 void URLRequestContextBuilder::DisableHttpCache() {
   http_cache_enabled_ = false;
   http_cache_params_ = HttpCacheParams();
 }
 
 void URLRequestContextBuilder::SetSpdyAndQuicEnabled(bool spdy_enabled,
                                                      bool quic_enabled) {
   http_network_session_params_.enable_http2 = spdy_enabled;
   http_network_session_params_.enable_quic = quic_enabled;
 }
 
 void URLRequestContextBuilder::set_ct_verifier(
     std::unique_ptr<CTVerifier> ct_verifier) {
   ct_verifier_ = std::move(ct_verifier);
 }
 
 void URLRequestContextBuilder::set_ct_policy_enforcer(
     std::unique_ptr<CTPolicyEnforcer> ct_policy_enforcer) {
   ct_policy_enforcer_ = std::move(ct_policy_enforcer);
 }
 
 void URLRequestContextBuilder::SetCertVerifier(
     std::unique_ptr<CertVerifier> cert_verifier) {
+  DCHECK(!shared_cert_verifier_);
   cert_verifier_ = std::move(cert_verifier);
 }
 
+void URLRequestContextBuilder::set_shared_cert_verifier(
+    CertVerifier* shared_cert_verifier) {
+  DCHECK(!cert_verifier_);
+  shared_cert_verifier_ = shared_cert_verifier;
+}
+
 #if BUILDFLAG(ENABLE_REPORTING)
 void URLRequestContextBuilder::set_reporting_policy(
     std::unique_ptr<net::ReportingPolicy> reporting_policy) {
   reporting_policy_ = std::move(reporting_policy);
 }
 #endif  // BUILDFLAG(ENABLE_REPORTING)
 
 void URLRequestContextBuilder::SetInterceptors(
     std::vector<std::unique_ptr<URLRequestInterceptor>>
         url_request_interceptors) {
   url_request_interceptors_ = std::move(url_request_interceptors);
 }
 
+void URLRequestContextBuilder::set_create_intercepting_job_factory(
+    CreateInterceptingJobFactory create_intercepting_job_factory) {
+  DCHECK(!create_intercepting_job_factory_);
+  create_intercepting_job_factory_ = std::move(create_intercepting_job_factory);
+}
+
 void URLRequestContextBuilder::SetCookieAndChannelIdStores(
     std::unique_ptr<CookieStore> cookie_store,
     std::unique_ptr<ChannelIDService> channel_id_service) {
   cookie_store_set_by_client_ = true;
   // If |cookie_store| is NULL, |channel_id_service| must be NULL too.
   DCHECK(cookie_store || !channel_id_service);
   cookie_store_ = std::move(cookie_store);
   channel_id_service_ = std::move(channel_id_service);
 }
 
 void URLRequestContextBuilder::SetCacheThreadTaskRunner(
     scoped_refptr<base::SingleThreadTaskRunner> cache_thread_task_runner) {
   cache_thread_task_runner_ = std::move(cache_thread_task_runner);
 }
 
 void URLRequestContextBuilder::SetProtocolHandler(
     const std::string& scheme,
     std::unique_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler) {
   DCHECK(protocol_handler);
+  // If a consumer sets a ProtocolHandler and then overwrites it with another,
+  // it's probably a bug.
+  DCHECK_EQ(0u, protocol_handlers_.count(scheme));
   protocol_handlers_[scheme] = std::move(protocol_handler);
 }
 
+void URLRequestContextBuilder::set_host_resolver(
+    std::unique_ptr<HostResolver> host_resolver) {
+  DCHECK(!shared_host_resolver_);
+  host_resolver_ = std::move(host_resolver);
+}
+
+void URLRequestContextBuilder::set_shared_host_resolver(
+    HostResolver* shared_host_resolver) {
+  DCHECK(!host_resolver_);
+  shared_host_resolver_ = shared_host_resolver;
+}
+
+void URLRequestContextBuilder::set_proxy_delegate(
+    std::unique_ptr<ProxyDelegate> proxy_delegate) {
+  DCHECK(!shared_proxy_delegate_);
+  proxy_delegate_ = std::move(proxy_delegate);
+}
+
+void URLRequestContextBuilder::set_shared_proxy_delegate(
+    ProxyDelegate* shared_proxy_delegate) {
+  DCHECK(!proxy_delegate_);
+  shared_proxy_delegate_ = shared_proxy_delegate;
+}
+
 void URLRequestContextBuilder::SetHttpAuthHandlerFactory(
     std::unique_ptr<HttpAuthHandlerFactory> factory) {
+  DCHECK(!shared_http_auth_handler_factory_);
   http_auth_handler_factory_ = std::move(factory);
 }
 
+void URLRequestContextBuilder::set_shared_http_auth_handler_factory(
+    HttpAuthHandlerFactory* shared_http_auth_handler_factory) {
+  DCHECK(!http_auth_handler_factory_);
+  shared_http_auth_handler_factory_ = shared_http_auth_handler_factory;
+}
+
 void URLRequestContextBuilder::SetHttpServerProperties(
     std::unique_ptr<HttpServerProperties> http_server_properties) {
   http_server_properties_ = std::move(http_server_properties);
 }
 
 std::unique_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
   std::unique_ptr<ContainerURLRequestContext> context(
       new ContainerURLRequestContext());
   URLRequestContextStorage* storage = context->storage();
 
   context->set_name(name_);
   context->set_enable_brotli(enable_brotli_);
   context->set_network_quality_estimator(network_quality_estimator_);
 
-  storage->set_http_user_agent_settings(
-      base::MakeUnique<StaticHttpUserAgentSettings>(accept_language_,
-                                                    user_agent_));
+  if (shared_http_user_agent_settings_) {
+    context->set_http_user_agent_settings(shared_http_user_agent_settings_);
+  } else {
+    storage->set_http_user_agent_settings(
+        base::MakeUnique<StaticHttpUserAgentSettings>(accept_language_,
+                                                      user_agent_));
+  }
 
   if (!network_delegate_)
     network_delegate_.reset(new BasicNetworkDelegate);
   storage->set_network_delegate(std::move(network_delegate_));
 
   if (net_log_) {
     // Unlike the other builder parameters, |net_log_| is not owned by the
     // builder or resulting context.
     context->set_net_log(net_log_);
   } else {
     storage->set_net_log(base::WrapUnique(new NetLog));
   }
 
-  if (!host_resolver_) {
-    host_resolver_ = HostResolver::CreateDefaultResolver(context->net_log());
+  if (host_resolver_) {
+    DCHECK(!shared_host_resolver_);
+    storage->set_host_resolver(std::move(host_resolver_));
+  } else if (shared_host_resolver_) {
+    context->set_host_resolver(shared_host_resolver_);
+  } else {
+    storage->set_host_resolver(
+        HostResolver::CreateDefaultResolver(context->net_log()));
   }
-  storage->set_host_resolver(std::move(host_resolver_));
 
   if (ssl_config_service_) {
     // This takes a raw pointer, but |storage| will hold onto a reference to the
     // service.
     storage->set_ssl_config_service(ssl_config_service_.get());
   } else {
     storage->set_ssl_config_service(new SSLConfigServiceDefaults);
   }
 
-  if (!http_auth_handler_factory_) {
-    http_auth_handler_factory_ =
-        HttpAuthHandlerRegistryFactory::CreateDefault(context->host_resolver());
+  if (http_auth_handler_factory_) {
+    DCHECK(!shared_http_auth_handler_factory_);
+    storage->set_http_auth_handler_factory(
+        std::move(http_auth_handler_factory_));
+  } else if (shared_http_auth_handler_factory_) {
+    context->set_http_auth_handler_factory(shared_http_auth_handler_factory_);
+  } else {
+    storage->set_http_auth_handler_factory(
+        HttpAuthHandlerRegistryFactory::CreateDefault(
+            context->host_resolver()));
   }
 
-  storage->set_http_auth_handler_factory(std::move(http_auth_handler_factory_));
-
   if (cookie_store_set_by_client_) {
     storage->set_cookie_store(std::move(cookie_store_));
     storage->set_channel_id_service(std::move(channel_id_service_));
   } else {
     std::unique_ptr<CookieStore> cookie_store(
         new CookieMonster(nullptr, nullptr));
     std::unique_ptr<ChannelIDService> channel_id_service(
         new ChannelIDService(new DefaultChannelIDStore(NULL)));
     cookie_store->SetChannelIDServiceID(channel_id_service->GetUniqueID());
     storage->set_cookie_store(std::move(cookie_store));
@@ skipping 11 matching lines @@
     // Use a low priority because saving this should not block anything
     // user-visible. Block shutdown to ensure it does get persisted to disk,
     // since it contains security-relevant information.
     scoped_refptr<base::SequencedTaskRunner> task_runner(
         base::CreateSequencedTaskRunnerWithTraits(
             {base::MayBlock(), base::TaskPriority::BACKGROUND,
              base::TaskShutdownBehavior::BLOCK_SHUTDOWN}));
 
     context->set_transport_security_persister(
         base::WrapUnique<TransportSecurityPersister>(
-            new TransportSecurityPersister(context->transport_security_state(),
-                                           transport_security_persister_path_,
-                                           task_runner, false)));
+            new TransportSecurityPersister(
+                context->transport_security_state(),
+                transport_security_persister_path_, task_runner,
+                transport_security_persister_readonly_)));
   }
 
   if (http_server_properties_) {
     storage->set_http_server_properties(std::move(http_server_properties_));
   } else {
     storage->set_http_server_properties(
         std::unique_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
   }
 
   if (cert_verifier_) {
+    DCHECK(!shared_cert_verifier_);
     storage->set_cert_verifier(std::move(cert_verifier_));
+  } else if (shared_cert_verifier_) {
+    context->set_cert_verifier(shared_cert_verifier_);
   } else {
     storage->set_cert_verifier(CertVerifier::CreateDefault());
   }
 
   if (ct_verifier_) {
     storage->set_cert_transparency_verifier(std::move(ct_verifier_));
   } else {
     std::unique_ptr<MultiLogCTVerifier> ct_verifier =
         base::MakeUnique<MultiLogCTVerifier>();
     ct_verifier->AddLogs(ct::CreateLogVerifiersForKnownLogs());
@@ skipping 25 matching lines @@
                            context->network_delegate(), context->net_log());
     proxy_service_->set_quick_check_enabled(pac_quick_check_enabled_);
     proxy_service_->set_sanitize_url_policy(pac_sanitize_url_policy_);
   }
   storage->set_proxy_service(std::move(proxy_service_));
 
   HttpNetworkSession::Context network_session_context;
   SetHttpNetworkSessionComponents(context.get(), &network_session_context);
 
   if (proxy_delegate_) {
+    DCHECK(!shared_proxy_delegate_);
     network_session_context.proxy_delegate = proxy_delegate_.get();
     storage->set_proxy_delegate(std::move(proxy_delegate_));
+  } else if (shared_proxy_delegate_) {
+    network_session_context.proxy_delegate = shared_proxy_delegate_;
   }
 
   storage->set_http_network_session(base::MakeUnique<HttpNetworkSession>(
       http_network_session_params_, network_session_context));
 
   std::unique_ptr<HttpTransactionFactory> http_transaction_factory;
   if (http_cache_enabled_) {
     std::unique_ptr<HttpCache::BackendFactory> http_cache_backend;
     if (http_cache_params_.type != HttpCacheParams::IN_MEMORY) {
       if (!cache_thread_task_runner_) {
         cache_thread_task_runner_ =
             base::CreateSingleThreadTaskRunnerWithTraits(
                 {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
                  base::TaskShutdownBehavior::BLOCK_SHUTDOWN});
       }
-      BackendType backend_type =
-          http_cache_params_.type == HttpCacheParams::DISK
-              ? CACHE_BACKEND_DEFAULT
-              : CACHE_BACKEND_SIMPLE;
+      // TODO(mmenke): Maybe merge BackendType and HttpCacheParams::Type? The
+      // first doesn't include in memory, so may require some work.
+      BackendType backend_type = CACHE_BACKEND_DEFAULT;
+      switch (http_cache_params_.type) {
+        case HttpCacheParams::DISK:
+          backend_type = CACHE_BACKEND_DEFAULT;
+          break;
+        case HttpCacheParams::DISK_BLOCKFILE:
+          backend_type = CACHE_BACKEND_BLOCKFILE;
+          break;
+        case HttpCacheParams::DISK_SIMPLE:
+          backend_type = CACHE_BACKEND_SIMPLE;
+          break;
+        case HttpCacheParams::IN_MEMORY:
+          NOTREACHED();
+          break;
+      }
       http_cache_backend.reset(new HttpCache::DefaultBackend(
           DISK_CACHE, backend_type, http_cache_params_.path,
           http_cache_params_.max_size, cache_thread_task_runner_));
     } else {
       http_cache_backend =
           HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
     }
 
     http_transaction_factory.reset(new HttpCache(
         storage->http_network_session(), std::move(http_cache_backend), true));
@@ skipping 37 matching lines @@
   if (!url_request_interceptors_.empty()) {
     // Set up interceptors in the reverse order.
 
     for (auto i = url_request_interceptors_.rbegin();
          i != url_request_interceptors_.rend(); ++i) {
       top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
           std::move(top_job_factory), std::move(*i)));
     }
     url_request_interceptors_.clear();
   }
+  if (create_intercepting_job_factory_) {
+    top_job_factory = std::move(create_intercepting_job_factory_)
+                          .Run(std::move(top_job_factory));
+  }
   storage->set_job_factory(std::move(top_job_factory));
 
 #if BUILDFLAG(ENABLE_REPORTING)
   if (reporting_policy_) {
     storage->set_reporting_service(
         ReportingService::Create(*reporting_policy_, context.get()));
   }
 #endif  // BUILDFLAG(ENABLE_REPORTING)
 
   return std::move(context);
 }
 
 std::unique_ptr<ProxyService> URLRequestContextBuilder::CreateProxyService(
     std::unique_ptr<ProxyConfigService> proxy_config_service,
     URLRequestContext* url_request_context,
     HostResolver* host_resolver,
     NetworkDelegate* network_delegate,
     NetLog* net_log) {
   return ProxyService::CreateUsingSystemProxyResolver(
       std::move(proxy_config_service), net_log);
 }
 
 }  // namespace net