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 client_socket_factory()64 ClientSocketFactory* client_socket_factory() { 65 return client_socket_factory_; 66 } set_client_socket_factory(ClientSocketFactory * factory)67 void set_client_socket_factory(ClientSocketFactory* factory) { 68 client_socket_factory_ = factory; 69 } 70 set_http_network_session_params(const HttpNetworkSession::Params & params)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 set_cancel_in_received_redirect(bool val)136 void set_cancel_in_received_redirect(bool val) { cancel_in_rr_ = val; } set_cancel_in_response_started(bool val)137 void set_cancel_in_response_started(bool val) { cancel_in_rs_ = val; } set_cancel_in_received_data(bool val)138 void set_cancel_in_received_data(bool val) { cancel_in_rd_ = val; } set_cancel_in_received_data_pending(bool val)139 void set_cancel_in_received_data_pending(bool val) { 140 cancel_in_rd_pending_ = val; 141 } set_quit_on_complete(bool val)142 void set_quit_on_complete(bool val) { quit_on_complete_ = val; } set_quit_on_redirect(bool val)143 void set_quit_on_redirect(bool val) { quit_on_redirect_ = val; } set_quit_on_network_start(bool val)144 void set_quit_on_network_start(bool val) { 145 quit_on_before_network_start_ = val; 146 } set_allow_certificate_errors(bool val)147 void set_allow_certificate_errors(bool val) { 148 allow_certificate_errors_ = val; 149 } set_credentials(const AuthCredentials & credentials)150 void set_credentials(const AuthCredentials& credentials) { 151 credentials_ = credentials; 152 } 153 154 // query state data_received()155 const std::string& data_received() const { return data_received_; } bytes_received()156 int bytes_received() const { return static_cast<int>(data_received_.size()); } response_started_count()157 int response_started_count() const { return response_started_count_; } received_redirect_count()158 int received_redirect_count() const { return received_redirect_count_; } received_before_network_start_count()159 int received_before_network_start_count() const { 160 return received_before_network_start_count_; 161 } received_data_before_response()162 bool received_data_before_response() const { 163 return received_data_before_response_; 164 } request_failed()165 bool request_failed() const { return request_failed_; } have_certificate_errors()166 bool have_certificate_errors() const { return have_certificate_errors_; } certificate_errors_are_fatal()167 bool certificate_errors_are_fatal() const { 168 return certificate_errors_are_fatal_; 169 } auth_required_called()170 bool auth_required_called() const { return auth_required_; } have_full_request_headers()171 bool have_full_request_headers() const { return have_full_request_headers_; } 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, const GURL& new_url, 179 bool* defer_redirect) OVERRIDE; 180 virtual void OnBeforeNetworkStart(URLRequest* request, bool* defer) OVERRIDE; 181 virtual void OnAuthRequired(URLRequest* request, 182 AuthChallengeInfo* auth_info) OVERRIDE; 183 // NOTE: |fatal| causes |certificate_errors_are_fatal_| to be set to true. 184 // (Unit tests use this as a post-condition.) But for policy, this method 185 // consults |allow_certificate_errors_|. 186 virtual void OnSSLCertificateError(URLRequest* request, 187 const SSLInfo& ssl_info, 188 bool fatal) OVERRIDE; 189 virtual void OnResponseStarted(URLRequest* request) OVERRIDE; 190 virtual void OnReadCompleted(URLRequest* request, 191 int bytes_read) OVERRIDE; 192 193 private: 194 static const int kBufferSize = 4096; 195 196 virtual void OnResponseCompleted(URLRequest* request); 197 198 // options for controlling behavior 199 bool cancel_in_rr_; 200 bool cancel_in_rs_; 201 bool cancel_in_rd_; 202 bool cancel_in_rd_pending_; 203 bool quit_on_complete_; 204 bool quit_on_redirect_; 205 bool quit_on_before_network_start_; 206 bool allow_certificate_errors_; 207 AuthCredentials credentials_; 208 209 // tracks status of callbacks 210 int response_started_count_; 211 int received_bytes_count_; 212 int received_redirect_count_; 213 int received_before_network_start_count_; 214 bool received_data_before_response_; 215 bool request_failed_; 216 bool have_certificate_errors_; 217 bool certificate_errors_are_fatal_; 218 bool auth_required_; 219 std::string data_received_; 220 bool have_full_request_headers_; 221 HttpRequestHeaders full_request_headers_; 222 223 // our read buffer 224 scoped_refptr<IOBuffer> buf_; 225 }; 226 227 //----------------------------------------------------------------------------- 228 229 class TestNetworkDelegate : public NetworkDelegate { 230 public: 231 enum Options { 232 NO_GET_COOKIES = 1 << 0, 233 NO_SET_COOKIE = 1 << 1, 234 }; 235 236 TestNetworkDelegate(); 237 virtual ~TestNetworkDelegate(); 238 239 // Writes the LoadTimingInfo during the most recent call to OnBeforeRedirect. 240 bool GetLoadTimingInfoBeforeRedirect( 241 LoadTimingInfo* load_timing_info_before_redirect) const; 242 243 // Same as GetLoadTimingInfoBeforeRedirect, except for calls to 244 // AuthRequiredResponse. 245 bool GetLoadTimingInfoBeforeAuth( 246 LoadTimingInfo* load_timing_info_before_auth) const; 247 248 // Will redirect once to the given URL when the next set of headers are 249 // received. set_redirect_on_headers_received_url(GURL redirect_on_headers_received_url)250 void set_redirect_on_headers_received_url( 251 GURL redirect_on_headers_received_url) { 252 redirect_on_headers_received_url_ = redirect_on_headers_received_url; 253 } 254 set_allowed_unsafe_redirect_url(GURL allowed_unsafe_redirect_url)255 void set_allowed_unsafe_redirect_url(GURL allowed_unsafe_redirect_url) { 256 allowed_unsafe_redirect_url_ = allowed_unsafe_redirect_url; 257 } 258 set_cookie_options(int o)259 void set_cookie_options(int o) {cookie_options_bit_mask_ = o; } 260 last_error()261 int last_error() const { return last_error_; } error_count()262 int error_count() const { return error_count_; } created_requests()263 int created_requests() const { return created_requests_; } destroyed_requests()264 int destroyed_requests() const { return destroyed_requests_; } completed_requests()265 int completed_requests() const { return completed_requests_; } canceled_requests()266 int canceled_requests() const { return canceled_requests_; } blocked_get_cookies_count()267 int blocked_get_cookies_count() const { return blocked_get_cookies_count_; } blocked_set_cookie_count()268 int blocked_set_cookie_count() const { return blocked_set_cookie_count_; } set_cookie_count()269 int set_cookie_count() const { return set_cookie_count_; } 270 set_can_access_files(bool val)271 void set_can_access_files(bool val) { can_access_files_ = val; } can_access_files()272 bool can_access_files() const { return can_access_files_; } 273 set_can_throttle_requests(bool val)274 void set_can_throttle_requests(bool val) { can_throttle_requests_ = val; } can_throttle_requests()275 bool can_throttle_requests() const { return can_throttle_requests_; } 276 277 protected: 278 // NetworkDelegate: 279 virtual int OnBeforeURLRequest(URLRequest* request, 280 const CompletionCallback& callback, 281 GURL* new_url) OVERRIDE; 282 virtual int OnBeforeSendHeaders(URLRequest* request, 283 const CompletionCallback& callback, 284 HttpRequestHeaders* headers) OVERRIDE; 285 virtual void OnSendHeaders(URLRequest* request, 286 const HttpRequestHeaders& headers) OVERRIDE; 287 virtual int OnHeadersReceived( 288 URLRequest* request, 289 const CompletionCallback& callback, 290 const HttpResponseHeaders* original_response_headers, 291 scoped_refptr<HttpResponseHeaders>* override_response_headers, 292 GURL* allowed_unsafe_redirect_url) OVERRIDE; 293 virtual void OnBeforeRedirect(URLRequest* request, 294 const GURL& new_location) OVERRIDE; 295 virtual void OnResponseStarted(URLRequest* request) OVERRIDE; 296 virtual void OnRawBytesRead(const URLRequest& request, 297 int bytes_read) OVERRIDE; 298 virtual void OnCompleted(URLRequest* request, bool started) OVERRIDE; 299 virtual void OnURLRequestDestroyed(URLRequest* request) OVERRIDE; 300 virtual void OnPACScriptError(int line_number, 301 const base::string16& error) OVERRIDE; 302 virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired( 303 URLRequest* request, 304 const AuthChallengeInfo& auth_info, 305 const AuthCallback& callback, 306 AuthCredentials* credentials) OVERRIDE; 307 virtual bool OnCanGetCookies(const URLRequest& request, 308 const CookieList& cookie_list) OVERRIDE; 309 virtual bool OnCanSetCookie(const URLRequest& request, 310 const std::string& cookie_line, 311 CookieOptions* options) OVERRIDE; 312 virtual bool OnCanAccessFile(const URLRequest& request, 313 const base::FilePath& path) const OVERRIDE; 314 virtual bool OnCanThrottleRequest( 315 const URLRequest& request) const OVERRIDE; 316 virtual int OnBeforeSocketStreamConnect( 317 SocketStream* stream, 318 const CompletionCallback& callback) OVERRIDE; 319 320 void InitRequestStatesIfNew(int request_id); 321 322 GURL redirect_on_headers_received_url_; 323 // URL marked as safe for redirection at the onHeadersReceived stage. 324 GURL allowed_unsafe_redirect_url_; 325 326 int last_error_; 327 int error_count_; 328 int created_requests_; 329 int destroyed_requests_; 330 int completed_requests_; 331 int canceled_requests_; 332 int cookie_options_bit_mask_; 333 int blocked_get_cookies_count_; 334 int blocked_set_cookie_count_; 335 int set_cookie_count_; 336 337 // NetworkDelegate callbacks happen in a particular order (e.g. 338 // OnBeforeURLRequest is always called before OnBeforeSendHeaders). 339 // This bit-set indicates for each request id (key) what events may be sent 340 // next. 341 std::map<int, int> next_states_; 342 343 // A log that records for each request id (key) the order in which On... 344 // functions were called. 345 std::map<int, std::string> event_order_; 346 347 LoadTimingInfo load_timing_info_before_redirect_; 348 bool has_load_timing_info_before_redirect_; 349 350 LoadTimingInfo load_timing_info_before_auth_; 351 bool has_load_timing_info_before_auth_; 352 353 bool can_access_files_; // true by default 354 bool can_throttle_requests_; // true by default 355 }; 356 357 // Overrides the host used by the LocalHttpTestServer in 358 // url_request_unittest.cc . This is used by the chrome_frame_net_tests due to 359 // a mysterious bug when tests execute over the loopback adapter. See 360 // http://crbug.com/114369 . 361 class ScopedCustomUrlRequestTestHttpHost { 362 public: 363 // Sets the host name to be used. The previous hostname will be stored and 364 // restored upon destruction. Note that if the lifetimes of two or more 365 // instances of this class overlap, they must be strictly nested. 366 explicit ScopedCustomUrlRequestTestHttpHost(const std::string& new_value); 367 368 ~ScopedCustomUrlRequestTestHttpHost(); 369 370 // Returns the current value to be used by HTTP tests in 371 // url_request_unittest.cc . 372 static const std::string& value(); 373 374 private: 375 static std::string value_; 376 const std::string old_value_; 377 const std::string new_value_; 378 379 DISALLOW_COPY_AND_ASSIGN(ScopedCustomUrlRequestTestHttpHost); 380 }; 381 382 //----------------------------------------------------------------------------- 383 384 // A simple ProtocolHandler that returns a pre-built URLRequestJob only once. 385 class TestJobInterceptor : public URLRequestJobFactory::ProtocolHandler { 386 public: 387 TestJobInterceptor(); 388 389 virtual URLRequestJob* MaybeCreateJob( 390 URLRequest* request, 391 NetworkDelegate* network_delegate) const OVERRIDE; 392 void set_main_intercept_job(URLRequestJob* job); 393 394 private: 395 mutable URLRequestJob* main_intercept_job_; 396 }; 397 398 } // namespace net 399 400 #endif // NET_URL_REQUEST_URL_REQUEST_TEST_UTIL_H_ 401