Refactor main URLRequestContext creation to use URLRequestContextBuilder

chrome/browser/profiles/profile_io_data.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.
 
 #ifndef CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_
 #define CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_
 
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 10 matching lines @@
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/storage_partition_descriptor.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/resource_context.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_builder.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory.h"
 
 class ChromeHttpUserAgentSettings;
 class ChromeNetworkDelegate;
 class ChromeURLRequestContextGetter;
 class DevToolsNetworkController;
 class HostContentSettingsMap;
 class MediaDeviceIDSalt;
 class ProtocolHandlerRegistry;
@@ skipping 22 matching lines @@
 class CookieStore;
 class FraudulentCertificateReporter;
 class FtpTransactionFactory;
 class HttpServerProperties;
 class HttpTransactionFactory;
 class ProxyConfigService;
 class ProxyService;
 class SSLConfigService;
 class TransportSecurityPersister;
 class TransportSecurityState;
+class URLRequestContextBuilder;
 class URLRequestJobFactoryImpl;
 }  // namespace net
 
 namespace policy {
 class PolicyCertVerifier;
 class PolicyHeaderIOHelper;
 class URLBlacklistManager;
 }  // namespace policy
 
 // Conceptually speaking, the ProfileIOData represents data that lives on the IO
@@ skipping 84 matching lines @@
   IntegerPrefMember* network_prediction_options() const {
     return &network_prediction_options_;
   }
 
   content::ResourceContext::SaltCallback GetMediaDeviceIDSalt() const;
 
   DevToolsNetworkController* network_controller() const {
     return network_controller_.get();
   }
 
-  net::TransportSecurityState* transport_security_state() const {
-    return transport_security_state_.get();
-  }
+  net::TransportSecurityState* transport_security_state() const;
 
 #if defined(OS_CHROMEOS)
   std::string username_hash() const {
     return username_hash_;
   }
 
   bool use_system_key_slot() const { return use_system_key_slot_; }
 #endif
 
   Profile::ProfileType profile_type() const {
@@ skipping 121 matching lines @@
     std::string username_hash;
     bool use_system_key_slot;
 #endif
 
     // The profile this struct was populated from. It's passed as a void* to
     // ensure it's not accidently used on the IO thread. Before using it on the
     // UI thread, call ProfileManager::IsValidProfile to ensure it's alive.
     void* profile;
   };
 
+  // Declared here to allow access to ProfileParams.
+  class HttpTransactionFactoryDelegate
+      : public net::HttpTransactionFactoryFactory {
+   public:
+    HttpTransactionFactoryDelegate(const ProfileIOData* owner,
+                                   const ProfileParams* profile_params,
+                                   net::HttpCache::BackendFactory* main_backend)
+        : owner_(owner),
+          profile_params_(profile_params),
+          main_backend_(main_backend) {}
+
+    net::HttpTransactionFactory* Create(
+        net::URLRequestContext* context) override;
+
+   private:
+    const ProfileIOData* owner_;
+    const ProfileParams* profile_params_;
+    net::HttpCache::BackendFactory* main_backend_;
+  };
+
+  // Declared here to allow access to protected functions.
+  class CertVerifierDelegateMainContext : public net::CertVerifierDelegate {
+   public:
+    CertVerifierDelegateMainContext(const ProfileIOData* owner)
+        : owner_(owner) {}
+
+    net::CertVerifier* Get(net::URLRequestContext* context) override;
+
+   private:
+    const ProfileIOData* owner_;
+  };
+
+  net::CertVerifier* GetCertVerifierForMainContext(
+      net::URLRequestContext* context) const;
+
   explicit ProfileIOData(Profile::ProfileType profile_type);
 
   static std::string GetSSLSessionCacheShard();
 
   void InitializeOnUIThread(Profile* profile);
   void ApplyProfileParamsToContext(net::URLRequestContext* context) const;
+  void ApplyProfileParamsToContext(
+      net::URLRequestContextBuilder* context_builder) const;
 
   scoped_ptr<net::URLRequestJobFactory> SetUpJobFactoryDefaults(
       scoped_ptr<net::URLRequestJobFactoryImpl> job_factory,
       content::URLRequestInterceptorScopedVector request_interceptors,
       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
           protocol_handler_interceptor,
       net::NetworkDelegate* network_delegate,
       net::FtpTransactionFactory* ftp_transaction_factory) const;
 
   // Called when the Profile is destroyed. |context_getters| must include all
   // URLRequestContextGetters that refer to the ProfileIOData's
   // URLRequestContexts. Triggers destruction of the ProfileIOData and shuts
   // down |context_getters| safely on the IO thread.
   // TODO(mmenke):  Passing all those URLRequestContextGetters around like this
   //     is really silly.  Can we do something cleaner?
   void ShutdownOnUIThread(
       scoped_ptr<ChromeURLRequestContextGetterVector> context_getters);
 
-  // A ChannelIDService object is created by a derived class of
-  // ProfileIOData, and the derived class calls this method to set the
-  // channel_id_service_ member and transfers ownership to the base
-  // class.
-  void set_channel_id_service(
-      net::ChannelIDService* channel_id_service) const;
-
   void set_data_reduction_proxy_io_data(
       scoped_ptr<data_reduction_proxy::DataReductionProxyIOData>
           data_reduction_proxy_io_data) const;
 
-  net::FraudulentCertificateReporter* fraudulent_certificate_reporter() const {
-    return fraudulent_certificate_reporter_.get();
-  }
+  net::FraudulentCertificateReporter* fraudulent_certificate_reporter() const;
 
   net::ProxyService* proxy_service() const {
     return proxy_service_.get();
   }
 
   base::WeakPtr<net::HttpServerProperties> http_server_properties() const;
 
   void set_http_server_properties(
       scoped_ptr<net::HttpServerProperties> http_server_properties) const;
 
   net::URLRequestContext* main_request_context() const {
     return main_request_context_.get();
   }
 
   bool initialized() const {
     return initialized_;
   }
 
   // Destroys the ResourceContext first, to cancel any URLRequests that are
   // using it still, before we destroy the member variables that those
   // URLRequests may be accessing.
   void DestroyResourceContext();
 
   // Creates network session and main network transaction factory.
   scoped_ptr<net::HttpCache> CreateMainHttpFactory(
       const ProfileParams* profile_params,
-      net::HttpCache::BackendFactory* main_backend) const;
+      net::HttpCache::BackendFactory* main_backend,
+      net::URLRequestContext* context) const;
 
   // Creates network transaction factory.
   scoped_ptr<net::HttpCache> CreateHttpFactory(
       net::HttpNetworkSession* shared_session,
       net::HttpCache::BackendFactory* backend) const;
 
   void SetCookieSettingsForTesting(
       content_settings::CookieSettings* cookie_settings);
 
  private:
@@ skipping 31 matching lines @@
   // --------------------------------------------
   // Virtual interface for subtypes to implement:
   // --------------------------------------------
 
   // Does the actual initialization of the ProfileIOData subtype. Subtypes
   // should use the static helper functions above to implement this.
   virtual void InitializeInternal(
       scoped_ptr<ChromeNetworkDelegate> chrome_network_delegate,
       ProfileParams* profile_params,
       content::ProtocolHandlerMap* protocol_handlers,
-      content::URLRequestInterceptorScopedVector
-          request_interceptors) const = 0;
+      content::URLRequestInterceptorScopedVector request_interceptors,
+      net::URLRequestContextBuilder* context_builder) const = 0;
 
   // Initializes the RequestContext for extensions.
   virtual void InitializeExtensionsRequestContext(
       ProfileParams* profile_params) const = 0;
   // Does an on-demand initialization of a RequestContext for the given
   // isolated app.
   virtual net::URLRequestContext* InitializeAppRequestContext(
       net::URLRequestContext* main_context,
       const StoragePartitionDescriptor& details,
       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
@@ skipping 18 matching lines @@
       scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
           protocol_handler_interceptor,
       content::ProtocolHandlerMap* protocol_handlers,
       content::URLRequestInterceptorScopedVector
           request_interceptors) const = 0;
   virtual net::URLRequestContext*
       AcquireIsolatedMediaRequestContext(
           net::URLRequestContext* app_context,
           const StoragePartitionDescriptor& partition_descriptor) const = 0;
 
+  virtual void InitPostContextSetup(
+      ChromeNetworkDelegate* chrome_network_delegate) const {}
+
   // The order *DOES* matter for the majority of these member variables, so
   // don't move them around unless you know what you're doing!
   // General rules:
   //   * ResourceContext references the URLRequestContexts, so
   //   URLRequestContexts must outlive ResourceContext, hence ResourceContext
   //   should be destroyed first.
   //   * URLRequestContexts reference a whole bunch of members, so
   //   URLRequestContext needs to be destroyed before them.
   //   * Therefore, ResourceContext should be listed last, and then the
   //   URLRequestContexts, and then the URLRequestContext members.
@@ skipping 41 matching lines @@
 #if defined(ENABLE_CONFIGURATION_POLICY)
   // Pointed to by NetworkDelegate.
   mutable scoped_ptr<policy::URLBlacklistManager> url_blacklist_manager_;
   mutable scoped_ptr<policy::PolicyHeaderIOHelper> policy_header_helper_;
 #endif
 
   // Pointed to by URLRequestContext.
 #if defined(ENABLE_EXTENSIONS)
   mutable scoped_refptr<extensions::InfoMap> extension_info_map_;
 #endif
-  mutable scoped_ptr<net::ChannelIDService> channel_id_service_;
 
   mutable scoped_ptr<data_reduction_proxy::DataReductionProxyIOData>
       data_reduction_proxy_io_data_;
 
   mutable scoped_ptr<net::FraudulentCertificateReporter>
       fraudulent_certificate_reporter_;
   mutable scoped_ptr<net::ProxyService> proxy_service_;
-  mutable scoped_ptr<net::TransportSecurityState> transport_security_state_;
   mutable scoped_ptr<net::HttpServerProperties>
       http_server_properties_;
 #if defined(OS_CHROMEOS)
   // Set to |cert_verifier_| if it references a PolicyCertVerifier. In that
   // case, the verifier is owned by  |cert_verifier_|. Otherwise, set to NULL.
   mutable policy::PolicyCertVerifier* policy_cert_verifier_;
   mutable scoped_ptr<net::CertVerifier> cert_verifier_;
   mutable std::string username_hash_;
   mutable bool use_system_key_slot_;
 #endif
@@ skipping 36 matching lines @@
 
   // TODO(jhawkins): Remove once crbug.com/102004 is fixed.
   bool initialized_on_UI_thread_;
 
   const Profile::ProfileType profile_type_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileIOData);
 };
 
 #endif  // CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_