Refactor main URLRequestContext creation to use URLRequestContextBuilder

net/url_request/url_request_context_builder.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 "net/url_request/url_request_context_builder.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/base/sdch_manager.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/dns/host_resolver.h"
 #include "net/ftp/ftp_network_layer.h"
 #include "net/http/http_auth_handler_factory.h"
 #include "net/http/http_cache.h"
 #include "net/http/http_network_layer.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
+#include "net/http/http_transaction_factory.h"
 #include "net/http/transport_security_persister.h"
 #include "net/http/transport_security_state.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.h"
 #include "net/url_request/data_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_storage.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
@@ skipping 83 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 };
 
 class BasicURLRequestContext : public URLRequestContext {
  public:
   explicit BasicURLRequestContext(
       const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
       : file_task_runner_(file_task_runner), storage_(this) {}
 
-  URLRequestContextStorage* storage() {
+  URLRequestContextStorage* storage() override {
     return &storage_;
   }
 
   scoped_refptr<base::SingleThreadTaskRunner>& GetFileTaskRunner() {
     // Create a new thread to run file tasks, if needed.
     if (!file_task_runner_) {
       DCHECK(!file_thread_);
       file_thread_.reset(new base::Thread("Network File Thread"));
       file_thread_->StartWithOptions(
           base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0));
@@ skipping 53 matching lines @@
 URLRequestContextBuilder::URLRequestContextBuilder()
     : data_enabled_(false),
 #if !defined(DISABLE_FILE_SUPPORT)
       file_enabled_(false),
 #endif
 #if !defined(DISABLE_FTP_SUPPORT)
       ftp_enabled_(false),
 #endif
       http_cache_enabled_(true),
       throttling_enabled_(false),
-      sdch_enabled_(false) {
+      sdch_enabled_(false),
+      net_log_unowned_(nullptr),
+      http_user_agent_settings_unowned_(nullptr),
+      host_resolver_unowned_(nullptr),
+      cert_transparency_verifier_unowned_(nullptr),
+      http_auth_handler_factory_unowned_(nullptr),
+      network_quality_estimator_unowned_(nullptr),
+      proxy_service_unowned_(nullptr) {
 }
 
 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 
 void URLRequestContextBuilder::EnableHttpCache(const HttpCacheParams& params) {
   http_cache_enabled_ = true;
   http_cache_params_ = params;
 }
 
 void URLRequestContextBuilder::DisableHttpCache() {
@@ skipping 19 matching lines @@
   DCHECK(cookie_store);
   cookie_store_ = cookie_store;
   channel_id_service_ = channel_id_service.Pass();
 }
 
 void URLRequestContextBuilder::SetFileTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   file_task_runner_ = task_runner;
 }
 
+void URLRequestContextBuilder::set_sdch_manager(SdchManager* manager) {
+  sdch_manager_.reset(manager);
+}
+
+void URLRequestContextBuilder::set_job_factory(
+    scoped_ptr<URLRequestJobFactory> factory) {
+  job_factory_ = factory.Pass();
+}
+
+URLRequestContext* URLRequestContextBuilder::BuildMainContext() {
+  BasicURLRequestContext* context =
+      new BasicURLRequestContext(file_task_runner_);
+  URLRequestContextStorage* storage = context->storage();
+
+  // The ordering of the code in this function is important. For example,
+  // the HttpTransactionFactory cannot be created before setting the
+  // CertVerifier.
+  // Do not change the ordering unless you are sure you know what depends on
+  // what.
+  // TODO(wjmaclean): Can this function provide default creation of the
+  // various elements in a manner that would work for a main context?
+  if (fraudulent_certificate_reporter_factory_) {
+    storage->set_fraudulent_certificate_reporter(
+        fraudulent_certificate_reporter_factory_->Create(context));
+  } else {
+    NOTIMPLEMENTED();
+  }
+
+  if (cert_verifier_delegate_)
+    context->set_cert_verifier(cert_verifier_delegate_->Get(context));
+  else
+    NOTIMPLEMENTED();
+
+  if (transport_security_state_.get())
+    storage->set_transport_security_state(transport_security_state_.release());
+  else
+    NOTIMPLEMENTED();
+
+  if (http_user_agent_settings_unowned_)
+    context->set_http_user_agent_settings(http_user_agent_settings_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  if (ssl_config_service_)
+    context->set_ssl_config_service(ssl_config_service_.get());
+  else
+    NOTIMPLEMENTED();
+
+  if (net_log_unowned_)
+    context->set_net_log(net_log_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  if (network_delegate_)
+    storage->set_network_delegate(network_delegate_.release());
+  else
+    NOTIMPLEMENTED();
+
+  if (http_server_properties_)
+    context->set_http_server_properties(http_server_properties_);
+  else
+    NOTIMPLEMENTED();
+
+  if (host_resolver_unowned_)
+    context->set_host_resolver(host_resolver_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  if (cert_transparency_verifier_unowned_)
+    context->set_cert_transparency_verifier(cert_transparency_verifier_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  if (http_auth_handler_factory_unowned_)
+    context->set_http_auth_handler_factory(http_auth_handler_factory_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  if (proxy_service_unowned_)
+    context->set_proxy_service(proxy_service_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  if (cookie_store_) {
+    storage->set_cookie_store(cookie_store_.get());
+    storage->set_channel_id_service(channel_id_service_.Pass());
+  } else {
+    NOTIMPLEMENTED();
+  }
+
+
+  if (http_transaction_factory_factory_) {
+    storage->set_http_transaction_factory(
+        http_transaction_factory_factory_->Create(context));
+  } else {
+    NOTIMPLEMENTED();
+  }
+
+  if (sdch_manager_)
+    storage->set_sdch_manager(sdch_manager_.Pass());
+  else
+    NOTIMPLEMENTED();
+
+  if (job_factory_)
+    storage->set_job_factory(job_factory_.release());
+  else
+    NOTIMPLEMENTED();
+
+
+  if (network_quality_estimator_unowned_)
+    context->set_network_quality_estimator(network_quality_estimator_unowned_);
+  else
+    NOTIMPLEMENTED();
+
+  return context;
+}
+
 URLRequestContext* URLRequestContextBuilder::Build() {
   BasicURLRequestContext* context =
       new BasicURLRequestContext(file_task_runner_);
   URLRequestContextStorage* storage = context->storage();
 
   storage->set_http_user_agent_settings(new StaticHttpUserAgentSettings(
       accept_language_, user_agent_));
 
   if (!network_delegate_)
     network_delegate_.reset(new BasicNetworkDelegate);
@@ skipping 165 matching lines @@
     }
     url_request_interceptors_.weak_clear();
   }
   storage->set_job_factory(top_job_factory.release());
   // TODO(willchan): Support sdch.
 
   return context;
 }
 
 }  // namespace net