src/net/url_request/url_request_test_util.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 #ifndef NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
   6 #define NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_
   7
   8 #include <stdlib.h>
   9
  10 #include <map>
  11 #include <string>
  12
  13 #include "base/basictypes.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/memory/ref_counted.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "base/message_loop/message_loop_proxy.h"
  18 #include "base/path_service.h"
  19 #include "base/strings/string16.h"
  20 #include "base/strings/string_util.h"
  21 #include "base/strings/utf_string_conversions.h"
  22 #include "base/time/time.h"
  23 #include "net/base/io_buffer.h"
  24 #include "net/base/load_timing_info.h"
  25 #include "net/base/net_errors.h"
  26 #include "net/base/network_delegate.h"
  27 #include "net/base/request_priority.h"
  28 #include "net/cert/cert_verifier.h"
  29 #include "net/cookies/cookie_monster.h"
  30 #include "net/disk_cache/disk_cache.h"
  31 #include "net/ftp/ftp_network_layer.h"
  32 #include "net/http/http_auth_handler_factory.h"
  33 #include "net/http/http_cache.h"
  34 #include "net/http/http_network_layer.h"
  35 #include "net/http/http_network_session.h"
  36 #include "net/http/http_request_headers.h"
  37 #include "net/proxy/proxy_service.h"
  38 #include "net/ssl/ssl_config_service_defaults.h"
  39 #include "net/url_request/url_request.h"
  40 #include "net/url_request/url_request_context.h"
  41 #include "net/url_request/url_request_context_getter.h"
  42 #include "net/url_request/url_request_context_storage.h"
  43 #include "net/url_request/url_request_job_factory.h"
  44 #include "url/url_util.h"
  45
  46 using base::TimeDelta;
  47
  48 namespace net {
  49
  50 //-----------------------------------------------------------------------------
  51
  52 class TestURLRequestContext : public URLRequestContext {
  53  public:
  54   TestURLRequestContext();
  55   // Default constructor like TestURLRequestContext() but does not call
  56   // Init() in case |delay_initialization| is true. This allows modifying the
  57   // URLRequestContext before it is constructed completely. If
  58   // |delay_initialization| is true, Init() needs be be called manually.
  59   explicit TestURLRequestContext(bool delay_initialization);
  60   virtual ~TestURLRequestContext();
  61
  62   void Init();
  63
  64   ClientSocketFactory* client_socket_factory() {
  65     return client_socket_factory_;
  66   }
  67   void set_client_socket_factory(ClientSocketFactory* factory) {
  68     client_socket_factory_ = factory;
  69   }
  70
  71   void set_http_network_session_params(
  72       const HttpNetworkSession::Params& params) {
  73   }
  74
  75  private:
  76   bool initialized_;
  77
  78   // Optional parameters to override default values.  Note that values that
  79   // point to other objects the TestURLRequestContext creates will be
  80   // overwritten.
  81   scoped_ptr<HttpNetworkSession::Params> http_network_session_params_;
  82
  83   // Not owned:
  84   ClientSocketFactory* client_socket_factory_;
  85
  86  protected:
  87   URLRequestContextStorage context_storage_;
  88 };
  89
  90 //-----------------------------------------------------------------------------
  91
  92 // Used to return a dummy context, which lives on the message loop
  93 // given in the constructor.
  94 class TestURLRequestContextGetter : public URLRequestContextGetter {
  95  public:
  96   // |network_task_runner| must not be NULL.
  97   explicit TestURLRequestContextGetter(
  98       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner);
  99
 100   // Use to pass a pre-initialized |context|.
 101   TestURLRequestContextGetter(
 102       const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
 103       scoped_ptr<TestURLRequestContext> context);
 104
 105   // URLRequestContextGetter implementation.
 106   virtual TestURLRequestContext* GetURLRequestContext() OVERRIDE;
 107   virtual scoped_refptr<base::SingleThreadTaskRunner>
 108       GetNetworkTaskRunner() const OVERRIDE;
 109
 110  protected:
 111   virtual ~TestURLRequestContextGetter();
 112
 113  private:
 114   const scoped_refptr<base::SingleThreadTaskRunner> network_task_runner_;
 115   scoped_ptr<TestURLRequestContext> context_;
 116 };
 117
 118 //-----------------------------------------------------------------------------
 119
 120 class TestURLRequest : public URLRequest {
 121  public:
 122   TestURLRequest(const GURL& url,
 123                  RequestPriority priority,
 124                  Delegate* delegate,
 125                  TestURLRequestContext* context);
 126   virtual ~TestURLRequest();
 127 };
 128
 129 //-----------------------------------------------------------------------------
 130
 131 class TestDelegate : public URLRequest::Delegate {
 132  public:
 133   TestDelegate();
 134   virtual ~TestDelegate();
 135
 136   void set_cancel_in_received_redirect(bool val) { cancel_in_rr_ = val; }
 137   void set_cancel_in_response_started(bool val) { cancel_in_rs_ = val; }
 138   void set_cancel_in_received_data(bool val) { cancel_in_rd_ = val; }
 139   void set_cancel_in_received_data_pending(bool val) {
 140     cancel_in_rd_pending_ = val;
 141   }
 142   void set_quit_on_complete(bool val) { quit_on_complete_ = val; }
 143   void set_quit_on_redirect(bool val) { quit_on_redirect_ = val; }
 144   void set_quit_on_network_start(bool val) {
 145     quit_on_before_network_start_ = val;
 146   }
 147   void set_allow_certificate_errors(bool val) {
 148     allow_certificate_errors_ = val;
 149   }
 150   void set_credentials(const AuthCredentials& credentials) {
 151     credentials_ = credentials;
 152   }
 153
 154   // query state
 155   const std::string& data_received() const { return data_received_; }
 156   int bytes_received() const { return static_cast<int>(data_received_.size()); }
 157   int response_started_count() const { return response_started_count_; }
 158   int received_redirect_count() const { return received_redirect_count_; }
 159   int received_before_network_start_count() const {
 160     return received_before_network_start_count_;
 161   }
 162   bool received_data_before_response() const {
 163     return received_data_before_response_;
 164   }
 165   bool request_failed() const { return request_failed_; }
 166   bool have_certificate_errors() const { return have_certificate_errors_; }
 167   bool certificate_errors_are_fatal() const {
 168     return certificate_errors_are_fatal_;
 169   }
 170   bool auth_required_called() const { return auth_required_; }
 171   bool have_full_request_headers() const { return have_full_request_headers_; }
 172   const HttpRequestHeaders& full_request_headers() const {
 173     return full_request_headers_;
 174   }
 175   void ClearFullRequestHeaders();
 176
 177   // URLRequest::Delegate:
 178   virtual void OnReceivedRedirect(URLRequest* request,
 179                                   const RedirectInfo& redirect_info,
 180                                   bool* defer_redirect) OVERRIDE;
 181   virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) OVERRIDE;
 182   virtual void OnAuthRequired(URLRequest* request,
 183                               AuthChallengeInfo* auth_info) OVERRIDE;
 184   // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true.
 185   // (Unit tests use this as a post-condition.) But for policy, this method
 186   // consults |allow_certificate_errors_|.
 187   virtual void OnSSLCertificateError(URLRequest* request,
 188                                      const SSLInfo& ssl_info,
 189                                      bool fatal) OVERRIDE;
 190   virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
 191   virtual void OnReadCompleted(URLRequest* request,
 192                                int bytes_read) OVERRIDE;
 193
 194  private:
 195   static const int kBufferSize = 4096;
 196
 197   virtual void OnResponseCompleted(URLRequest* request);
 198
 199   // options for controlling behavior
 200   bool cancel_in_rr_;
 201   bool cancel_in_rs_;
 202   bool cancel_in_rd_;
 203   bool cancel_in_rd_pending_;
 204   bool quit_on_complete_;
 205   bool quit_on_redirect_;
 206   bool quit_on_before_network_start_;
 207   bool allow_certificate_errors_;
 208   AuthCredentials credentials_;
 209
 210   // tracks status of callbacks
 211   int response_started_count_;
 212   int received_bytes_count_;
 213   int received_redirect_count_;
 214   int received_before_network_start_count_;
 215   bool received_data_before_response_;
 216   bool request_failed_;
 217   bool have_certificate_errors_;
 218   bool certificate_errors_are_fatal_;
 219   bool auth_required_;
 220   std::string data_received_;
 221   bool have_full_request_headers_;
 222   HttpRequestHeaders full_request_headers_;
 223
 224   // our read buffer
 225   scoped_refptr<IOBuffer> buf_;
 226 };
 227
 228 //-----------------------------------------------------------------------------
 229
 230 class TestNetworkDelegate : public NetworkDelegate {
 231  public:
 232   enum Options {
 233     NO_GET_COOKIES = 1 << 0,
 234     NO_SET_COOKIE  = 1 << 1,
 235   };
 236
 237   TestNetworkDelegate();
 238   virtual ~TestNetworkDelegate();
 239
 240   // Writes the LoadTimingInfo during the most recent call to OnBeforeRedirect.
 241   bool GetLoadTimingInfoBeforeRedirect(
 242       LoadTimingInfo* load_timing_info_before_redirect) const;
 243
 244   // Same as GetLoadTimingInfoBeforeRedirect, except for calls to
 245   // AuthRequiredResponse.
 246   bool GetLoadTimingInfoBeforeAuth(
 247       LoadTimingInfo* load_timing_info_before_auth) const;
 248
 249   // Will redirect once to the given URL when the next set of headers are
 250   // received.
 251   void set_redirect_on_headers_received_url(
 252       GURL redirect_on_headers_received_url) {
 253     redirect_on_headers_received_url_ = redirect_on_headers_received_url;
 254   }
 255
 256   void set_allowed_unsafe_redirect_url(GURL allowed_unsafe_redirect_url) {
 257     allowed_unsafe_redirect_url_ = allowed_unsafe_redirect_url;
 258   }
 259
 260   void set_cookie_options(int o) {cookie_options_bit_mask_ = o; }
 261
 262   int last_error() const { return last_error_; }
 263   int error_count() const { return error_count_; }
 264   int created_requests() const { return created_requests_; }
 265   int destroyed_requests() const { return destroyed_requests_; }
 266   int completed_requests() const { return completed_requests_; }
 267   int canceled_requests() const { return canceled_requests_; }
 268   int blocked_get_cookies_count() const { return blocked_get_cookies_count_; }
 269   int blocked_set_cookie_count() const { return blocked_set_cookie_count_; }
 270   int set_cookie_count() const { return set_cookie_count_; }
 271
 272   void set_can_access_files(bool val) { can_access_files_ = val; }
 273   bool can_access_files() const { return can_access_files_; }
 274
 275   void set_can_throttle_requests(bool val) { can_throttle_requests_ = val; }
 276   bool can_throttle_requests() const { return can_throttle_requests_; }
 277
 278   int observed_before_proxy_headers_sent_callbacks() const {
 279     return observed_before_proxy_headers_sent_callbacks_;
 280   }
 281
 282   // Last observed proxy in proxy header sent callback.
 283   HostPortPair last_observed_proxy() {
 284     return last_observed_proxy_;
 285   }
 286
 287  protected:
 288   // NetworkDelegate:
 289   virtual int OnBeforeURLRequest(URLRequest* request,
 290                                  const CompletionCallback& callback,
 291                                  GURL* new_url) OVERRIDE;
 292   virtual int OnBeforeSendHeaders(URLRequest* request,
 293                                   const CompletionCallback& callback,
 294                                   HttpRequestHeaders* headers) OVERRIDE;
 295   virtual void OnBeforeSendProxyHeaders(
 296       net::URLRequest* request,
 297       const net::ProxyInfo& proxy_info,
 298       net::HttpRequestHeaders* headers) OVERRIDE;
 299   virtual void OnSendHeaders(URLRequest* request,
 300                              const HttpRequestHeaders& headers) OVERRIDE;
 301   virtual int OnHeadersReceived(
 302       URLRequest* request,
 303       const CompletionCallback& callback,
 304       const HttpResponseHeaders* original_response_headers,
 305       scoped_refptr<HttpResponseHeaders>* override_response_headers,
 306       GURL* allowed_unsafe_redirect_url) OVERRIDE;
 307   virtual void OnBeforeRedirect(URLRequest* request,
 308                                 const GURL& new_location) OVERRIDE;
 309   virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
 310   virtual void OnRawBytesRead(const URLRequest& request,
 311                               int bytes_read) OVERRIDE;
 312   virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE;
 313   virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE;
 314   virtual void OnPACScriptError(int line_number,
 315                                 const base::string16& error) OVERRIDE;
 316   virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired(
 317       URLRequest* request,
 318       const AuthChallengeInfo& auth_info,
 319       const AuthCallback& callback,
 320       AuthCredentials* credentials) OVERRIDE;
 321   virtual bool OnCanGetCookies(const URLRequest& request,
 322                                const CookieList& cookie_list) OVERRIDE;
 323   virtual bool OnCanSetCookie(const URLRequest& request,
 324                               const std::string& cookie_line,
 325                               CookieOptions* options) OVERRIDE;
 326   virtual bool OnCanAccessFile(const URLRequest& request,
 327                                const base::FilePath& path) const OVERRIDE;
 328   virtual bool OnCanThrottleRequest(
 329       const URLRequest& request) const OVERRIDE;
 330   virtual int OnBeforeSocketStreamConnect(
 331       SocketStream* stream,
 332       const CompletionCallback& callback) OVERRIDE;
 333
 334   void InitRequestStatesIfNew(int request_id);
 335
 336   GURL redirect_on_headers_received_url_;
 337   // URL marked as safe for redirection at the onHeadersReceived stage.
 338   GURL allowed_unsafe_redirect_url_;
 339
 340   int last_error_;
 341   int error_count_;
 342   int created_requests_;
 343   int destroyed_requests_;
 344   int completed_requests_;
 345   int canceled_requests_;
 346   int cookie_options_bit_mask_;
 347   int blocked_get_cookies_count_;
 348   int blocked_set_cookie_count_;
 349   int set_cookie_count_;
 350   int observed_before_proxy_headers_sent_callbacks_;
 351   // Last observed proxy in before proxy header sent callback.
 352   HostPortPair last_observed_proxy_;
 353
 354   // NetworkDelegate callbacks happen in a particular order (e.g.
 355   // OnBeforeURLRequest is always called before OnBeforeSendHeaders).
 356   // This bit-set indicates for each request id (key) what events may be sent
 357   // next.
 358   std::map<int, int> next_states_;
 359
 360   // A log that records for each request id (key) the order in which On...
 361   // functions were called.
 362   std::map<int, std::string> event_order_;
 363
 364   LoadTimingInfo load_timing_info_before_redirect_;
 365   bool has_load_timing_info_before_redirect_;
 366
 367   LoadTimingInfo load_timing_info_before_auth_;
 368   bool has_load_timing_info_before_auth_;
 369
 370   bool can_access_files_;  // true by default
 371   bool can_throttle_requests_;  // true by default
 372 };
 373
 374 // Overrides the host used by the LocalHttpTestServer in
 375 // url_request_unittest.cc . This is used by the chrome_frame_net_tests due to
 376 // a mysterious bug when tests execute over the loopback adapter. See
 377 // http://crbug.com/114369 .
 378 class ScopedCustomUrlRequestTestHttpHost {
 379  public:
 380   // Sets the host name to be used. The previous hostname will be stored and
 381   // restored upon destruction. Note that if the lifetimes of two or more
 382   // instances of this class overlap, they must be strictly nested.
 383   explicit ScopedCustomUrlRequestTestHttpHost(const std::string& new_value);
 384
 385   ~ScopedCustomUrlRequestTestHttpHost();
 386
 387   // Returns the current value to be used by HTTP tests in
 388   // url_request_unittest.cc .
 389   static const std::string& value();
 390
 391  private:
 392   static std::string value_;
 393   const std::string old_value_;
 394   const std::string new_value_;
 395
 396   DISALLOW_COPY_AND_ASSIGN(ScopedCustomUrlRequestTestHttpHost);
 397 };
 398
 399 //-----------------------------------------------------------------------------
 400
 401 // A simple ProtocolHandler that returns a pre-built URLRequestJob only once.
 402 class TestJobInterceptor : public URLRequestJobFactory::ProtocolHandler {
 403  public:
 404   TestJobInterceptor();
 405
 406   virtual URLRequestJob* MaybeCreateJob(
 407       URLRequest* request,
 408       NetworkDelegate* network_delegate) const OVERRIDE;
 409   void set_main_intercept_job(URLRequestJob* job);
 410
 411  private:
 412   mutable URLRequestJob* main_intercept_job_;
 413 };
 414
 415 }  // namespace net
 416
 417 #endif  // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_