Refactor main URLRequestContext creation to 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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "build/build_config.h"
 #include "net/base/net_export.h"
 #include "net/base/network_delegate.h"
 #include "net/dns/host_resolver.h"
 #include "net/proxy/proxy_config_service.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/quic_protocol.h"
 #include "net/socket/next_proto.h"
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace net {
 
+class CertVerifier;
 class ChannelIDService;
 class CookieStore;
+class CTVerifier;
+class FraudulentCertificateReporter;
 class FtpTransactionFactory;
 class HostMappingRules;
 class HttpAuthHandlerFactory;
+class HttpServerProperties;
+class HttpTransactionFactory;
+class HttpUserAgentSettings;
+class NetworkQualityEstimator;
 class ProxyConfigService;
+class SSLConfigService;
+class SdchManager;
+class TransportSecurityState;
 class URLRequestContext;
 class URLRequestInterceptor;
+class URLRequestJobFactory;
+
+// The next threee classes are interfaces to allow callbacks during the
+// construction of a main context.
+// TODO(wjmaclean): Should these be combined into a single Delegate class,
+// to be implemented by the creator of the main context?
+class FraudulentCertificateReporterFactory {
+ public:
+  FraudulentCertificateReporterFactory() {}
+
+  virtual FraudulentCertificateReporter* Create(
+      URLRequestContext* context) const = 0;
+};
+
+class HttpTransactionFactoryFactory {
+ public:
+  HttpTransactionFactoryFactory() {}
+  virtual ~HttpTransactionFactoryFactory() {}
+
+  virtual HttpTransactionFactory* Create(URLRequestContext* context) = 0;
+};
+
+class CertVerifierDelegate {
+ public:
+  CertVerifierDelegate() {}
+  virtual ~CertVerifierDelegate() {}
+
+  virtual CertVerifier* Get(URLRequestContext* context) = 0;
+};
 
 class NET_EXPORT URLRequestContextBuilder {
  public:
   struct NET_EXPORT HttpCacheParams {
     enum Type {
       IN_MEMORY,
       DISK,
     };
 
     HttpCacheParams();
@@ skipping 30 matching lines @@
   ~URLRequestContextBuilder();
 
   // These functions are mutually exclusive.  The ProxyConfigService, if
   // set, will be used to construct a ProxyService.
   void set_proxy_config_service(ProxyConfigService* proxy_config_service) {
     proxy_config_service_.reset(proxy_config_service);
   }
   void set_proxy_service(ProxyService* proxy_service) {
     proxy_service_.reset(proxy_service);
   }
+  void set_proxy_service_unowned(ProxyService* proxy_service) {
+    proxy_service_unowned_ = proxy_service;
+  }
+
+  void set_ssl_config_service(SSLConfigService* service) {
+    ssl_config_service_ = 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;
   }
@@ skipping 94 matching lines @@
 
   // Note that if SDCH is enabled without a policy object observing
   // the SDCH manager and handling at least Get-Dictionary events, the
   // result will be "Content-Encoding: sdch" advertisements, but no
   // dictionaries fetches and no specific dictionaries advertised.
   // SdchOwner in net/sdch/sdch_owner.h is a simple policy object.
   void set_sdch_enabled(bool enable) { sdch_enabled_ = enable; }
 
   URLRequestContext* Build();
 
+  // Functions specific to building a main context.
+  void set_fraudulent_certificate_reporter_factory(
+      const FraudulentCertificateReporterFactory* factory) {
+    fraudulent_certificate_reporter_factory_ = factory;
+  }
+
+  void set_net_log_unowned(NetLog* net_log) {
+    net_log_unowned_= net_log;
+  }
+
+  void set_transport_security_state(TransportSecurityState* state){
+    transport_security_state_.reset(state);
+  }
+
+  void set_http_user_agent_settings_unowned(HttpUserAgentSettings* settings) {
+    http_user_agent_settings_unowned_ = settings;
+  }
+
+  void set_http_transaction_factory_factory(
+      HttpTransactionFactoryFactory* factory) {
+    http_transaction_factory_factory_.reset(factory);
+  }
+
+  void set_cert_verifier_delegate(CertVerifierDelegate* cert_verifier_delegate) {
+    cert_verifier_delegate_.reset(cert_verifier_delegate);
+  }
+
+  void set_host_resolver_unowned(HostResolver* host_resolver) {
+    host_resolver_unowned_ = host_resolver;
+  }
+
+  void set_cert_transparency_verifier_unowned(CTVerifier* ct_verifier) {
+    cert_transparency_verifier_unowned_ = ct_verifier;
+  }
+
+  void set_http_server_properties(
+      const base::WeakPtr<HttpServerProperties>& http_server_properties) {
+    http_server_properties_ = http_server_properties;
+  }
+
+  void set_http_auth_handler_factory_unowned(
+      HttpAuthHandlerFactory* http_auth_handler_factory) {
+    http_auth_handler_factory_unowned_ = http_auth_handler_factory;
+  }
+
+  void set_sdch_manager(SdchManager* manager);
+
+  void set_job_factory(scoped_ptr<URLRequestJobFactory> factory);
+
+  void set_network_quality_estimator_unowned(
+      NetworkQualityEstimator* network_quality_estimator) {
+    network_quality_estimator_unowned_ = network_quality_estimator;
+  }
+
+  URLRequestContext* BuildMainContext();
+
  private:
   struct NET_EXPORT SchemeFactory {
     SchemeFactory(const std::string& scheme, HttpAuthHandlerFactory* factory);
     ~SchemeFactory();
 
     std::string scheme;
     HttpAuthHandlerFactory* factory;
   };
 
   std::string accept_language_;
@@ skipping 20 matching lines @@
   scoped_ptr<HostResolver> host_resolver_;
   scoped_ptr<ChannelIDService> channel_id_service_;
   scoped_ptr<ProxyConfigService> proxy_config_service_;
   scoped_ptr<ProxyService> proxy_service_;
   scoped_ptr<NetworkDelegate> network_delegate_;
   scoped_refptr<CookieStore> cookie_store_;
   scoped_ptr<FtpTransactionFactory> ftp_transaction_factory_;
   std::vector<SchemeFactory> extra_http_auth_handlers_;
   ScopedVector<URLRequestInterceptor> url_request_interceptors_;
 
+  // Member variables specific to building a main context.
+  // Names ending in 'unowned' indicate variables that will not be owned by
+  // the main context, If this ownership status changes, then the variable
+  // in question should be renamed.
+  const FraudulentCertificateReporterFactory*
+      fraudulent_certificate_reporter_factory_;
+  NetLog* net_log_unowned_;
+  scoped_ptr<TransportSecurityState> transport_security_state_;
+  HttpUserAgentSettings* http_user_agent_settings_unowned_;
+  scoped_ptr<HttpTransactionFactoryFactory> http_transaction_factory_factory_;
+  scoped_ptr<CertVerifierDelegate> cert_verifier_delegate_;
+  HostResolver* host_resolver_unowned_;
+  CTVerifier* cert_transparency_verifier_unowned_;
+  base::WeakPtr<HttpServerProperties> http_server_properties_;
+  HttpAuthHandlerFactory* http_auth_handler_factory_unowned_;
+  scoped_ptr<SdchManager> sdch_manager_;
+  scoped_ptr<URLRequestJobFactory> job_factory_;
+  NetworkQualityEstimator* network_quality_estimator_unowned_;
+  scoped_refptr<SSLConfigService> ssl_config_service_;
+  ProxyService* proxy_service_unowned_;
+
   DISALLOW_COPY_AND_ASSIGN(URLRequestContextBuilder);
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_BUILDER_H_