net/url_request/url_request_context.h

   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 // This class represents contextual information (cookies, cache, etc.)
   6 // that's useful when processing resource requests.
   7 // The class is reference-counted so that it can be cleaned up after any
   8 // requests that are using it have been completed.
   9
  10 #ifndef NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
  11 #define NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_
  12
  13 #include <set>
  14 #include <string>
  15
  16 #include "base/memory/ref_counted.h"
  17 #include "base/memory/scoped_ptr.h"
  18 #include "base/memory/weak_ptr.h"
  19 #include "base/threading/non_thread_safe.h"
  20 #include "net/base/net_export.h"
  21 #include "net/base/net_log.h"
  22 #include "net/base/request_priority.h"
  23 #include "net/http/http_network_session.h"
  24 #include "net/http/http_server_properties.h"
  25 #include "net/http/transport_security_state.h"
  26 #include "net/ssl/ssl_config_service.h"
  27 #include "net/url_request/url_request.h"
  28
  29 namespace net {
  30 class CertVerifier;
  31 class CookieStore;
  32 class CTVerifier;
  33 class FraudulentCertificateReporter;
  34 class HostResolver;
  35 class HttpAuthHandlerFactory;
  36 class HttpTransactionFactory;
  37 class HttpUserAgentSettings;
  38 class NetworkDelegate;
  39 class ServerBoundCertService;
  40 class ProxyService;
  41 class URLRequest;
  42 class URLRequestJobFactory;
  43 class URLRequestThrottlerManager;
  44
  45 // Subclass to provide application-specific context for URLRequest
  46 // instances. Note that URLRequestContext typically does not provide storage for
  47 // these member variables, since they may be shared. For the ones that aren't
  48 // shared, URLRequestContextStorage can be helpful in defining their storage.
  49 class NET_EXPORT URLRequestContext
  50     : NON_EXPORTED_BASE(public base::NonThreadSafe) {
  51  public:
  52   URLRequestContext();
  53   virtual ~URLRequestContext();
  54
  55   // Copies the state from |other| into this context.
  56   void CopyFrom(const URLRequestContext* other);
  57
  58   // May return NULL if this context doesn't have an associated network session.
  59   const HttpNetworkSession::Params* GetNetworkSessionParams() const;
  60
  61   // Creates a URLRequest. |cookie_store| optionally specifies a cookie store
  62   // to be used rather than the one represented by the context, or NULL
  63   // otherwise.
  64   scoped_ptr<URLRequest> CreateRequest(const GURL& url,
  65                                        RequestPriority priority,
  66                                        URLRequest::Delegate* delegate,
  67                                        CookieStore* cookie_store) const;
  68
  69   NetLog* net_log() const {
  70     return net_log_;
  71   }
  72
  73   void set_net_log(NetLog* net_log) {
  74     net_log_ = net_log;
  75   }
  76
  77   HostResolver* host_resolver() const {
  78     return host_resolver_;
  79   }
  80
  81   void set_host_resolver(HostResolver* host_resolver) {
  82     host_resolver_ = host_resolver;
  83   }
  84
  85   CertVerifier* cert_verifier() const {
  86     return cert_verifier_;
  87   }
  88
  89   void set_cert_verifier(CertVerifier* cert_verifier) {
  90     cert_verifier_ = cert_verifier;
  91   }
  92
  93   ServerBoundCertService* server_bound_cert_service() const {
  94     return server_bound_cert_service_;
  95   }
  96
  97   void set_server_bound_cert_service(
  98       ServerBoundCertService* server_bound_cert_service) {
  99     server_bound_cert_service_ = server_bound_cert_service;
 100   }
 101
 102   FraudulentCertificateReporter* fraudulent_certificate_reporter() const {
 103     return fraudulent_certificate_reporter_;
 104   }
 105   void set_fraudulent_certificate_reporter(
 106       FraudulentCertificateReporter* fraudulent_certificate_reporter) {
 107     fraudulent_certificate_reporter_ = fraudulent_certificate_reporter;
 108   }
 109
 110   // Get the proxy service for this context.
 111   ProxyService* proxy_service() const { return proxy_service_; }
 112   void set_proxy_service(ProxyService* proxy_service) {
 113     proxy_service_ = proxy_service;
 114   }
 115
 116   // Get the ssl config service for this context.
 117   SSLConfigService* ssl_config_service() const {
 118     return ssl_config_service_.get();
 119   }
 120   void set_ssl_config_service(SSLConfigService* service) {
 121     ssl_config_service_ = service;
 122   }
 123
 124   // Gets the HTTP Authentication Handler Factory for this context.
 125   // The factory is only valid for the lifetime of this URLRequestContext
 126   HttpAuthHandlerFactory* http_auth_handler_factory() const {
 127     return http_auth_handler_factory_;
 128   }
 129   void set_http_auth_handler_factory(HttpAuthHandlerFactory* factory) {
 130     http_auth_handler_factory_ = factory;
 131   }
 132
 133   // Gets the http transaction factory for this context.
 134   HttpTransactionFactory* http_transaction_factory() const {
 135     return http_transaction_factory_;
 136   }
 137   void set_http_transaction_factory(HttpTransactionFactory* factory) {
 138     http_transaction_factory_ = factory;
 139   }
 140
 141   void set_network_delegate(NetworkDelegate* network_delegate) {
 142     network_delegate_ = network_delegate;
 143   }
 144   NetworkDelegate* network_delegate() const { return network_delegate_; }
 145
 146   void set_http_server_properties(
 147       const base::WeakPtr<HttpServerProperties>& http_server_properties) {
 148     http_server_properties_ = http_server_properties;
 149   }
 150   base::WeakPtr<HttpServerProperties> http_server_properties() const {
 151     return http_server_properties_;
 152   }
 153
 154   // Gets the cookie store for this context (may be null, in which case
 155   // cookies are not stored).
 156   CookieStore* cookie_store() const { return cookie_store_.get(); }
 157   void set_cookie_store(CookieStore* cookie_store);
 158
 159   TransportSecurityState* transport_security_state() const {
 160     return transport_security_state_;
 161   }
 162   void set_transport_security_state(
 163       TransportSecurityState* state) {
 164     transport_security_state_ = state;
 165   }
 166
 167   CTVerifier* cert_transparency_verifier() const {
 168     return cert_transparency_verifier_;
 169   }
 170   void set_cert_transparency_verifier(CTVerifier* verifier) {
 171     cert_transparency_verifier_ = verifier;
 172   }
 173
 174   const URLRequestJobFactory* job_factory() const { return job_factory_; }
 175   void set_job_factory(const URLRequestJobFactory* job_factory) {
 176     job_factory_ = job_factory;
 177   }
 178
 179   // May be NULL.
 180   URLRequestThrottlerManager* throttler_manager() const {
 181     return throttler_manager_;
 182   }
 183   void set_throttler_manager(URLRequestThrottlerManager* throttler_manager) {
 184     throttler_manager_ = throttler_manager;
 185   }
 186
 187   // Gets the URLRequest objects that hold a reference to this
 188   // URLRequestContext.
 189   std::set<const URLRequest*>* url_requests() const {
 190     return url_requests_.get();
 191   }
 192
 193   void AssertNoURLRequests() const;
 194
 195   // Get the underlying |HttpUserAgentSettings| implementation that provides
 196   // the HTTP Accept-Language and User-Agent header values.
 197   const HttpUserAgentSettings* http_user_agent_settings() const {
 198     return http_user_agent_settings_;
 199   }
 200   void set_http_user_agent_settings(
 201       HttpUserAgentSettings* http_user_agent_settings) {
 202     http_user_agent_settings_ = http_user_agent_settings;
 203   }
 204
 205  private:
 206   // ---------------------------------------------------------------------------
 207   // Important: When adding any new members below, consider whether they need to
 208   // be added to CopyFrom.
 209   // ---------------------------------------------------------------------------
 210
 211   // Ownership for these members are not defined here. Clients should either
 212   // provide storage elsewhere or have a subclass take ownership.
 213   NetLog* net_log_;
 214   HostResolver* host_resolver_;
 215   CertVerifier* cert_verifier_;
 216   ServerBoundCertService* server_bound_cert_service_;
 217   FraudulentCertificateReporter* fraudulent_certificate_reporter_;
 218   HttpAuthHandlerFactory* http_auth_handler_factory_;
 219   ProxyService* proxy_service_;
 220   scoped_refptr<SSLConfigService> ssl_config_service_;
 221   NetworkDelegate* network_delegate_;
 222   base::WeakPtr<HttpServerProperties> http_server_properties_;
 223   HttpUserAgentSettings* http_user_agent_settings_;
 224   scoped_refptr<CookieStore> cookie_store_;
 225   TransportSecurityState* transport_security_state_;
 226   CTVerifier* cert_transparency_verifier_;
 227   HttpTransactionFactory* http_transaction_factory_;
 228   const URLRequestJobFactory* job_factory_;
 229   URLRequestThrottlerManager* throttler_manager_;
 230
 231   // ---------------------------------------------------------------------------
 232   // Important: When adding any new members below, consider whether they need to
 233   // be added to CopyFrom.
 234   // ---------------------------------------------------------------------------
 235
 236   scoped_ptr<std::set<const URLRequest*> > url_requests_;
 237
 238   DISALLOW_COPY_AND_ASSIGN(URLRequestContext);
 239 };
 240
 241 }  // namespace net
 242
 243 #endif  // NET_URL_REQUEST_URL_REQUEST_CONTEXT_H_