Switch to using URLRequestContextBuilder to create some URLRequestContexts.

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/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.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/transport_security_persister.h"
 #include "net/http/transport_security_state.h"
-#include "net/proxy/proxy_service.h"
+#include "net/ssl/default_server_bound_cert_store.h"
+#include "net/ssl/server_bound_cert_service.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_job_factory_impl.h"
+#include "net/url_request/url_request_throttler_manager.h"
 
 #if !defined(DISABLE_FILE_SUPPORT)
 #include "net/url_request/file_protocol_handler.h"
 #endif
 
 #if !defined(DISABLE_FTP_SUPPORT)
 #include "net/url_request/ftp_protocol_handler.h"
 #endif
 
 namespace net {
@@ skipping 63 matching lines @@
                               CookieOptions* options) OVERRIDE {
     return true;
   }
 
   virtual bool OnCanAccessFile(const net::URLRequest& request,
                                const base::FilePath& path) const OVERRIDE {
     return true;
   }
 
   virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
-    return false;
+    // Returning true will only enable throttling if there's also a
+    // URLRequestThrottlerManager, which there isn't, by default.
+    return true;
   }
 
   virtual int OnBeforeSocketStreamConnect(
       SocketStream* stream,
       const CompletionCallback& callback) OVERRIDE {
     return OK;
   }
 
   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 };
 
 class BasicURLRequestContext : public URLRequestContext {
  public:
   BasicURLRequestContext()
       : storage_(this) {}
 
   URLRequestContextStorage* storage() {
     return &storage_;
   }
 
   base::Thread* GetCacheThread() {
     if (!cache_thread_) {
-      cache_thread_.reset(new base::Thread("Cache Thread"));
+      cache_thread_.reset(new base::Thread("Network cache Thread"));

[mef, 2014/06/30 21:42:59]

nit: a bit strange that second word is not capitalized, but third one is.

[mmenke, 2014/06/30 21:55:25]

Done.

       cache_thread_->StartWithOptions(
           base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
     }
     return cache_thread_.get();
   }
 
   base::Thread* GetFileThread() {
     if (!file_thread_) {
-      file_thread_.reset(new base::Thread("File Thread"));
+      file_thread_.reset(new base::Thread("Network file Thread"));
       file_thread_->StartWithOptions(
           base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0));
     }
     return file_thread_.get();
   }
 
+  void set_transport_security_persister(
+      scoped_ptr<TransportSecurityPersister> transport_security_persister) {
+    transport_security_persister = transport_security_persister.Pass();
+  }
+
  protected:
   virtual ~BasicURLRequestContext() {}
 
  private:
+  // Threads should be torn down last.
   scoped_ptr<base::Thread> cache_thread_;
   scoped_ptr<base::Thread> file_thread_;
+
   URLRequestContextStorage storage_;
+  scoped_ptr<TransportSecurityPersister> transport_security_persister_;
+
   DISALLOW_COPY_AND_ASSIGN(BasicURLRequestContext);
 };
 
 }  // namespace
 
 URLRequestContextBuilder::HttpCacheParams::HttpCacheParams()
     : type(IN_MEMORY),
       max_size(0) {}
 URLRequestContextBuilder::HttpCacheParams::~HttpCacheParams() {}
 
@@ skipping 24 matching lines @@
       file_enabled_(false),
 #endif
 #if !defined(DISABLE_FTP_SUPPORT)
       ftp_enabled_(false),
 #endif
       http_cache_enabled_(true) {
 }
 
 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 
-void URLRequestContextBuilder::set_proxy_config_service(
-    ProxyConfigService* proxy_config_service) {
-  proxy_config_service_.reset(proxy_config_service);
+void URLRequestContextBuilder::EnableHttpCache(const HttpCacheParams& params) {
+  http_cache_enabled_ = true;
+  http_cache_params_ = params;
+}
+
+void URLRequestContextBuilder::DisableHttpCache() {
+  http_cache_enabled_ = false;
+  http_cache_params_ = HttpCacheParams();
 }
 
 void URLRequestContextBuilder::SetSpdyAndQuicEnabled(bool spdy_enabled,
                                                      bool quic_enabled) {
   http_network_session_params_.next_protos =
       NextProtosWithSpdyAndQuic(spdy_enabled, quic_enabled);
 }
 
 URLRequestContext* URLRequestContextBuilder::Build() {
   BasicURLRequestContext* context = new BasicURLRequestContext;
   URLRequestContextStorage* storage = context->storage();
 
   storage->set_http_user_agent_settings(new StaticHttpUserAgentSettings(
       accept_language_, user_agent_));
 
   if (!network_delegate_)
     network_delegate_.reset(new BasicNetworkDelegate);
   NetworkDelegate* network_delegate = network_delegate_.release();
   storage->set_network_delegate(network_delegate);
 
-  if (!host_resolver_)
-    host_resolver_ = net::HostResolver::CreateDefaultResolver(NULL);
+  if (net_log_) {
+    storage->set_net_log(net_log_.release());
+  } else {
+    storage->set_net_log(new net::NetLog);
+  }
+
+  if (!host_resolver_) {
+    host_resolver_ = net::HostResolver::CreateDefaultResolver(
+        context->net_log());
+  }
   storage->set_host_resolver(host_resolver_.Pass());
 
-  storage->set_net_log(new net::NetLog);
+  if (!proxy_service_) {
+    // TODO(willchan): Switch to using this code when
+    // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck.
+  #if defined(OS_LINUX) || defined(OS_ANDROID)
+    ProxyConfigService* proxy_config_service = proxy_config_service_.release();
+  #else
+    ProxyConfigService* proxy_config_service = NULL;
+    if (proxy_config_service_) {
+      proxy_config_service = proxy_config_service_.release();
+    } else {
+      proxy_config_service =
+          ProxyService::CreateSystemProxyConfigService(
+              base::ThreadTaskRunnerHandle::Get().get(),
+              context->GetFileThread()->message_loop());
+    }
+  #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
+    proxy_service_.reset(
+        ProxyService::CreateUsingSystemProxyResolver(
+            proxy_config_service,
+            0,  // This results in using the default value.
+            context->net_log()));
+  }
+  storage->set_proxy_service(proxy_service_.release());
 
-  // TODO(willchan): Switch to using this code when
-  // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck.
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-  ProxyConfigService* proxy_config_service = proxy_config_service_.release();
-#else
-  ProxyConfigService* proxy_config_service = NULL;
-  if (proxy_config_service_) {
-    proxy_config_service = proxy_config_service_.release();
-  } else {
-    proxy_config_service =
-        ProxyService::CreateSystemProxyConfigService(
-            base::ThreadTaskRunnerHandle::Get().get(),
-            context->GetFileThread()->message_loop());
-  }
-#endif  // defined(OS_LINUX) || defined(OS_ANDROID)
-  storage->set_proxy_service(
-      ProxyService::CreateUsingSystemProxyResolver(
-          proxy_config_service,
-          4,  // TODO(willchan): Find a better constant somewhere.
-          context->net_log()));
   storage->set_ssl_config_service(new net::SSLConfigServiceDefaults);
   HttpAuthHandlerRegistryFactory* http_auth_handler_registry_factory =
       net::HttpAuthHandlerRegistryFactory::CreateDefault(
            context->host_resolver());
   for (size_t i = 0; i < extra_http_auth_handlers_.size(); ++i) {
     http_auth_handler_registry_factory->RegisterSchemeFactory(
         extra_http_auth_handlers_[i].scheme,
         extra_http_auth_handlers_[i].factory);
   }
   storage->set_http_auth_handler_factory(http_auth_handler_registry_factory);
   storage->set_cookie_store(new CookieMonster(NULL, NULL));
+
+  // TODO(mmenke):  This always creates a file thread, even when it ends up
+  // not being used.  Consider lazily creating the thread.
+  storage->set_server_bound_cert_service(
+      new ServerBoundCertService(
+          new DefaultServerBoundCertStore(NULL),
+          context->GetFileThread()->message_loop_proxy()));

[mmenke, 2014/06/25 18:56:47]

This is a behavior change, but it sounds like we should be doing this everywhere
anyways.

+
   storage->set_transport_security_state(new net::TransportSecurityState());
+  if (!transport_security_persister_path_.empty()) {
+    context->set_transport_security_persister(
+        make_scoped_ptr<TransportSecurityPersister>(
+            new TransportSecurityPersister(
+                context->transport_security_state(),
+                transport_security_persister_path_,
+                context->GetFileThread()->message_loop_proxy(),
+                false)));
+  }
+
   storage->set_http_server_properties(
       scoped_ptr<net::HttpServerProperties>(
           new net::HttpServerPropertiesImpl()));
   storage->set_cert_verifier(CertVerifier::CreateDefault());
 
+  if (throttling_enabled_)
+    storage->set_throttler_manager(new URLRequestThrottlerManager());
+
   net::HttpNetworkSession::Params network_session_params;
   network_session_params.host_resolver = context->host_resolver();
   network_session_params.cert_verifier = context->cert_verifier();
   network_session_params.transport_security_state =
       context->transport_security_state();
   network_session_params.proxy_service = context->proxy_service();
   network_session_params.ssl_config_service =
       context->ssl_config_service();
   network_session_params.http_auth_handler_factory =
       context->http_auth_handler_factory();
@@ skipping 65 matching lines @@
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
   storage->set_job_factory(job_factory);
 
   // TODO(willchan): Support sdch.
 
   return context;
 }
 
 }  // namespace net