Refactor main URLRequestContext creation to use URLRequestContextBuilder

chrome/browser/profiles/profile_impl_io_data.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 "chrome/browser/profiles/profile_impl_io_data.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 42 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "extensions/browser/extension_protocols.h"
 #include "extensions/common/constants.h"
 #include "net/base/cache_type.h"
 #include "net/base/sdch_manager.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/sdch/sdch_owner.h"
 #include "net/ssl/channel_id_service.h"
+#include "net/url_request/url_request_context_builder.h"
+#include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "storage/browser/quota/special_storage_policy.h"
 
 namespace {
 
 net::BackendType ChooseCacheBackendType() {
 #if defined(OS_ANDROID)
   return net::CACHE_BACKEND_SIMPLE;
 #else
@@ skipping 366 matching lines @@
   DestroyResourceContext();
 
   if (media_request_context_)
     media_request_context_->AssertNoURLRequests();
 }
 
 void ProfileImplIOData::InitializeInternal(
     scoped_ptr<ChromeNetworkDelegate> chrome_network_delegate,
     ProfileParams* profile_params,
     content::ProtocolHandlerMap* protocol_handlers,
-    content::URLRequestInterceptorScopedVector request_interceptors) const {
+    content::URLRequestInterceptorScopedVector request_interceptors,
+    net::URLRequestContextBuilder* context_builder) const {
   // Set up a persistent store for use by the network stack on the IO thread.
   base::FilePath network_json_store_filepath(
       profile_path_.Append(chrome::kNetworkPersistentStateFilename));
   network_json_store_ = new JsonPrefStore(
       network_json_store_filepath,
       JsonPrefStore::GetTaskRunnerForFile(network_json_store_filepath,
                                           BrowserThread::GetBlockingPool()),
       scoped_ptr<PrefFilter>());
   network_json_store_->ReadPrefsAsync(nullptr);
 
-  net::URLRequestContext* main_context = main_request_context();
-
   IOThread* const io_thread = profile_params->io_thread;
   IOThread::Globals* const io_thread_globals = io_thread->globals();
 
-  chrome_network_delegate->set_predictor(predictor_.get());
-
-  if (domain_reliability_monitor_) {
-    domain_reliability::DomainReliabilityMonitor* monitor =
-        domain_reliability_monitor_.get();
-    monitor->InitURLRequestContext(main_context);
-    monitor->AddBakedInConfigs();
-    monitor->SetDiscardUploads(!GetMetricsEnabledStateOnIOThread());
-    chrome_network_delegate->set_domain_reliability_monitor(monitor);
-  }
-
-  ApplyProfileParamsToContext(main_context);
+  ApplyProfileParamsToContext(context_builder);
 
   if (http_server_properties_manager_)
     http_server_properties_manager_->InitializeOnNetworkThread();
 
-  main_context->set_transport_security_state(transport_security_state());
+  context_builder->set_net_log_unowned(io_thread->net_log());
 
-  main_context->set_net_log(io_thread->net_log());
+  // The context receives a WeakPtr to the server properties.
+  // TODO(wjmaclean): presumably this value gets copied to other contexts ...
+  // it would be nice to avoid this.
+  context_builder->set_http_server_properties(http_server_properties());
 
-  network_delegate_ = data_reduction_proxy_io_data()->CreateNetworkDelegate(
-      chrome_network_delegate.Pass(), true).Pass();
-
-  main_context->set_network_delegate(network_delegate_.get());
-
-  main_context->set_http_server_properties(http_server_properties());
-
-  main_context->set_host_resolver(
+  context_builder->set_host_resolver_unowned(
       io_thread_globals->host_resolver.get());
-  main_context->set_cert_transparency_verifier(
+  context_builder->set_cert_transparency_verifier_unowned(
       io_thread_globals->cert_transparency_verifier.get());
-  main_context->set_http_auth_handler_factory(
+  context_builder->set_http_auth_handler_factory_unowned(
       io_thread_globals->http_auth_handler_factory.get());
 
-  main_context->set_fraudulent_certificate_reporter(
-      fraudulent_certificate_reporter());
-
-  main_context->set_proxy_service(proxy_service());
+  // TODO(wjmaclean): proxy_service() is currently built with all sorts of stuff
+  // from io_globals, so we'll treat it as an unowned pointer for now.
+  context_builder->set_proxy_service_unowned(proxy_service());
 
   scoped_refptr<net::CookieStore> cookie_store = NULL;
   net::ChannelIDService* channel_id_service = NULL;
 
   // Set up cookie store.
   if (!cookie_store.get()) {
     DCHECK(!lazy_params_->cookie_path.empty());
 
     content::CookieStoreConfig cookie_config(
         lazy_params_->cookie_path,
         lazy_params_->session_cookie_mode,
         lazy_params_->special_storage_policy.get(),
         profile_params->cookie_monster_delegate.get());
     cookie_config.crypto_delegate =
       chrome_browser_net::GetCookieCryptoDelegate();
     cookie_store = content::CreateCookieStore(cookie_config);
   }
 
-  main_context->set_cookie_store(cookie_store.get());
-
   // Set up server bound cert service.
   if (!channel_id_service) {
     DCHECK(!lazy_params_->channel_id_path.empty());
 
     scoped_refptr<QuotaPolicyChannelIDStore> channel_id_db =
         new QuotaPolicyChannelIDStore(
             lazy_params_->channel_id_path,
             BrowserThread::GetBlockingPool()->GetSequencedTaskRunner(
                 BrowserThread::GetBlockingPool()->GetSequenceToken()),
             lazy_params_->special_storage_policy.get());
     channel_id_service = new net::ChannelIDService(
         new net::DefaultChannelIDStore(channel_id_db.get()),
         base::WorkerPool::GetTaskRunner(true));
   }
 
-  set_channel_id_service(channel_id_service);
-  main_context->set_channel_id_service(channel_id_service);
+  context_builder->SetCookieAndChannelIdStores(
+      cookie_store.get(), make_scoped_ptr(channel_id_service));
 
-  scoped_ptr<net::HttpCache> main_cache;
   {
     // TODO(ttuttle): Remove ScopedTracker below once crbug.com/436671 is fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("436671 HttpCache construction"));
     net::HttpCache::DefaultBackend* main_backend =
         new net::HttpCache::DefaultBackend(
             net::DISK_CACHE,
             ChooseCacheBackendType(),
             lazy_params_->cache_path,
             lazy_params_->cache_max_size,
             BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
-    main_cache = CreateMainHttpFactory(profile_params, main_backend);
+    context_builder->set_http_transaction_factory_factory(
+        new ProfileIOData::HttpTransactionFactoryDelegate(this, profile_params,
+                                                          main_backend));
   }
 
-  main_http_factory_.reset(main_cache.release());
-  main_context->set_http_transaction_factory(main_http_factory_.get());
-
 #if !defined(DISABLE_FTP_SUPPORT)
+  // The host_resolver used here should be the same one used for the main
+  // URLResourceContext.
   ftp_factory_.reset(
       new net::FtpNetworkLayer(io_thread_globals->host_resolver.get()));
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
+  chrome_network_delegate->set_predictor(predictor_.get());
+
   scoped_ptr<net::URLRequestJobFactoryImpl> main_job_factory(
       new net::URLRequestJobFactoryImpl());
   InstallProtocolHandlers(main_job_factory.get(), protocol_handlers);
 
   // The data reduction proxy interceptor should be as close to the network
   // as possible.
   request_interceptors.insert(
       request_interceptors.begin(),
       data_reduction_proxy_io_data()->CreateInterceptor().release());
-  main_job_factory_ = SetUpJobFactoryDefaults(
+  scoped_ptr<net::NetworkDelegate> network_delegate =
+      data_reduction_proxy_io_data()->CreateNetworkDelegate(
+          chrome_network_delegate.Pass(), true);
+
+  context_builder->set_job_factory(SetUpJobFactoryDefaults(
       main_job_factory.Pass(),
       request_interceptors.Pass(),
       profile_params->protocol_handler_interceptor.Pass(),
-      main_context->network_delegate(),
-      ftp_factory_.get());
-  main_context->set_job_factory(main_job_factory_.get());
-  main_context->set_network_quality_estimator(
+      network_delegate.get(),
+      ftp_factory_.get()).Pass());
+  // TODO(wjmaclean): make this Pass(), not release().
+  context_builder->set_network_delegate(network_delegate.release());
+  context_builder->set_network_quality_estimator_unowned(
       io_thread_globals->network_quality_estimator.get());
 
 #if defined(ENABLE_EXTENSIONS)
+  // This call initializes the extensions URLRequestContext *independently* of
+  // the, as-yet unbuilt, main URLRequestContext. If that ever changes, then
+  // this should not be called in this function.
   InitializeExtensionsRequestContext(profile_params);
 #endif
 
-  // Setup SDCH for this profile.
-  sdch_manager_.reset(new net::SdchManager);
-  sdch_policy_.reset(new net::SdchOwner(sdch_manager_.get(), main_context));
-  main_context->set_sdch_manager(sdch_manager_.get());
+  // Start setup of SDCH for this profile.
+  context_builder->set_sdch_manager(new net::SdchManager);
+}
+
+void ProfileImplIOData::InitPostContextSetup(
+    ChromeNetworkDelegate* chrome_network_delegate) const {
+  net::URLRequestContext* main_context = main_request_context();
+
+  if (domain_reliability_monitor_) {
+    domain_reliability::DomainReliabilityMonitor* monitor =
+        domain_reliability_monitor_.get();
+    monitor->InitURLRequestContext(main_context);
+    monitor->AddBakedInConfigs();
+    monitor->SetDiscardUploads(!GetMetricsEnabledStateOnIOThread());
+    chrome_network_delegate->set_domain_reliability_monitor(monitor);
+  }
+
+  // Finish setup of SDCH for this profile.
+  sdch_policy_.reset(
+      new net::SdchOwner(main_context->sdch_manager(), main_context));
   if (ShouldUseSdchPersistence()) {
     sdch_policy_->EnablePersistentStorage(network_json_store_.get());
   }
 
   // Create a media request context based on the main context, but using a
   // media cache.  It shares the same job factory as the main context.
   StoragePartitionDescriptor details(profile_path_, false);
   media_request_context_.reset(InitializeMediaRequestContext(main_context,
                                                              details));
 
+  // lazy_params_ are last used in InitializeMediaRequestContext().
   lazy_params_.reset();
 }
 
 void ProfileImplIOData::
     InitializeExtensionsRequestContext(ProfileParams* profile_params) const {
   net::URLRequestContext* extensions_context = extensions_request_context();
   IOThread* const io_thread = profile_params->io_thread;
   ApplyProfileParamsToContext(extensions_context);
 
   extensions_context->set_transport_security_state(transport_security_state());
@@ skipping 55 matching lines @@
   if (partition_descriptor.in_memory) {
     app_backend = net::HttpCache::DefaultBackend::InMemory(0);
   } else {
     app_backend = new net::HttpCache::DefaultBackend(
         net::DISK_CACHE,
         ChooseCacheBackendType(),
         cache_path,
         app_cache_max_size_,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
   }
+  DCHECK(main_context->storage());
   net::HttpNetworkSession* main_network_session =
-      main_http_factory_->GetSession();
+      main_context->storage()->http_transaction_factory()->GetSession();
   scoped_ptr<net::HttpCache> app_http_cache =
       CreateHttpFactory(main_network_session, app_backend);
 
   scoped_refptr<net::CookieStore> cookie_store = NULL;
   if (partition_descriptor.in_memory) {
     cookie_store = content::CreateCookieStore(content::CookieStoreConfig());
   }
 
   // Use an app-specific cookie store.
   if (!cookie_store.get()) {
@@ skipping 61 matching lines @@
   }
 
   // Use a separate HTTP disk cache for isolated apps.
   net::HttpCache::BackendFactory* media_backend =
       new net::HttpCache::DefaultBackend(
           net::MEDIA_CACHE,
           ChooseCacheBackendType(),
           cache_path,
           cache_max_size,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+  DCHECK(original_context->storage());
   net::HttpNetworkSession* main_network_session =
-      main_http_factory_->GetSession();
+      original_context->storage()->http_transaction_factory()->GetSession();
   scoped_ptr<net::HttpCache> media_http_cache =
       CreateHttpFactory(main_network_session, media_backend);
 
   // Transfer ownership of the cache to MediaRequestContext.
   context->SetHttpTransactionFactory(media_http_cache.Pass());
 
   // Note that we do not create a new URLRequestJobFactory because
   // the media context should behave exactly like its parent context
   // in all respects except for cache behavior on media subresources.
   // The CopyFrom() step above means that our media context will use
@@ skipping 42 matching lines @@
     const base::Closure& completion) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized());
 
   DCHECK(transport_security_state());
   // Completes synchronously.
   transport_security_state()->DeleteAllDynamicDataSince(time);
   DCHECK(http_server_properties_manager_);
   http_server_properties_manager_->Clear(completion);
 }