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