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