Make ProfileIOData 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 <stdint.h>
 
 #include <map>
@@ skipping 64 matching lines @@
 namespace net {
 class CertVerifier;
 class ChannelIDService;
 class ClientCertStore;
 class CookieStore;
 class HttpTransactionFactory;
 class ProxyConfigService;
 class ReportingService;
 class ReportSender;
 class SSLConfigService;
-class TransportSecurityPersister;
-class URLRequestContextStorage;
+class URLRequestContextBuilder;
 class URLRequestJobFactoryImpl;
 }  // namespace net
 
 namespace policy {
 class PolicyCertVerifier;
 class PolicyHeaderIOHelper;
 class URLBlacklistManager;
 }  // namespace policy
 
 namespace previews {
@@ skipping 18 matching lines @@
   // net::URLRequest.
   static bool IsHandledProtocol(const std::string& scheme);
 
   // Returns true if |url| is handled in Chrome, or by default handlers in
   // net::URLRequest.
   static bool IsHandledURL(const GURL& url);
 
   // Utility to install additional WebUI handlers into the |job_factory|.
   // Ownership of the handlers is transfered from |protocol_handlers|
   // to the |job_factory|.
+  // TODO(mmenke): Remove this, once only AddProtocolHandlersToBuilder is used.
   static void InstallProtocolHandlers(
       net::URLRequestJobFactoryImpl* job_factory,
       content::ProtocolHandlerMap* protocol_handlers);
 
+  // Utility to install additional WebUI handlers into |builder|. Ownership of
+  // the handlers is transfered from |protocol_handlers| to |builder|.
+  static void AddProtocolHandlersToBuilder(
+      net::URLRequestContextBuilder* builder,
+      content::ProtocolHandlerMap* protocol_handlers);
+
   // Sets a global CertVerifier to use when initializing all profiles.
   static void SetCertVerifierForTesting(net::CertVerifier* cert_verifier);
 
   // Called by Profile.
   content::ResourceContext* GetResourceContext() const;
 
   // Initializes the ProfileIOData object and primes the RequestContext
   // generation. Must be called prior to any of the Get*() methods other than
   // GetResouceContext or GetMetricsEnabledStateOnIOThread.
   void Init(
@@ skipping 197 matching lines @@
 
     // 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;
   };
 
   explicit ProfileIOData(Profile::ProfileType profile_type);
 
   void InitializeOnUIThread(Profile* profile);
-  void ApplyProfileParamsToContext(net::URLRequestContext* context) const;
 
   // Does common setup of the URLRequestJobFactories. Adds default
   // ProtocolHandlers to |job_factory|, adds URLRequestInterceptors in front of
   // it as needed, and returns the result.
   //
   // |protocol_handler_interceptor| is configured to intercept URLRequests
   //     before all other URLRequestInterceptors, if non-null.
   // |host_resolver| is needed to set up the FtpProtocolHandler.
   std::unique_ptr<net::URLRequestJobFactory> 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;
 
+  // Does common setup of the URLRequestJobFactories. Adds default
+  // ProtocolHandlers to |builder|, and adds URLRequestInterceptors in front of
+  // them as needed.
+  //
+  // |protocol_handler_interceptor| is configured to intercept URLRequests
+  //     before all other URLRequestInterceptors, if non-null.
+  // |host_resolver| is needed to set up the FtpProtocolHandler.
+  void SetUpJobFactoryDefaultsForBuilder(
+      net::URLRequestContextBuilder* builder,
+      content::URLRequestInterceptorScopedVector request_interceptors,
+      std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
+          protocol_handler_interceptor,
+      net::HostResolver* host_resolver) 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(
       std::unique_ptr<ChromeURLRequestContextGetterVector> context_getters);
 
   void set_data_reduction_proxy_io_data(
       std::unique_ptr<data_reduction_proxy::DataReductionProxyIOData>
           data_reduction_proxy_io_data) const;
 
   void set_previews_io_data(
       std::unique_ptr<previews::PreviewsIOData> previews_io_data) const;
 
   net::URLRequestContext* main_request_context() const {
     return main_request_context_.get();
   }
 
-  // Storage for |main_request_context_|, to allow objects created by subclasses
-  // to live until the ProfileIOData destructor is invoked, so it can safely
-  // cancel URLRequests.
-  net::URLRequestContextStorage* main_request_context_storage() const {
-    return main_request_context_storage_.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();
 
-  std::unique_ptr<net::HttpNetworkSession> CreateHttpNetworkSession(
-      const ProfileParams& profile_params) const;
-
   // Creates main network transaction factory.
   std::unique_ptr<net::HttpCache> CreateMainHttpFactory(
       net::HttpNetworkSession* session,
       std::unique_ptr<net::HttpCache::BackendFactory> main_backend) const;
 
   // Creates network transaction factory. The created factory will share
   // HttpNetworkSession with |main_http_factory|.
   std::unique_ptr<net::HttpCache> CreateHttpFactory(
       net::HttpTransactionFactory* main_http_factory,
       std::unique_ptr<net::HttpCache::BackendFactory> backend) const;
@@ skipping 29 matching lines @@
   // Virtual interface for subtypes to implement:
   // --------------------------------------------
 
   // Does any necessary additional configuration of the network delegate,
   // including composing it with other NetworkDelegates, if needed. By default,
   // just returns the input NetworkDelegate.
   virtual std::unique_ptr<net::NetworkDelegate> ConfigureNetworkDelegate(
       IOThread* io_thread,
       std::unique_ptr<ChromeNetworkDelegate> chrome_network_delegate) const;
 
-  // Does the actual initialization of the ProfileIOData subtype. Subtypes
-  // should use the static helper functions above to implement this.
+  // Does the initialization of the URLRequestContextBuilder for a ProfileIOData
+  // subclass. Subclasseses should use the static helper functions above to
+  // implement this.
   virtual void InitializeInternal(
+      net::URLRequestContextBuilder* builder,
       ProfileParams* profile_params,
       content::ProtocolHandlerMap* protocol_handlers,
       content::URLRequestInterceptorScopedVector request_interceptors)
       const = 0;
 
+  // Called after the main URLRequestContext has been initialized, just after
+  // InitializeInternal().
+  virtual void OnMainRequestContextCreated(
+      ProfileParams* profile_params) 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,
       std::unique_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
           protocol_handler_interceptor,
@@ skipping 88 matching lines @@
 #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 std::unique_ptr<net::CertVerifier> cert_verifier_;
   mutable policy::PolicyCertVerifier* policy_cert_verifier_;
   mutable std::string username_hash_;
   mutable bool use_system_key_slot_;
   mutable std::unique_ptr<chromeos::CertificateProvider> certificate_provider_;
 #endif
 
-  // Owns the subset of URLRequestContext's elements that are created by
-  // subclasses of ProfileImplIOData, to ensure proper destruction ordering.
-  // TODO(mmenke):  Move ownship of net objects owned by the ProfileIOData
-  // itself to this class, to improve destruction ordering.
-  mutable std::unique_ptr<net::URLRequestContextStorage>
-      main_request_context_storage_;
   mutable std::unique_ptr<net::URLRequestContext> main_request_context_;
 
   // Pointed to by the TransportSecurityState (owned by
   // URLRequestContextStorage), and must be disconnected from it before it's
   // destroyed.
-  mutable std::unique_ptr<net::TransportSecurityPersister>
-      transport_security_persister_;
   mutable std::unique_ptr<net::ReportSender> certificate_report_sender_;
   mutable std::unique_ptr<certificate_transparency::CTPolicyManager>
       ct_policy_manager_;
 
   mutable std::unique_ptr<net::URLRequestContext> extensions_request_context_;
   // One URLRequestContext per isolated app for main and media requests.
   mutable URLRequestContextMap app_request_context_map_;
   mutable URLRequestContextMap isolated_media_request_context_map_;
 
   mutable std::unique_ptr<ResourceContext> resource_context_;
@@ skipping 19 matching lines @@
   mutable std::unique_ptr<certificate_transparency::TreeStateTracker>
       ct_tree_tracker_;
   mutable base::Closure ct_tree_tracker_unregistration_;
 
   const Profile::ProfileType profile_type_;
 
   DISALLOW_COPY_AND_ASSIGN(ProfileIOData);
 };
 
 #endif  // CHROME_BROWSER_PROFILES_PROFILE_IO_DATA_H_