Make ProfileIOData use URLRequestContextBuilder

net/url_request/url_request_context_builder.h

 // 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.
 
 // This class is useful for building a simple URLRequestContext. Most creators
 // of new URLRequestContexts should use this helper class to construct it. Call
 // any configuration params, and when done, invoke Build() to construct the
 // URLRequestContext. This URLRequestContext will own all its own storage.
 //
 // URLRequestContextBuilder and its associated params classes are initially
 // populated with "sane" default values. Read through the comments to figure out
 // what these are.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
 #define NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <string>
 #include <unordered_map>
 #include <utility>
 #include <vector>
 
+#include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/task_scheduler/task_traits.h"
 #include "build/build_config.h"
 #include "build/buildflag.h"
 #include "net/base/net_export.h"
 #include "net/base/network_delegate.h"
 #include "net/base/proxy_delegate.h"
 #include "net/dns/host_resolver.h"
@@ skipping 11 matching lines @@
 }
 
 namespace net {
 
 class CertVerifier;
 class ChannelIDService;
 class CookieStore;
 class CTPolicyEnforcer;
 class CTVerifier;
 class HttpAuthHandlerFactory;
+class HttpUserAgentSettings;
 class HttpServerProperties;
 class NetworkQualityEstimator;
 class ProxyConfigService;
 struct ReportingPolicy;
 class URLRequestContext;
 class URLRequestInterceptor;
 
 // A URLRequestContextBuilder creates a single URLRequestContext. It provides
 // methods to manage various URLRequestContext components which should be called
 // before creating the Context. Once configuration is complete, calling Build()
 // will create a URLRequestContext with the specified configuration. Components
 // that are not explicitly configured will use reasonable in-memory defaults.
 //
 // The returned URLRequestContext is self-contained: Deleting it will safely
 // shut down all of the URLRequests owned by its internal components, and then
 // tear down those components. The only exception to this are objects not owned
 // by URLRequestContext. This includes components passed in to the methods that
 // take raw pointers, and objects that components passed in to the Builder have
 // raw pointers to.
 //
 // A Builder should be destroyed after calling Build, and there is no need to
 // keep it around for the lifetime of the created URLRequestContext. Each
 // Builder may be used to create only a single URLRequestContext.
 class NET_EXPORT URLRequestContextBuilder {
  public:
+  using CreateInterceptingJobFactory =
+      base::OnceCallback<std::unique_ptr<net::URLRequestJobFactory>(
+          std::unique_ptr<net::URLRequestJobFactory> inner_job_factory)>;
+
   struct NET_EXPORT HttpCacheParams {
     enum Type {
       // In-memory cache.
       IN_MEMORY,
       // Disk cache using "default" backend.
       DISK,
+      // Disk cache using "blockfile" backend (BackendImpl).
+      DISK_BLOCKFILE,
       // Disk cache using "simple" backend (SimpleBackendImpl).
       DISK_SIMPLE,
     };
 
     HttpCacheParams();
     ~HttpCacheParams();
 
     // The type of HTTP cache. Default is IN_MEMORY.
     Type type;
 
@@ skipping 61 matching lines @@
   }
 
   void set_ssl_config_service(
       scoped_refptr<net::SSLConfigService> ssl_config_service) {
     ssl_config_service_ = std::move(ssl_config_service);
   }
 
   // Call these functions to specify hard-coded Accept-Language
   // or User-Agent header values for all requests that don't
   // have the headers already set.
-  void set_accept_language(const std::string& accept_language) {
-    accept_language_ = accept_language;
-  }
-  void set_user_agent(const std::string& user_agent) {
-    user_agent_ = user_agent;
-  }
+  void set_accept_language(const std::string& accept_language);
+  void set_user_agent(const std::string& user_agent);
+  // Makes the created URLRequestContext use a shared HttpUserAgentSettings
+  // object. Not compatible with set_accept_language() / set_user_agent(). The
+  // consumer must ensure the HttpUserAgentSettings outlives the
+  // URLRequestContext returned by the builder.
+  //
+  // TODO(mmenke): Take ownership of the object instead. See:
+  // https://crbug.com/743251
+  void set_shared_http_user_agent_settings(
+      HttpUserAgentSettings* shared_http_user_agent_settings);
 
   // Control support for data:// requests. By default it's disabled.
   void set_data_enabled(bool enable) {
     data_enabled_ = enable;
   }
 
 #if !BUILDFLAG(DISABLE_FILE_SUPPORT)
   // Control support for file:// requests. By default it's disabled.
   void set_file_enabled(bool enable) {
     file_enabled_ = enable;
@@ skipping 13 matching lines @@
       const std::string& scheme,
       std::unique_ptr<URLRequestJobFactory::ProtocolHandler> protocol_handler);
 
   // Unlike the other setters, the builder does not take ownership of the
   // NetLog.
   // TODO(mmenke):  Probably makes sense to get rid of this, and have consumers
   // set their own NetLog::Observers instead.
   void set_net_log(NetLog* net_log) { net_log_ = net_log; }
 
   // By default host_resolver is constructed with CreateDefaultResolver.
-  void set_host_resolver(std::unique_ptr<HostResolver> host_resolver) {
-    host_resolver_ = std::move(host_resolver);
-  }
+  void set_host_resolver(std::unique_ptr<HostResolver> host_resolver);
+  // Allows sharing the HostResolver with other URLRequestContexts. Should not
+  // be used if set_host_resolver() is used. The consumer must ensure the
+  // HostResolver outlives the URLRequestContext returned by the builder.
+  //
+  // TODO(mmenke): Figure out the cost/benefits of not supporting sharing
+  // HostResolvers between URLRequestContexts. See: https://crbug.com/743251.
+  void set_shared_host_resolver(HostResolver* host_resolver);
 
   // Uses BasicNetworkDelegate by default. Note that calling Build will unset
   // any custom delegate in builder, so this must be called each time before
   // Build is called.
   void set_network_delegate(std::unique_ptr<NetworkDelegate> delegate) {
     network_delegate_ = std::move(delegate);
   }
 
-  // Temporarily stores a ProxyDelegate. Ownership is transferred to
-  // UrlRequestContextStorage during Build.
-  void set_proxy_delegate(std::unique_ptr<ProxyDelegate> delegate) {
-    proxy_delegate_ = std::move(delegate);
-  }
+  // Sets the ProxyDelegate.
+  void set_proxy_delegate(std::unique_ptr<ProxyDelegate> proxy_delegate);
+  // Allows sharing the PreoxyDelegates with other URLRequestContexts. Should
+  // not be used if set_proxy_delegate() is used. The consumer must ensure the
+  // ProxyDelegate outlives the URLRequestContext returned by the builder.
+  //
+  // TODO(mmenke): Remove this (And update consumers). See:
+  // https://crbug.com/743251.
+  void set_shared_proxy_delegate(ProxyDelegate* shared_proxy_delegate);
 
   // Sets a specific HttpAuthHandlerFactory to be used by the URLRequestContext
   // rather than the default |HttpAuthHandlerRegistryFactory|. The builder
   // takes ownership of the factory and will eventually transfer it to the new
-  // URLRequestContext. Note that since Build will transfer ownership, the
-  // custom factory will be unset and this must be called before the next Build
-  // to set another custom one.
+  // URLRequestContext.
   void SetHttpAuthHandlerFactory(
       std::unique_ptr<HttpAuthHandlerFactory> factory);
+  // Makes the created URLRequestContext use a shared HttpAuthHandlerFactory
+  // object. Not compatible with SetHttpAuthHandlerFactory(). The consumer must
+  // ensure the HttpAuthHandlerFactory outlives the URLRequestContext returned
+  // by the builder.
+  //
+  // TODO(mmenke): Evaluate if sharing is really needed. See:
+  // https://crbug.com/743251.
+  void set_shared_http_auth_handler_factory(
+      HttpAuthHandlerFactory* shared_http_auth_handler_factory);
 
   // By default HttpCache is enabled with a default constructed HttpCacheParams.
   void EnableHttpCache(const HttpCacheParams& params);
   void DisableHttpCache();
 
   // Override default HttpNetworkSession::Params settings.
   void set_http_network_session_params(
       const HttpNetworkSession::Params& http_network_session_params) {
     http_network_session_params_ = http_network_session_params;
   }
 
   void set_transport_security_persister_path(
       const base::FilePath& transport_security_persister_path) {
     transport_security_persister_path_ = transport_security_persister_path;
   }
 
+  // Sets whether the TransportSecurityPersister only reads persisted
+  // information, or also writes it. By default, it both reads and writes.
+  //
+  // TODO(mmenke): Consider removing this in favor of the above method. See:
+  // https://crbug.com/743251.
+  void set_transport_security_persister_readonly(
+      bool transport_security_persister_readonly) {
+    transport_security_persister_readonly_ =
+        transport_security_persister_readonly;
+  }
+
   void SetSpdyAndQuicEnabled(bool spdy_enabled,
                              bool quic_enabled);
 
   void set_throttling_enabled(bool throttling_enabled) {
     throttling_enabled_ = throttling_enabled;
   }
 
   void set_ct_verifier(std::unique_ptr<CTVerifier> ct_verifier);
   void set_ct_policy_enforcer(
       std::unique_ptr<CTPolicyEnforcer> ct_policy_enforcer);
 
   void SetCertVerifier(std::unique_ptr<CertVerifier> cert_verifier);
 
+  // Makes the created URLRequestContext use a shared CertVerifier object.
+  // Should not be used it SetCertVerifier() is used. The consumer must ensure
+  // the CertVerifier outlives the URLRequestContext returned by the builder.
+  //
+  // TODO(mmenke): Figure out if consumers can use SetCertVerifier instead. See:
+  // https://crbug.com/743251.
+  void set_shared_cert_verifier(CertVerifier* shared_cert_verifier);
+
 #if BUILDFLAG(ENABLE_REPORTING)
   void set_reporting_policy(
       std::unique_ptr<net::ReportingPolicy> reporting_policy);
 #endif  // BUILDFLAG(ENABLE_REPORTING)
 
   void SetInterceptors(std::vector<std::unique_ptr<URLRequestInterceptor>>
                            url_request_interceptors);
 
+  // Sets a callback that is passed ownership of the URLRequestJobFactory, and
+  // can wrap it in another URLRequestJobFactory. URLRequestInterceptors can't
+  // handle intercepting unsupported protocols, while this case.
+  // TODO(mmenke): Remove this, once it's no longer needed.
+  void set_create_intercepting_job_factory(
+      CreateInterceptingJobFactory create_intercepting_job_factory);
+
   // Override the default in-memory cookie store and channel id service.
   // If both |cookie_store| and |channel_id_service| are NULL, CookieStore and
   // ChannelIDService will be disabled for this context.
   // If |cookie_store| is not NULL and |channel_id_service| is NULL,
   // only ChannelIdService is disabled for this context.
   // Note that a persistent cookie store should not be used with an in-memory
   // channel id service, and one cookie store should not be shared between
   // multiple channel-id stores (or used both with and without a channel id
   // store).
   void SetCookieAndChannelIdStores(
@@ skipping 35 matching lines @@
       NetworkDelegate* network_delegate,
       NetLog* net_log);
 
  private:
   const char* name_;
   bool enable_brotli_;
   NetworkQualityEstimator* network_quality_estimator_;
 
   std::string accept_language_;
   std::string user_agent_;
+  HttpUserAgentSettings* shared_http_user_agent_settings_;
+
   // Include support for data:// requests.
   bool data_enabled_;
 #if !BUILDFLAG(DISABLE_FILE_SUPPORT)
   // Include support for file:// requests.
   bool file_enabled_;
 #endif
 #if !BUILDFLAG(DISABLE_FTP_SUPPORT)
   // Include support for ftp:// requests.
   bool ftp_enabled_;
 #endif
   bool http_cache_enabled_;
   bool throttling_enabled_;
   bool sdch_enabled_;
   bool cookie_store_set_by_client_;
 
   scoped_refptr<base::SingleThreadTaskRunner> cache_thread_task_runner_;
   HttpCacheParams http_cache_params_;
   HttpNetworkSession::Params http_network_session_params_;
   base::FilePath transport_security_persister_path_;
+  bool transport_security_persister_readonly_;
   NetLog* net_log_;
   std::unique_ptr<HostResolver> host_resolver_;
+  net::HostResolver* shared_host_resolver_;
   std::unique_ptr<ChannelIDService> channel_id_service_;
   std::unique_ptr<ProxyConfigService> proxy_config_service_;
   bool pac_quick_check_enabled_;
   ProxyService::SanitizeUrlPolicy pac_sanitize_url_policy_;
   std::unique_ptr<ProxyService> proxy_service_;
   scoped_refptr<net::SSLConfigService> ssl_config_service_;
   std::unique_ptr<NetworkDelegate> network_delegate_;
   std::unique_ptr<ProxyDelegate> proxy_delegate_;
+  ProxyDelegate* shared_proxy_delegate_;
   std::unique_ptr<CookieStore> cookie_store_;
   std::unique_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_;
+  HttpAuthHandlerFactory* shared_http_auth_handler_factory_;
   std::unique_ptr<CertVerifier> cert_verifier_;
+  CertVerifier* shared_cert_verifier_;
   std::unique_ptr<CTVerifier> ct_verifier_;
   std::unique_ptr<CTPolicyEnforcer> ct_policy_enforcer_;
 #if BUILDFLAG(ENABLE_REPORTING)
   std::unique_ptr<net::ReportingPolicy> reporting_policy_;
 #endif  // BUILDFLAG(ENABLE_REPORTING)
   std::vector<std::unique_ptr<URLRequestInterceptor>> url_request_interceptors_;
+  CreateInterceptingJobFactory create_intercepting_job_factory_;
   std::unique_ptr<HttpServerProperties> http_server_properties_;
   std::map<std::string, std::unique_ptr<URLRequestJobFactory::ProtocolHandler>>
       protocol_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(URLRequestContextBuilder);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_