net/url_request/url_request_context_builder.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/url_request/url_request_context_builder.h"
   6
   7 #include <string>
   8
   9 #include "base/basictypes.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/logging.h"
  12 #include "base/strings/string_util.h"
  13 #include "base/thread_task_runner_handle.h"
  14 #include "base/threading/thread.h"
  15 #include "net/base/cache_type.h"
  16 #include "net/base/net_errors.h"
  17 #include "net/base/network_delegate.h"
  18 #include "net/cert/cert_verifier.h"
  19 #include "net/cookies/cookie_monster.h"
  20 #include "net/dns/host_resolver.h"
  21 #include "net/ftp/ftp_network_layer.h"
  22 #include "net/http/http_auth_handler_factory.h"
  23 #include "net/http/http_cache.h"
  24 #include "net/http/http_network_layer.h"
  25 #include "net/http/http_network_session.h"
  26 #include "net/http/http_server_properties_impl.h"
  27 #include "net/http/transport_security_state.h"
  28 #include "net/proxy/proxy_service.h"
  29 #include "net/ssl/ssl_config_service_defaults.h"
  30 #include "net/url_request/data_protocol_handler.h"
  31 #include "net/url_request/static_http_user_agent_settings.h"
  32 #include "net/url_request/url_request_context.h"
  33 #include "net/url_request/url_request_context_storage.h"
  34 #include "net/url_request/url_request_job_factory_impl.h"
  35
  36 #if !defined(DISABLE_FILE_SUPPORT)
  37 #include "net/url_request/file_protocol_handler.h"
  38 #endif
  39
  40 #if !defined(DISABLE_FTP_SUPPORT)
  41 #include "net/url_request/ftp_protocol_handler.h"
  42 #endif
  43
  44 namespace net {
  45
  46 namespace {
  47
  48 class BasicNetworkDelegate : public NetworkDelegate {
  49  public:
  50   BasicNetworkDelegate() {}
  51   virtual ~BasicNetworkDelegate() {}
  52
  53  private:
  54   virtual int OnBeforeURLRequest(URLRequest* request,
  55                                  const CompletionCallback& callback,
  56                                  GURL* new_url) OVERRIDE {
  57     return OK;
  58   }
  59
  60   virtual int OnBeforeSendHeaders(URLRequest* request,
  61                                   const CompletionCallback& callback,
  62                                   HttpRequestHeaders* headers) OVERRIDE {
  63     return OK;
  64   }
  65
  66   virtual void OnSendHeaders(URLRequest* request,
  67                              const HttpRequestHeaders& headers) OVERRIDE {}
  68
  69   virtual int OnHeadersReceived(
  70       URLRequest* request,
  71       const CompletionCallback& callback,
  72       const HttpResponseHeaders* original_response_headers,
  73       scoped_refptr<HttpResponseHeaders>* override_response_headers,
  74       GURL* allowed_unsafe_redirect_url) OVERRIDE {
  75     return OK;
  76   }
  77
  78   virtual void OnBeforeRedirect(URLRequest* request,
  79                                 const GURL& new_location) OVERRIDE {}
  80
  81   virtual void OnResponseStarted(URLRequest* request) OVERRIDE {}
  82
  83   virtual void OnRawBytesRead(const URLRequest& request,
  84                               int bytes_read) OVERRIDE {}
  85
  86   virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE {}
  87
  88   virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE {}
  89
  90   virtual void OnPACScriptError(int line_number,
  91                                 const base::string16& error) OVERRIDE {}
  92
  93   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
  94       URLRequest* request,
  95       const AuthChallengeInfo& auth_info,
  96       const AuthCallback& callback,
  97       AuthCredentials* credentials) OVERRIDE {
  98     return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
  99   }
 100
 101   virtual bool OnCanGetCookies(const URLRequest& request,
 102                                const CookieList& cookie_list) OVERRIDE {
 103     return true;
 104   }
 105
 106   virtual bool OnCanSetCookie(const URLRequest& request,
 107                               const std::string& cookie_line,
 108                               CookieOptions* options) OVERRIDE {
 109     return true;
 110   }
 111
 112   virtual bool OnCanAccessFile(const net::URLRequest& request,
 113                                const base::FilePath& path) const OVERRIDE {
 114     return true;
 115   }
 116
 117   virtual bool OnCanThrottleRequest(const URLRequest& request) const OVERRIDE {
 118     return false;
 119   }
 120
 121   virtual int OnBeforeSocketStreamConnect(
 122       SocketStream* stream,
 123       const CompletionCallback& callback) OVERRIDE {
 124     return OK;
 125   }
 126
 127   DISALLOW_COPY_AND_ASSIGN(BasicNetworkDelegate);
 128 };
 129
 130 class BasicURLRequestContext : public URLRequestContext {
 131  public:
 132   BasicURLRequestContext()
 133       : storage_(this) {}
 134
 135   URLRequestContextStorage* storage() {
 136     return &storage_;
 137   }
 138
 139   base::Thread* GetCacheThread() {
 140     if (!cache_thread_) {
 141       cache_thread_.reset(new base::Thread("Cache Thread"));
 142       cache_thread_->StartWithOptions(
 143           base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
 144     }
 145     return cache_thread_.get();
 146   }
 147
 148   base::Thread* GetFileThread() {
 149     if (!file_thread_) {
 150       file_thread_.reset(new base::Thread("File Thread"));
 151       file_thread_->StartWithOptions(
 152           base::Thread::Options(base::MessageLoop::TYPE_DEFAULT, 0));
 153     }
 154     return file_thread_.get();
 155   }
 156
 157  protected:
 158   virtual ~BasicURLRequestContext() {}
 159
 160  private:
 161   scoped_ptr<base::Thread> cache_thread_;
 162   scoped_ptr<base::Thread> file_thread_;
 163   URLRequestContextStorage storage_;
 164   DISALLOW_COPY_AND_ASSIGN(BasicURLRequestContext);
 165 };
 166
 167 }  // namespace
 168
 169 URLRequestContextBuilder::HttpCacheParams::HttpCacheParams()
 170     : type(IN_MEMORY),
 171       max_size(0) {}
 172 URLRequestContextBuilder::HttpCacheParams::~HttpCacheParams() {}
 173
 174 URLRequestContextBuilder::HttpNetworkSessionParams::HttpNetworkSessionParams()
 175     : ignore_certificate_errors(false),
 176       host_mapping_rules(NULL),
 177       http_pipelining_enabled(false),
 178       testing_fixed_http_port(0),
 179       testing_fixed_https_port(0),
 180       trusted_spdy_proxy() {}
 181
 182 URLRequestContextBuilder::HttpNetworkSessionParams::~HttpNetworkSessionParams()
 183 {}
 184
 185 URLRequestContextBuilder::SchemeFactory::SchemeFactory(
 186     const std::string& auth_scheme,
 187     net::HttpAuthHandlerFactory* auth_handler_factory)
 188     : scheme(auth_scheme), factory(auth_handler_factory) {
 189 }
 190
 191 URLRequestContextBuilder::SchemeFactory::~SchemeFactory() {
 192 }
 193
 194 URLRequestContextBuilder::URLRequestContextBuilder()
 195     : data_enabled_(false),
 196 #if !defined(DISABLE_FILE_SUPPORT)
 197       file_enabled_(false),
 198 #endif
 199 #if !defined(DISABLE_FTP_SUPPORT)
 200       ftp_enabled_(false),
 201 #endif
 202       http_cache_enabled_(true) {
 203 }
 204
 205 URLRequestContextBuilder::~URLRequestContextBuilder() {}
 206
 207 void URLRequestContextBuilder::set_proxy_config_service(
 208     ProxyConfigService* proxy_config_service) {
 209   proxy_config_service_.reset(proxy_config_service);
 210 }
 211
 212 URLRequestContext* URLRequestContextBuilder::Build() {
 213   BasicURLRequestContext* context = new BasicURLRequestContext;
 214   URLRequestContextStorage* storage = context->storage();
 215
 216   storage->set_http_user_agent_settings(new StaticHttpUserAgentSettings(
 217       accept_language_, user_agent_));
 218
 219   if (!network_delegate_)
 220     network_delegate_.reset(new BasicNetworkDelegate);
 221   NetworkDelegate* network_delegate = network_delegate_.release();
 222   storage->set_network_delegate(network_delegate);
 223
 224   if (!host_resolver_)
 225     host_resolver_ = net::HostResolver::CreateDefaultResolver(NULL);
 226   storage->set_host_resolver(host_resolver_.Pass());
 227
 228   storage->set_net_log(new net::NetLog);
 229
 230   // TODO(willchan): Switch to using this code when
 231   // ProxyService::CreateSystemProxyConfigService()'s signature doesn't suck.
 232 #if defined(OS_LINUX) || defined(OS_ANDROID)
 233   ProxyConfigService* proxy_config_service = proxy_config_service_.release();
 234 #else
 235   ProxyConfigService* proxy_config_service = NULL;
 236   if (proxy_config_service_) {
 237     proxy_config_service = proxy_config_service_.release();
 238   } else {
 239     proxy_config_service =
 240         ProxyService::CreateSystemProxyConfigService(
 241             base::ThreadTaskRunnerHandle::Get().get(),
 242             context->GetFileThread()->message_loop());
 243   }
 244 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 245   storage->set_proxy_service(
 246       ProxyService::CreateUsingSystemProxyResolver(
 247           proxy_config_service,
 248           4,  // TODO(willchan): Find a better constant somewhere.
 249           context->net_log()));
 250   storage->set_ssl_config_service(new net::SSLConfigServiceDefaults);
 251   HttpAuthHandlerRegistryFactory* http_auth_handler_registry_factory =
 252       net::HttpAuthHandlerRegistryFactory::CreateDefault(
 253            context->host_resolver());
 254   for (size_t i = 0; i < extra_http_auth_handlers_.size(); ++i) {
 255     http_auth_handler_registry_factory->RegisterSchemeFactory(
 256         extra_http_auth_handlers_[i].scheme,
 257         extra_http_auth_handlers_[i].factory);
 258   }
 259   storage->set_http_auth_handler_factory(http_auth_handler_registry_factory);
 260   storage->set_cookie_store(new CookieMonster(NULL, NULL));
 261   storage->set_transport_security_state(new net::TransportSecurityState());
 262   storage->set_http_server_properties(
 263       scoped_ptr<net::HttpServerProperties>(
 264           new net::HttpServerPropertiesImpl()));
 265   storage->set_cert_verifier(CertVerifier::CreateDefault());
 266
 267   net::HttpNetworkSession::Params network_session_params;
 268   network_session_params.host_resolver = context->host_resolver();
 269   network_session_params.cert_verifier = context->cert_verifier();
 270   network_session_params.transport_security_state =
 271       context->transport_security_state();
 272   network_session_params.proxy_service = context->proxy_service();
 273   network_session_params.ssl_config_service =
 274       context->ssl_config_service();
 275   network_session_params.http_auth_handler_factory =
 276       context->http_auth_handler_factory();
 277   network_session_params.network_delegate = network_delegate;
 278   network_session_params.http_server_properties =
 279       context->http_server_properties();
 280   network_session_params.net_log = context->net_log();
 281   network_session_params.ignore_certificate_errors =
 282       http_network_session_params_.ignore_certificate_errors;
 283   network_session_params.host_mapping_rules =
 284       http_network_session_params_.host_mapping_rules;
 285   network_session_params.http_pipelining_enabled =
 286       http_network_session_params_.http_pipelining_enabled;
 287   network_session_params.testing_fixed_http_port =
 288       http_network_session_params_.testing_fixed_http_port;
 289   network_session_params.testing_fixed_https_port =
 290       http_network_session_params_.testing_fixed_https_port;
 291   network_session_params.trusted_spdy_proxy =
 292       http_network_session_params_.trusted_spdy_proxy;
 293
 294   HttpTransactionFactory* http_transaction_factory = NULL;
 295   if (http_cache_enabled_) {
 296     network_session_params.server_bound_cert_service =
 297         context->server_bound_cert_service();
 298     HttpCache::BackendFactory* http_cache_backend = NULL;
 299     if (http_cache_params_.type == HttpCacheParams::DISK) {
 300       http_cache_backend = new HttpCache::DefaultBackend(
 301           DISK_CACHE,
 302           net::CACHE_BACKEND_DEFAULT,
 303           http_cache_params_.path,
 304           http_cache_params_.max_size,
 305           context->GetCacheThread()->message_loop_proxy().get());
 306     } else {
 307       http_cache_backend =
 308           HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
 309     }
 310
 311     http_transaction_factory = new HttpCache(
 312         network_session_params, http_cache_backend);
 313   } else {
 314     scoped_refptr<net::HttpNetworkSession> network_session(
 315         new net::HttpNetworkSession(network_session_params));
 316
 317     http_transaction_factory = new HttpNetworkLayer(network_session.get());
 318   }
 319   storage->set_http_transaction_factory(http_transaction_factory);
 320
 321   URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl;
 322   if (data_enabled_)
 323     job_factory->SetProtocolHandler("data", new DataProtocolHandler);
 324
 325 #if !defined(DISABLE_FILE_SUPPORT)
 326   if (file_enabled_) {
 327     job_factory->SetProtocolHandler(
 328     "file",
 329     new FileProtocolHandler(context->GetFileThread()->message_loop_proxy()));
 330   }
 331 #endif  // !defined(DISABLE_FILE_SUPPORT)
 332
 333 #if !defined(DISABLE_FTP_SUPPORT)
 334   if (ftp_enabled_) {
 335     ftp_transaction_factory_.reset(
 336         new FtpNetworkLayer(context->host_resolver()));
 337     job_factory->SetProtocolHandler("ftp",
 338         new FtpProtocolHandler(ftp_transaction_factory_.get()));
 339   }
 340 #endif  // !defined(DISABLE_FTP_SUPPORT)
 341
 342   storage->set_job_factory(job_factory);
 343
 344   // TODO(willchan): Support sdch.
 345
 346   return context;
 347 }
 348
 349 }  // namespace net