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 #include "build/build_config.h" 6 7 #if defined(OS_WIN) 8 #include <windows.h> 9 #include <shlobj.h> 10 #endif 11 12 #include <algorithm> 13 #include <string> 14 15 #include "base/basictypes.h" 16 #include "base/bind.h" 17 #include "base/compiler_specific.h" 18 #include "base/file_util.h" 19 #include "base/format_macros.h" 20 #include "base/memory/weak_ptr.h" 21 #include "base/message_loop/message_loop.h" 22 #include "base/path_service.h" 23 #include "base/strings/string_number_conversions.h" 24 #include "base/strings/string_piece.h" 25 #include "base/strings/string_split.h" 26 #include "base/strings/string_util.h" 27 #include "base/strings/stringprintf.h" 28 #include "base/strings/utf_string_conversions.h" 29 #include "net/base/capturing_net_log.h" 30 #include "net/base/load_flags.h" 31 #include "net/base/load_timing_info.h" 32 #include "net/base/load_timing_info_test_util.h" 33 #include "net/base/net_errors.h" 34 #include "net/base/net_log.h" 35 #include "net/base/net_log_unittest.h" 36 #include "net/base/net_module.h" 37 #include "net/base/net_util.h" 38 #include "net/base/test_data_directory.h" 39 #include "net/base/upload_bytes_element_reader.h" 40 #include "net/base/upload_data_stream.h" 41 #include "net/base/upload_file_element_reader.h" 42 #include "net/cert/ev_root_ca_metadata.h" 43 #include "net/cert/test_root_certs.h" 44 #include "net/cookies/cookie_monster.h" 45 #include "net/cookies/cookie_store_test_helpers.h" 46 #include "net/disk_cache/disk_cache.h" 47 #include "net/dns/mock_host_resolver.h" 48 #include "net/ftp/ftp_network_layer.h" 49 #include "net/http/http_cache.h" 50 #include "net/http/http_network_layer.h" 51 #include "net/http/http_network_session.h" 52 #include "net/http/http_request_headers.h" 53 #include "net/http/http_response_headers.h" 54 #include "net/ocsp/nss_ocsp.h" 55 #include "net/proxy/proxy_service.h" 56 #include "net/socket/ssl_client_socket.h" 57 #include "net/ssl/ssl_connection_status_flags.h" 58 #include "net/test/cert_test_util.h" 59 #include "net/test/spawned_test_server/spawned_test_server.h" 60 #include "net/url_request/data_protocol_handler.h" 61 #include "net/url_request/file_protocol_handler.h" 62 #include "net/url_request/ftp_protocol_handler.h" 63 #include "net/url_request/static_http_user_agent_settings.h" 64 #include "net/url_request/url_request.h" 65 #include "net/url_request/url_request_file_dir_job.h" 66 #include "net/url_request/url_request_http_job.h" 67 #include "net/url_request/url_request_job_factory_impl.h" 68 #include "net/url_request/url_request_redirect_job.h" 69 #include "net/url_request/url_request_test_job.h" 70 #include "net/url_request/url_request_test_util.h" 71 #include "testing/gtest/include/gtest/gtest.h" 72 #include "testing/platform_test.h" 73 74 #if defined(OS_WIN) 75 #include "base/win/scoped_com_initializer.h" 76 #include "base/win/scoped_comptr.h" 77 #include "base/win/windows_version.h" 78 #endif 79 80 using base::Time; 81 82 namespace net { 83 84 namespace { 85 86 const base::string16 kChrome(ASCIIToUTF16("chrome")); 87 const base::string16 kSecret(ASCIIToUTF16("secret")); 88 const base::string16 kUser(ASCIIToUTF16("user")); 89 90 // Tests load timing information in the case a fresh connection was used, with 91 // no proxy. 92 void TestLoadTimingNotReused(const net::LoadTimingInfo& load_timing_info, 93 int connect_timing_flags) { 94 EXPECT_FALSE(load_timing_info.socket_reused); 95 EXPECT_NE(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 96 97 EXPECT_FALSE(load_timing_info.request_start_time.is_null()); 98 EXPECT_FALSE(load_timing_info.request_start.is_null()); 99 100 EXPECT_LE(load_timing_info.request_start, 101 load_timing_info.connect_timing.connect_start); 102 ExpectConnectTimingHasTimes(load_timing_info.connect_timing, 103 connect_timing_flags); 104 EXPECT_LE(load_timing_info.connect_timing.connect_end, 105 load_timing_info.send_start); 106 EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end); 107 EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end); 108 109 EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null()); 110 EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null()); 111 } 112 113 // Same as above, but with proxy times. 114 void TestLoadTimingNotReusedWithProxy( 115 const net::LoadTimingInfo& load_timing_info, 116 int connect_timing_flags) { 117 EXPECT_FALSE(load_timing_info.socket_reused); 118 EXPECT_NE(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 119 120 EXPECT_FALSE(load_timing_info.request_start_time.is_null()); 121 EXPECT_FALSE(load_timing_info.request_start.is_null()); 122 123 EXPECT_LE(load_timing_info.request_start, 124 load_timing_info.proxy_resolve_start); 125 EXPECT_LE(load_timing_info.proxy_resolve_start, 126 load_timing_info.proxy_resolve_end); 127 EXPECT_LE(load_timing_info.proxy_resolve_end, 128 load_timing_info.connect_timing.connect_start); 129 ExpectConnectTimingHasTimes(load_timing_info.connect_timing, 130 connect_timing_flags); 131 EXPECT_LE(load_timing_info.connect_timing.connect_end, 132 load_timing_info.send_start); 133 EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end); 134 EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end); 135 } 136 137 // Same as above, but with a reused socket and proxy times. 138 void TestLoadTimingReusedWithProxy( 139 const net::LoadTimingInfo& load_timing_info) { 140 EXPECT_TRUE(load_timing_info.socket_reused); 141 EXPECT_NE(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 142 143 EXPECT_FALSE(load_timing_info.request_start_time.is_null()); 144 EXPECT_FALSE(load_timing_info.request_start.is_null()); 145 146 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 147 148 EXPECT_LE(load_timing_info.request_start, 149 load_timing_info.proxy_resolve_start); 150 EXPECT_LE(load_timing_info.proxy_resolve_start, 151 load_timing_info.proxy_resolve_end); 152 EXPECT_LE(load_timing_info.proxy_resolve_end, 153 load_timing_info.send_start); 154 EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end); 155 EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end); 156 } 157 158 // Tests load timing information in the case of a cache hit, when no cache 159 // validation request was sent over the wire. 160 void TestLoadTimingCacheHitNoNetwork( 161 const net::LoadTimingInfo& load_timing_info) { 162 EXPECT_FALSE(load_timing_info.socket_reused); 163 EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 164 165 EXPECT_FALSE(load_timing_info.request_start_time.is_null()); 166 EXPECT_FALSE(load_timing_info.request_start.is_null()); 167 168 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 169 EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start); 170 EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end); 171 EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end); 172 173 EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null()); 174 EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null()); 175 } 176 177 // Tests load timing in the case that there is no HTTP response. This can be 178 // used to test in the case of errors or non-HTTP requests. 179 void TestLoadTimingNoHttpResponse( 180 const net::LoadTimingInfo& load_timing_info) { 181 EXPECT_FALSE(load_timing_info.socket_reused); 182 EXPECT_EQ(net::NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 183 184 // Only the request times should be non-null. 185 EXPECT_FALSE(load_timing_info.request_start_time.is_null()); 186 EXPECT_FALSE(load_timing_info.request_start.is_null()); 187 188 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 189 190 EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null()); 191 EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null()); 192 EXPECT_TRUE(load_timing_info.send_start.is_null()); 193 EXPECT_TRUE(load_timing_info.send_end.is_null()); 194 EXPECT_TRUE(load_timing_info.receive_headers_end.is_null()); 195 } 196 197 base::StringPiece TestNetResourceProvider(int key) { 198 return "header"; 199 } 200 201 // Do a case-insensitive search through |haystack| for |needle|. 202 bool ContainsString(const std::string& haystack, const char* needle) { 203 std::string::const_iterator it = 204 std::search(haystack.begin(), 205 haystack.end(), 206 needle, 207 needle + strlen(needle), 208 base::CaseInsensitiveCompare<char>()); 209 return it != haystack.end(); 210 } 211 212 void FillBuffer(char* buffer, size_t len) { 213 static bool called = false; 214 if (!called) { 215 called = true; 216 int seed = static_cast<int>(Time::Now().ToInternalValue()); 217 srand(seed); 218 } 219 220 for (size_t i = 0; i < len; i++) { 221 buffer[i] = static_cast<char>(rand()); 222 if (!buffer[i]) 223 buffer[i] = 'g'; 224 } 225 } 226 227 UploadDataStream* CreateSimpleUploadData(const char* data) { 228 scoped_ptr<UploadElementReader> reader( 229 new UploadBytesElementReader(data, strlen(data))); 230 return UploadDataStream::CreateWithReader(reader.Pass(), 0); 231 } 232 233 // Verify that the SSLInfo of a successful SSL connection has valid values. 234 void CheckSSLInfo(const SSLInfo& ssl_info) { 235 // Allow ChromeFrame fake SSLInfo to get through. 236 if (ssl_info.cert.get() && 237 ssl_info.cert.get()->issuer().GetDisplayName() == "Chrome Internal") { 238 // -1 means unknown. 239 EXPECT_EQ(ssl_info.security_bits, -1); 240 return; 241 } 242 243 // -1 means unknown. 0 means no encryption. 244 EXPECT_GT(ssl_info.security_bits, 0); 245 246 // The cipher suite TLS_NULL_WITH_NULL_NULL (0) must not be negotiated. 247 int cipher_suite = SSLConnectionStatusToCipherSuite( 248 ssl_info.connection_status); 249 EXPECT_NE(0, cipher_suite); 250 } 251 252 void CheckFullRequestHeaders(const HttpRequestHeaders& headers, 253 const GURL& host_url) { 254 std::string sent_value; 255 256 EXPECT_TRUE(headers.GetHeader("Host", &sent_value)); 257 EXPECT_EQ(GetHostAndOptionalPort(host_url), sent_value); 258 259 EXPECT_TRUE(headers.GetHeader("Connection", &sent_value)); 260 EXPECT_EQ("keep-alive", sent_value); 261 } 262 263 bool FingerprintsEqual(const HashValueVector& a, const HashValueVector& b) { 264 size_t size = a.size(); 265 266 if (size != b.size()) 267 return false; 268 269 for (size_t i = 0; i < size; ++i) { 270 if (!a[i].Equals(b[i])) 271 return false; 272 } 273 274 return true; 275 } 276 277 // A network delegate that allows the user to choose a subset of request stages 278 // to block in. When blocking, the delegate can do one of the following: 279 // * synchronously return a pre-specified error code, or 280 // * asynchronously return that value via an automatically called callback, 281 // or 282 // * block and wait for the user to do a callback. 283 // Additionally, the user may also specify a redirect URL -- then each request 284 // with the current URL different from the redirect target will be redirected 285 // to that target, in the on-before-URL-request stage, independent of whether 286 // the delegate blocks in ON_BEFORE_URL_REQUEST or not. 287 class BlockingNetworkDelegate : public TestNetworkDelegate { 288 public: 289 // Stages in which the delegate can block. 290 enum Stage { 291 NOT_BLOCKED = 0, 292 ON_BEFORE_URL_REQUEST = 1 << 0, 293 ON_BEFORE_SEND_HEADERS = 1 << 1, 294 ON_HEADERS_RECEIVED = 1 << 2, 295 ON_AUTH_REQUIRED = 1 << 3 296 }; 297 298 // Behavior during blocked stages. During other stages, just 299 // returns net::OK or NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION. 300 enum BlockMode { 301 SYNCHRONOUS, // No callback, returns specified return values. 302 AUTO_CALLBACK, // |this| posts a task to run the callback using the 303 // specified return codes. 304 USER_CALLBACK, // User takes care of doing a callback. |retval_| and 305 // |auth_retval_| are ignored. In every blocking stage the 306 // message loop is quit. 307 }; 308 309 // Creates a delegate which does not block at all. 310 explicit BlockingNetworkDelegate(BlockMode block_mode); 311 312 // For users to trigger a callback returning |response|. 313 // Side-effects: resets |stage_blocked_for_callback_| and stored callbacks. 314 // Only call if |block_mode_| == USER_CALLBACK. 315 void DoCallback(int response); 316 void DoAuthCallback(NetworkDelegate::AuthRequiredResponse response); 317 318 // Setters. 319 void set_retval(int retval) { 320 ASSERT_NE(USER_CALLBACK, block_mode_); 321 ASSERT_NE(ERR_IO_PENDING, retval); 322 ASSERT_NE(OK, retval); 323 retval_ = retval; 324 } 325 326 // If |auth_retval| == AUTH_REQUIRED_RESPONSE_SET_AUTH, then 327 // |auth_credentials_| will be passed with the response. 328 void set_auth_retval(AuthRequiredResponse auth_retval) { 329 ASSERT_NE(USER_CALLBACK, block_mode_); 330 ASSERT_NE(AUTH_REQUIRED_RESPONSE_IO_PENDING, auth_retval); 331 auth_retval_ = auth_retval; 332 } 333 void set_auth_credentials(const AuthCredentials& auth_credentials) { 334 auth_credentials_ = auth_credentials; 335 } 336 337 void set_redirect_url(const GURL& url) { 338 redirect_url_ = url; 339 } 340 341 void set_block_on(int block_on) { 342 block_on_ = block_on; 343 } 344 345 // Allows the user to check in which state did we block. 346 Stage stage_blocked_for_callback() const { 347 EXPECT_EQ(USER_CALLBACK, block_mode_); 348 return stage_blocked_for_callback_; 349 } 350 351 private: 352 void RunCallback(int response, const CompletionCallback& callback); 353 void RunAuthCallback(AuthRequiredResponse response, 354 const AuthCallback& callback); 355 356 // TestNetworkDelegate implementation. 357 virtual int OnBeforeURLRequest(URLRequest* request, 358 const CompletionCallback& callback, 359 GURL* new_url) OVERRIDE; 360 361 virtual int OnBeforeSendHeaders(URLRequest* request, 362 const CompletionCallback& callback, 363 HttpRequestHeaders* headers) OVERRIDE; 364 365 virtual int OnHeadersReceived( 366 URLRequest* request, 367 const CompletionCallback& callback, 368 const HttpResponseHeaders* original_response_headers, 369 scoped_refptr<HttpResponseHeaders>* override_response_headers) OVERRIDE; 370 371 virtual NetworkDelegate::AuthRequiredResponse OnAuthRequired( 372 URLRequest* request, 373 const AuthChallengeInfo& auth_info, 374 const AuthCallback& callback, 375 AuthCredentials* credentials) OVERRIDE; 376 377 // Resets the callbacks and |stage_blocked_for_callback_|. 378 void Reset(); 379 380 // Checks whether we should block in |stage|. If yes, returns an error code 381 // and optionally sets up callback based on |block_mode_|. If no, returns OK. 382 int MaybeBlockStage(Stage stage, const CompletionCallback& callback); 383 384 // Configuration parameters, can be adjusted by public methods: 385 const BlockMode block_mode_; 386 387 // Values returned on blocking stages when mode is SYNCHRONOUS or 388 // AUTO_CALLBACK. For USER_CALLBACK these are set automatically to IO_PENDING. 389 int retval_; // To be returned in non-auth stages. 390 AuthRequiredResponse auth_retval_; 391 392 GURL redirect_url_; // Used if non-empty. 393 int block_on_; // Bit mask: in which stages to block. 394 395 // |auth_credentials_| will be copied to |*target_auth_credential_| on 396 // callback. 397 AuthCredentials auth_credentials_; 398 AuthCredentials* target_auth_credentials_; 399 400 // Internal variables, not set by not the user: 401 // Last blocked stage waiting for user callback (unused if |block_mode_| != 402 // USER_CALLBACK). 403 Stage stage_blocked_for_callback_; 404 405 // Callback objects stored during blocking stages. 406 CompletionCallback callback_; 407 AuthCallback auth_callback_; 408 409 base::WeakPtrFactory<BlockingNetworkDelegate> weak_factory_; 410 411 DISALLOW_COPY_AND_ASSIGN(BlockingNetworkDelegate); 412 }; 413 414 BlockingNetworkDelegate::BlockingNetworkDelegate(BlockMode block_mode) 415 : block_mode_(block_mode), 416 retval_(OK), 417 auth_retval_(AUTH_REQUIRED_RESPONSE_NO_ACTION), 418 block_on_(0), 419 target_auth_credentials_(NULL), 420 stage_blocked_for_callback_(NOT_BLOCKED), 421 weak_factory_(this) { 422 } 423 424 void BlockingNetworkDelegate::DoCallback(int response) { 425 ASSERT_EQ(USER_CALLBACK, block_mode_); 426 ASSERT_NE(NOT_BLOCKED, stage_blocked_for_callback_); 427 ASSERT_NE(ON_AUTH_REQUIRED, stage_blocked_for_callback_); 428 CompletionCallback callback = callback_; 429 Reset(); 430 RunCallback(response, callback); 431 } 432 433 void BlockingNetworkDelegate::DoAuthCallback( 434 NetworkDelegate::AuthRequiredResponse response) { 435 ASSERT_EQ(USER_CALLBACK, block_mode_); 436 ASSERT_EQ(ON_AUTH_REQUIRED, stage_blocked_for_callback_); 437 AuthCallback auth_callback = auth_callback_; 438 Reset(); 439 RunAuthCallback(response, auth_callback); 440 } 441 442 void BlockingNetworkDelegate::RunCallback(int response, 443 const CompletionCallback& callback) { 444 callback.Run(response); 445 } 446 447 void BlockingNetworkDelegate::RunAuthCallback(AuthRequiredResponse response, 448 const AuthCallback& callback) { 449 if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH) { 450 ASSERT_TRUE(target_auth_credentials_ != NULL); 451 *target_auth_credentials_ = auth_credentials_; 452 } 453 callback.Run(response); 454 } 455 456 int BlockingNetworkDelegate::OnBeforeURLRequest( 457 URLRequest* request, 458 const CompletionCallback& callback, 459 GURL* new_url) { 460 if (redirect_url_ == request->url()) 461 return OK; // We've already seen this request and redirected elsewhere. 462 463 TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url); 464 465 if (!redirect_url_.is_empty()) 466 *new_url = redirect_url_; 467 468 return MaybeBlockStage(ON_BEFORE_URL_REQUEST, callback); 469 } 470 471 int BlockingNetworkDelegate::OnBeforeSendHeaders( 472 URLRequest* request, 473 const CompletionCallback& callback, 474 HttpRequestHeaders* headers) { 475 TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers); 476 477 return MaybeBlockStage(ON_BEFORE_SEND_HEADERS, callback); 478 } 479 480 int BlockingNetworkDelegate::OnHeadersReceived( 481 URLRequest* request, 482 const CompletionCallback& callback, 483 const HttpResponseHeaders* original_response_headers, 484 scoped_refptr<HttpResponseHeaders>* override_response_headers) { 485 TestNetworkDelegate::OnHeadersReceived( 486 request, callback, original_response_headers, 487 override_response_headers); 488 489 return MaybeBlockStage(ON_HEADERS_RECEIVED, callback); 490 } 491 492 NetworkDelegate::AuthRequiredResponse BlockingNetworkDelegate::OnAuthRequired( 493 URLRequest* request, 494 const AuthChallengeInfo& auth_info, 495 const AuthCallback& callback, 496 AuthCredentials* credentials) { 497 TestNetworkDelegate::OnAuthRequired(request, auth_info, callback, 498 credentials); 499 // Check that the user has provided callback for the previous blocked stage. 500 EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_); 501 502 if ((block_on_ & ON_AUTH_REQUIRED) == 0) { 503 return AUTH_REQUIRED_RESPONSE_NO_ACTION; 504 } 505 506 target_auth_credentials_ = credentials; 507 508 switch (block_mode_) { 509 case SYNCHRONOUS: 510 if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH) 511 *target_auth_credentials_ = auth_credentials_; 512 return auth_retval_; 513 514 case AUTO_CALLBACK: 515 base::MessageLoop::current()->PostTask( 516 FROM_HERE, 517 base::Bind(&BlockingNetworkDelegate::RunAuthCallback, 518 weak_factory_.GetWeakPtr(), auth_retval_, callback)); 519 return AUTH_REQUIRED_RESPONSE_IO_PENDING; 520 521 case USER_CALLBACK: 522 auth_callback_ = callback; 523 stage_blocked_for_callback_ = ON_AUTH_REQUIRED; 524 base::MessageLoop::current()->PostTask(FROM_HERE, 525 base::MessageLoop::QuitClosure()); 526 return AUTH_REQUIRED_RESPONSE_IO_PENDING; 527 } 528 NOTREACHED(); 529 return AUTH_REQUIRED_RESPONSE_NO_ACTION; // Dummy value. 530 } 531 532 void BlockingNetworkDelegate::Reset() { 533 EXPECT_NE(NOT_BLOCKED, stage_blocked_for_callback_); 534 stage_blocked_for_callback_ = NOT_BLOCKED; 535 callback_.Reset(); 536 auth_callback_.Reset(); 537 } 538 539 int BlockingNetworkDelegate::MaybeBlockStage( 540 BlockingNetworkDelegate::Stage stage, 541 const CompletionCallback& callback) { 542 // Check that the user has provided callback for the previous blocked stage. 543 EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_); 544 545 if ((block_on_ & stage) == 0) { 546 return OK; 547 } 548 549 switch (block_mode_) { 550 case SYNCHRONOUS: 551 EXPECT_NE(OK, retval_); 552 return retval_; 553 554 case AUTO_CALLBACK: 555 base::MessageLoop::current()->PostTask( 556 FROM_HERE, 557 base::Bind(&BlockingNetworkDelegate::RunCallback, 558 weak_factory_.GetWeakPtr(), retval_, callback)); 559 return ERR_IO_PENDING; 560 561 case USER_CALLBACK: 562 callback_ = callback; 563 stage_blocked_for_callback_ = stage; 564 base::MessageLoop::current()->PostTask(FROM_HERE, 565 base::MessageLoop::QuitClosure()); 566 return ERR_IO_PENDING; 567 } 568 NOTREACHED(); 569 return 0; 570 } 571 572 class TestURLRequestContextWithProxy : public TestURLRequestContext { 573 public: 574 // Does not own |delegate|. 575 TestURLRequestContextWithProxy(const std::string& proxy, 576 NetworkDelegate* delegate) 577 : TestURLRequestContext(true) { 578 context_storage_.set_proxy_service(ProxyService::CreateFixed(proxy)); 579 set_network_delegate(delegate); 580 Init(); 581 } 582 virtual ~TestURLRequestContextWithProxy() {} 583 }; 584 585 } // namespace 586 587 // Inherit PlatformTest since we require the autorelease pool on Mac OS X. 588 class URLRequestTest : public PlatformTest { 589 public: 590 URLRequestTest() : default_context_(true) { 591 default_context_.set_network_delegate(&default_network_delegate_); 592 default_context_.set_net_log(&net_log_); 593 job_factory_.SetProtocolHandler("data", new DataProtocolHandler); 594 job_factory_.SetProtocolHandler("file", new FileProtocolHandler); 595 default_context_.set_job_factory(&job_factory_); 596 default_context_.Init(); 597 } 598 virtual ~URLRequestTest() {} 599 600 // Adds the TestJobInterceptor to the default context. 601 TestJobInterceptor* AddTestInterceptor() { 602 TestJobInterceptor* protocol_handler_ = new TestJobInterceptor(); 603 job_factory_.SetProtocolHandler("http", NULL); 604 job_factory_.SetProtocolHandler("http", protocol_handler_); 605 return protocol_handler_; 606 } 607 608 protected: 609 CapturingNetLog net_log_; 610 TestNetworkDelegate default_network_delegate_; // Must outlive URLRequest. 611 URLRequestJobFactoryImpl job_factory_; 612 TestURLRequestContext default_context_; 613 }; 614 615 TEST_F(URLRequestTest, AboutBlankTest) { 616 TestDelegate d; 617 { 618 URLRequest r(GURL("about:blank"), &d, &default_context_); 619 620 r.Start(); 621 EXPECT_TRUE(r.is_pending()); 622 623 base::MessageLoop::current()->Run(); 624 625 EXPECT_TRUE(!r.is_pending()); 626 EXPECT_FALSE(d.received_data_before_response()); 627 EXPECT_EQ(d.bytes_received(), 0); 628 EXPECT_EQ("", r.GetSocketAddress().host()); 629 EXPECT_EQ(0, r.GetSocketAddress().port()); 630 631 HttpRequestHeaders headers; 632 EXPECT_FALSE(r.GetFullRequestHeaders(&headers)); 633 } 634 } 635 636 TEST_F(URLRequestTest, DataURLImageTest) { 637 TestDelegate d; 638 { 639 // Use our nice little Chrome logo. 640 URLRequest r(GURL( 641 "data:image/png;base64," 642 "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAADVklEQVQ4jX2TfUwUBBjG3" 643 "w1y+HGcd9dxhXR8T4awOccJGgOSWclHImznLkTlSw0DDQXkrmgYgbUYnlQTqQxIEVxitD" 644 "5UMCATRA1CEEg+Qjw3bWDxIauJv/5oumqs39/P827vnucRmYN0gyF01GI5MpCVdW0gO7t" 645 "vNC+vqSEtbZefk5NuLv1jdJ46p/zw0HeH4+PHr3h7c1mjoV2t5rKzMx1+fg9bAgK6zHq9" 646 "cU5z+LpA3xOtx34+vTeT21onRuzssC3zxbbSwC13d/pFuC7CkIMDxQpF7r/MWq12UctI1" 647 "dWWm99ypqSYmRUBdKem8MkrO/kgaTt1O7YzlpzE5GIVd0WYUqt57yWf2McHTObYPbVD+Z" 648 "wbtlLTVMZ3BW+TnLyXLaWtmEq6WJVbT3HBh3Svj2HQQcm43XwmtoYM6vVKleh0uoWvnzW" 649 "3v3MpidruPTQPf0bia7sJOtBM0ufTWNvus/nkDFHF9ZS+uYVjRUasMeHUmyLYtcklTvzW" 650 "GFZnNOXczThvpKIzjcahSqIzkvDLayDq6D3eOjtBbNUEIZYyqsvj4V4wY92eNJ4IoyhTb" 651 "xXX1T5xsV9tm9r4TQwHLiZw/pdDZJea8TKmsmR/K0uLh/GwnCHghTja6lPhphezPfO5/5" 652 "MrVvMzNaI3+ERHfrFzPKQukrQGI4d/3EFD/3E2mVNYvi4at7CXWREaxZGD+3hg28zD3gV" 653 "Md6q5c8GdosynKmSeRuGzpjyl1/9UDGtPR5HeaKT8Wjo17WXk579BXVUhN64ehF9fhRtq" 654 "/uxxZKzNiZFGD0wRC3NFROZ5mwIPL/96K/rKMMLrIzF9uhHr+/sYH7DAbwlgC4J+R2Z7F" 655 "Ux1qLnV7MGF40smVSoJ/jvHRfYhQeUJd/SnYtGWhPHR0Sz+GE2F2yth0B36Vcz2KpnufB" 656 "JbsysjjW4kblBUiIjiURUWqJY65zxbnTy57GQyH58zgy0QBtTQv5gH15XMdKkYu+TGaJM" 657 "nlm2O34uI4b9tflqp1+QEFGzoW/ulmcofcpkZCYJhDfSpme7QcrHa+Xfji8paEQkTkSfm" 658 "moRWRNZr/F1KfVMjW+IKEnv2FwZfKdzt0BQR6lClcZR0EfEXEfv/G6W9iLiIyCoReV5En" 659 "hORIBHx+ufPj/gLB/zGI/G4Bk0AAAAASUVORK5CYII="), 660 &d, 661 &default_context_); 662 663 r.Start(); 664 EXPECT_TRUE(r.is_pending()); 665 666 base::MessageLoop::current()->Run(); 667 668 EXPECT_TRUE(!r.is_pending()); 669 EXPECT_FALSE(d.received_data_before_response()); 670 EXPECT_EQ(d.bytes_received(), 911); 671 EXPECT_EQ("", r.GetSocketAddress().host()); 672 EXPECT_EQ(0, r.GetSocketAddress().port()); 673 674 HttpRequestHeaders headers; 675 EXPECT_FALSE(r.GetFullRequestHeaders(&headers)); 676 } 677 } 678 679 TEST_F(URLRequestTest, FileTest) { 680 base::FilePath app_path; 681 PathService::Get(base::FILE_EXE, &app_path); 682 GURL app_url = FilePathToFileURL(app_path); 683 684 TestDelegate d; 685 { 686 URLRequest r(app_url, &d, &default_context_); 687 688 r.Start(); 689 EXPECT_TRUE(r.is_pending()); 690 691 base::MessageLoop::current()->Run(); 692 693 int64 file_size = -1; 694 EXPECT_TRUE(file_util::GetFileSize(app_path, &file_size)); 695 696 EXPECT_TRUE(!r.is_pending()); 697 EXPECT_EQ(1, d.response_started_count()); 698 EXPECT_FALSE(d.received_data_before_response()); 699 EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size)); 700 EXPECT_EQ("", r.GetSocketAddress().host()); 701 EXPECT_EQ(0, r.GetSocketAddress().port()); 702 703 HttpRequestHeaders headers; 704 EXPECT_FALSE(r.GetFullRequestHeaders(&headers)); 705 } 706 } 707 708 TEST_F(URLRequestTest, FileTestCancel) { 709 base::FilePath app_path; 710 PathService::Get(base::FILE_EXE, &app_path); 711 GURL app_url = FilePathToFileURL(app_path); 712 713 TestDelegate d; 714 { 715 URLRequest r(app_url, &d, &default_context_); 716 717 r.Start(); 718 EXPECT_TRUE(r.is_pending()); 719 r.Cancel(); 720 } 721 // Async cancellation should be safe even when URLRequest has been already 722 // destroyed. 723 base::MessageLoop::current()->RunUntilIdle(); 724 } 725 726 TEST_F(URLRequestTest, FileTestFullSpecifiedRange) { 727 const size_t buffer_size = 4000; 728 scoped_ptr<char[]> buffer(new char[buffer_size]); 729 FillBuffer(buffer.get(), buffer_size); 730 731 base::FilePath temp_path; 732 EXPECT_TRUE(file_util::CreateTemporaryFile(&temp_path)); 733 GURL temp_url = FilePathToFileURL(temp_path); 734 EXPECT_TRUE(file_util::WriteFile(temp_path, buffer.get(), buffer_size)); 735 736 int64 file_size; 737 EXPECT_TRUE(file_util::GetFileSize(temp_path, &file_size)); 738 739 const size_t first_byte_position = 500; 740 const size_t last_byte_position = buffer_size - first_byte_position; 741 const size_t content_length = last_byte_position - first_byte_position + 1; 742 std::string partial_buffer_string(buffer.get() + first_byte_position, 743 buffer.get() + last_byte_position + 1); 744 745 TestDelegate d; 746 { 747 URLRequest r(temp_url, &d, &default_context_); 748 749 HttpRequestHeaders headers; 750 headers.SetHeader(HttpRequestHeaders::kRange, 751 base::StringPrintf( 752 "bytes=%" PRIuS "-%" PRIuS, 753 first_byte_position, last_byte_position)); 754 r.SetExtraRequestHeaders(headers); 755 r.Start(); 756 EXPECT_TRUE(r.is_pending()); 757 758 base::MessageLoop::current()->Run(); 759 EXPECT_TRUE(!r.is_pending()); 760 EXPECT_EQ(1, d.response_started_count()); 761 EXPECT_FALSE(d.received_data_before_response()); 762 EXPECT_EQ(static_cast<int>(content_length), d.bytes_received()); 763 // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed. 764 EXPECT_TRUE(partial_buffer_string == d.data_received()); 765 } 766 767 EXPECT_TRUE(base::DeleteFile(temp_path, false)); 768 } 769 770 TEST_F(URLRequestTest, FileTestHalfSpecifiedRange) { 771 const size_t buffer_size = 4000; 772 scoped_ptr<char[]> buffer(new char[buffer_size]); 773 FillBuffer(buffer.get(), buffer_size); 774 775 base::FilePath temp_path; 776 EXPECT_TRUE(file_util::CreateTemporaryFile(&temp_path)); 777 GURL temp_url = FilePathToFileURL(temp_path); 778 EXPECT_TRUE(file_util::WriteFile(temp_path, buffer.get(), buffer_size)); 779 780 int64 file_size; 781 EXPECT_TRUE(file_util::GetFileSize(temp_path, &file_size)); 782 783 const size_t first_byte_position = 500; 784 const size_t last_byte_position = buffer_size - 1; 785 const size_t content_length = last_byte_position - first_byte_position + 1; 786 std::string partial_buffer_string(buffer.get() + first_byte_position, 787 buffer.get() + last_byte_position + 1); 788 789 TestDelegate d; 790 { 791 URLRequest r(temp_url, &d, &default_context_); 792 793 HttpRequestHeaders headers; 794 headers.SetHeader(HttpRequestHeaders::kRange, 795 base::StringPrintf("bytes=%" PRIuS "-", 796 first_byte_position)); 797 r.SetExtraRequestHeaders(headers); 798 r.Start(); 799 EXPECT_TRUE(r.is_pending()); 800 801 base::MessageLoop::current()->Run(); 802 EXPECT_TRUE(!r.is_pending()); 803 EXPECT_EQ(1, d.response_started_count()); 804 EXPECT_FALSE(d.received_data_before_response()); 805 EXPECT_EQ(static_cast<int>(content_length), d.bytes_received()); 806 // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed. 807 EXPECT_TRUE(partial_buffer_string == d.data_received()); 808 } 809 810 EXPECT_TRUE(base::DeleteFile(temp_path, false)); 811 } 812 813 TEST_F(URLRequestTest, FileTestMultipleRanges) { 814 const size_t buffer_size = 400000; 815 scoped_ptr<char[]> buffer(new char[buffer_size]); 816 FillBuffer(buffer.get(), buffer_size); 817 818 base::FilePath temp_path; 819 EXPECT_TRUE(file_util::CreateTemporaryFile(&temp_path)); 820 GURL temp_url = FilePathToFileURL(temp_path); 821 EXPECT_TRUE(file_util::WriteFile(temp_path, buffer.get(), buffer_size)); 822 823 int64 file_size; 824 EXPECT_TRUE(file_util::GetFileSize(temp_path, &file_size)); 825 826 TestDelegate d; 827 { 828 URLRequest r(temp_url, &d, &default_context_); 829 830 HttpRequestHeaders headers; 831 headers.SetHeader(HttpRequestHeaders::kRange, 832 "bytes=0-0,10-200,200-300"); 833 r.SetExtraRequestHeaders(headers); 834 r.Start(); 835 EXPECT_TRUE(r.is_pending()); 836 837 base::MessageLoop::current()->Run(); 838 EXPECT_TRUE(d.request_failed()); 839 } 840 841 EXPECT_TRUE(base::DeleteFile(temp_path, false)); 842 } 843 844 TEST_F(URLRequestTest, InvalidUrlTest) { 845 TestDelegate d; 846 { 847 URLRequest r(GURL("invalid url"), &d, &default_context_); 848 849 r.Start(); 850 EXPECT_TRUE(r.is_pending()); 851 852 base::MessageLoop::current()->Run(); 853 EXPECT_TRUE(d.request_failed()); 854 } 855 } 856 857 #if defined(OS_WIN) 858 TEST_F(URLRequestTest, ResolveShortcutTest) { 859 base::FilePath app_path; 860 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 861 app_path = app_path.AppendASCII("net"); 862 app_path = app_path.AppendASCII("data"); 863 app_path = app_path.AppendASCII("url_request_unittest"); 864 app_path = app_path.AppendASCII("with-headers.html"); 865 866 std::wstring lnk_path = app_path.value() + L".lnk"; 867 868 base::win::ScopedCOMInitializer com_initializer; 869 870 // Temporarily create a shortcut for test 871 { 872 base::win::ScopedComPtr<IShellLink> shell; 873 ASSERT_TRUE(SUCCEEDED(shell.CreateInstance(CLSID_ShellLink, NULL, 874 CLSCTX_INPROC_SERVER))); 875 base::win::ScopedComPtr<IPersistFile> persist; 876 ASSERT_TRUE(SUCCEEDED(shell.QueryInterface(persist.Receive()))); 877 EXPECT_TRUE(SUCCEEDED(shell->SetPath(app_path.value().c_str()))); 878 EXPECT_TRUE(SUCCEEDED(shell->SetDescription(L"ResolveShortcutTest"))); 879 EXPECT_TRUE(SUCCEEDED(persist->Save(lnk_path.c_str(), TRUE))); 880 } 881 882 TestDelegate d; 883 { 884 URLRequest r(FilePathToFileURL(base::FilePath(lnk_path)), &d, 885 &default_context_); 886 887 r.Start(); 888 EXPECT_TRUE(r.is_pending()); 889 890 base::MessageLoop::current()->Run(); 891 892 WIN32_FILE_ATTRIBUTE_DATA data; 893 GetFileAttributesEx(app_path.value().c_str(), 894 GetFileExInfoStandard, &data); 895 HANDLE file = CreateFile(app_path.value().c_str(), GENERIC_READ, 896 FILE_SHARE_READ, NULL, OPEN_EXISTING, 897 FILE_ATTRIBUTE_NORMAL, NULL); 898 EXPECT_NE(INVALID_HANDLE_VALUE, file); 899 scoped_ptr<char[]> buffer(new char[data.nFileSizeLow]); 900 DWORD read_size; 901 BOOL result; 902 result = ReadFile(file, buffer.get(), data.nFileSizeLow, 903 &read_size, NULL); 904 std::string content(buffer.get(), read_size); 905 CloseHandle(file); 906 907 EXPECT_TRUE(!r.is_pending()); 908 EXPECT_EQ(1, d.received_redirect_count()); 909 EXPECT_EQ(content, d.data_received()); 910 } 911 912 // Clean the shortcut 913 DeleteFile(lnk_path.c_str()); 914 } 915 #endif // defined(OS_WIN) 916 917 TEST_F(URLRequestTest, FileDirCancelTest) { 918 // Put in mock resource provider. 919 NetModule::SetResourceProvider(TestNetResourceProvider); 920 921 TestDelegate d; 922 { 923 base::FilePath file_path; 924 PathService::Get(base::DIR_SOURCE_ROOT, &file_path); 925 file_path = file_path.Append(FILE_PATH_LITERAL("net")); 926 file_path = file_path.Append(FILE_PATH_LITERAL("data")); 927 928 URLRequest req(FilePathToFileURL(file_path), &d, &default_context_); 929 req.Start(); 930 EXPECT_TRUE(req.is_pending()); 931 932 d.set_cancel_in_received_data_pending(true); 933 934 base::MessageLoop::current()->Run(); 935 } 936 937 // Take out mock resource provider. 938 NetModule::SetResourceProvider(NULL); 939 } 940 941 TEST_F(URLRequestTest, FileDirRedirectNoCrash) { 942 // There is an implicit redirect when loading a file path that matches a 943 // directory and does not end with a slash. Ensure that following such 944 // redirects does not crash. See http://crbug.com/18686. 945 946 base::FilePath path; 947 PathService::Get(base::DIR_SOURCE_ROOT, &path); 948 path = path.Append(FILE_PATH_LITERAL("net")); 949 path = path.Append(FILE_PATH_LITERAL("data")); 950 path = path.Append(FILE_PATH_LITERAL("url_request_unittest")); 951 952 TestDelegate d; 953 URLRequest req(FilePathToFileURL(path), &d, &default_context_); 954 req.Start(); 955 base::MessageLoop::current()->Run(); 956 957 ASSERT_EQ(1, d.received_redirect_count()); 958 ASSERT_LT(0, d.bytes_received()); 959 ASSERT_FALSE(d.request_failed()); 960 ASSERT_TRUE(req.status().is_success()); 961 } 962 963 #if defined(OS_WIN) 964 // Don't accept the url "file:///" on windows. See http://crbug.com/1474. 965 TEST_F(URLRequestTest, FileDirRedirectSingleSlash) { 966 TestDelegate d; 967 URLRequest req(GURL("file:///"), &d, &default_context_); 968 req.Start(); 969 base::MessageLoop::current()->Run(); 970 971 ASSERT_EQ(1, d.received_redirect_count()); 972 ASSERT_FALSE(req.status().is_success()); 973 } 974 #endif 975 976 // Custom URLRequestJobs for use with interceptor tests 977 class RestartTestJob : public URLRequestTestJob { 978 public: 979 RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate) 980 : URLRequestTestJob(request, network_delegate, true) {} 981 protected: 982 virtual void StartAsync() OVERRIDE { 983 this->NotifyRestartRequired(); 984 } 985 private: 986 virtual ~RestartTestJob() {} 987 }; 988 989 class CancelTestJob : public URLRequestTestJob { 990 public: 991 explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate) 992 : URLRequestTestJob(request, network_delegate, true) {} 993 protected: 994 virtual void StartAsync() OVERRIDE { 995 request_->Cancel(); 996 } 997 private: 998 virtual ~CancelTestJob() {} 999 }; 1000 1001 class CancelThenRestartTestJob : public URLRequestTestJob { 1002 public: 1003 explicit CancelThenRestartTestJob(URLRequest* request, 1004 NetworkDelegate* network_delegate) 1005 : URLRequestTestJob(request, network_delegate, true) { 1006 } 1007 protected: 1008 virtual void StartAsync() OVERRIDE { 1009 request_->Cancel(); 1010 this->NotifyRestartRequired(); 1011 } 1012 private: 1013 virtual ~CancelThenRestartTestJob() {} 1014 }; 1015 1016 // An Interceptor for use with interceptor tests 1017 class TestInterceptor : URLRequest::Interceptor { 1018 public: 1019 TestInterceptor() 1020 : intercept_main_request_(false), restart_main_request_(false), 1021 cancel_main_request_(false), cancel_then_restart_main_request_(false), 1022 simulate_main_network_error_(false), 1023 intercept_redirect_(false), cancel_redirect_request_(false), 1024 intercept_final_response_(false), cancel_final_request_(false), 1025 did_intercept_main_(false), did_restart_main_(false), 1026 did_cancel_main_(false), did_cancel_then_restart_main_(false), 1027 did_simulate_error_main_(false), 1028 did_intercept_redirect_(false), did_cancel_redirect_(false), 1029 did_intercept_final_(false), did_cancel_final_(false) { 1030 URLRequest::Deprecated::RegisterRequestInterceptor(this); 1031 } 1032 1033 virtual ~TestInterceptor() { 1034 URLRequest::Deprecated::UnregisterRequestInterceptor(this); 1035 } 1036 1037 virtual URLRequestJob* MaybeIntercept( 1038 URLRequest* request, 1039 NetworkDelegate* network_delegate) OVERRIDE { 1040 if (restart_main_request_) { 1041 restart_main_request_ = false; 1042 did_restart_main_ = true; 1043 return new RestartTestJob(request, network_delegate); 1044 } 1045 if (cancel_main_request_) { 1046 cancel_main_request_ = false; 1047 did_cancel_main_ = true; 1048 return new CancelTestJob(request, network_delegate); 1049 } 1050 if (cancel_then_restart_main_request_) { 1051 cancel_then_restart_main_request_ = false; 1052 did_cancel_then_restart_main_ = true; 1053 return new CancelThenRestartTestJob(request, network_delegate); 1054 } 1055 if (simulate_main_network_error_) { 1056 simulate_main_network_error_ = false; 1057 did_simulate_error_main_ = true; 1058 // will error since the requeted url is not one of its canned urls 1059 return new URLRequestTestJob(request, network_delegate, true); 1060 } 1061 if (!intercept_main_request_) 1062 return NULL; 1063 intercept_main_request_ = false; 1064 did_intercept_main_ = true; 1065 URLRequestTestJob* job = new URLRequestTestJob(request, 1066 network_delegate, 1067 main_headers_, 1068 main_data_, 1069 true); 1070 job->set_load_timing_info(main_request_load_timing_info_); 1071 return job; 1072 } 1073 1074 virtual URLRequestJob* MaybeInterceptRedirect( 1075 URLRequest* request, 1076 NetworkDelegate* network_delegate, 1077 const GURL& location) OVERRIDE { 1078 if (cancel_redirect_request_) { 1079 cancel_redirect_request_ = false; 1080 did_cancel_redirect_ = true; 1081 return new CancelTestJob(request, network_delegate); 1082 } 1083 if (!intercept_redirect_) 1084 return NULL; 1085 intercept_redirect_ = false; 1086 did_intercept_redirect_ = true; 1087 return new URLRequestTestJob(request, 1088 network_delegate, 1089 redirect_headers_, 1090 redirect_data_, 1091 true); 1092 } 1093 1094 virtual URLRequestJob* MaybeInterceptResponse( 1095 URLRequest* request, NetworkDelegate* network_delegate) OVERRIDE { 1096 if (cancel_final_request_) { 1097 cancel_final_request_ = false; 1098 did_cancel_final_ = true; 1099 return new CancelTestJob(request, network_delegate); 1100 } 1101 if (!intercept_final_response_) 1102 return NULL; 1103 intercept_final_response_ = false; 1104 did_intercept_final_ = true; 1105 return new URLRequestTestJob(request, 1106 network_delegate, 1107 final_headers_, 1108 final_data_, 1109 true); 1110 } 1111 1112 // Whether to intercept the main request, and if so the response to return and 1113 // the LoadTimingInfo to use. 1114 bool intercept_main_request_; 1115 std::string main_headers_; 1116 std::string main_data_; 1117 LoadTimingInfo main_request_load_timing_info_; 1118 1119 // Other actions we take at MaybeIntercept time 1120 bool restart_main_request_; 1121 bool cancel_main_request_; 1122 bool cancel_then_restart_main_request_; 1123 bool simulate_main_network_error_; 1124 1125 // Whether to intercept redirects, and if so the response to return. 1126 bool intercept_redirect_; 1127 std::string redirect_headers_; 1128 std::string redirect_data_; 1129 1130 // Other actions we can take at MaybeInterceptRedirect time 1131 bool cancel_redirect_request_; 1132 1133 // Whether to intercept final response, and if so the response to return. 1134 bool intercept_final_response_; 1135 std::string final_headers_; 1136 std::string final_data_; 1137 1138 // Other actions we can take at MaybeInterceptResponse time 1139 bool cancel_final_request_; 1140 1141 // If we did something or not 1142 bool did_intercept_main_; 1143 bool did_restart_main_; 1144 bool did_cancel_main_; 1145 bool did_cancel_then_restart_main_; 1146 bool did_simulate_error_main_; 1147 bool did_intercept_redirect_; 1148 bool did_cancel_redirect_; 1149 bool did_intercept_final_; 1150 bool did_cancel_final_; 1151 1152 // Static getters for canned response header and data strings 1153 1154 static std::string ok_data() { 1155 return URLRequestTestJob::test_data_1(); 1156 } 1157 1158 static std::string ok_headers() { 1159 return URLRequestTestJob::test_headers(); 1160 } 1161 1162 static std::string redirect_data() { 1163 return std::string(); 1164 } 1165 1166 static std::string redirect_headers() { 1167 return URLRequestTestJob::test_redirect_headers(); 1168 } 1169 1170 static std::string error_data() { 1171 return std::string("ohhh nooooo mr. bill!"); 1172 } 1173 1174 static std::string error_headers() { 1175 return URLRequestTestJob::test_error_headers(); 1176 } 1177 }; 1178 1179 TEST_F(URLRequestTest, Intercept) { 1180 TestInterceptor interceptor; 1181 1182 // intercept the main request and respond with a simple response 1183 interceptor.intercept_main_request_ = true; 1184 interceptor.main_headers_ = TestInterceptor::ok_headers(); 1185 interceptor.main_data_ = TestInterceptor::ok_data(); 1186 1187 TestDelegate d; 1188 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1189 base::SupportsUserData::Data* user_data0 = new base::SupportsUserData::Data(); 1190 base::SupportsUserData::Data* user_data1 = new base::SupportsUserData::Data(); 1191 base::SupportsUserData::Data* user_data2 = new base::SupportsUserData::Data(); 1192 req.SetUserData(NULL, user_data0); 1193 req.SetUserData(&user_data1, user_data1); 1194 req.SetUserData(&user_data2, user_data2); 1195 req.set_method("GET"); 1196 req.Start(); 1197 base::MessageLoop::current()->Run(); 1198 1199 // Make sure we can retrieve our specific user data 1200 EXPECT_EQ(user_data0, req.GetUserData(NULL)); 1201 EXPECT_EQ(user_data1, req.GetUserData(&user_data1)); 1202 EXPECT_EQ(user_data2, req.GetUserData(&user_data2)); 1203 1204 // Check the interceptor got called as expected 1205 EXPECT_TRUE(interceptor.did_intercept_main_); 1206 1207 // Check we got one good response 1208 EXPECT_TRUE(req.status().is_success()); 1209 EXPECT_EQ(200, req.response_headers()->response_code()); 1210 EXPECT_EQ(TestInterceptor::ok_data(), d.data_received()); 1211 EXPECT_EQ(1, d.response_started_count()); 1212 EXPECT_EQ(0, d.received_redirect_count()); 1213 } 1214 1215 TEST_F(URLRequestTest, InterceptRedirect) { 1216 TestInterceptor interceptor; 1217 1218 // intercept the main request and respond with a redirect 1219 interceptor.intercept_main_request_ = true; 1220 interceptor.main_headers_ = TestInterceptor::redirect_headers(); 1221 interceptor.main_data_ = TestInterceptor::redirect_data(); 1222 1223 // intercept that redirect and respond a final OK response 1224 interceptor.intercept_redirect_ = true; 1225 interceptor.redirect_headers_ = TestInterceptor::ok_headers(); 1226 interceptor.redirect_data_ = TestInterceptor::ok_data(); 1227 1228 TestDelegate d; 1229 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1230 req.set_method("GET"); 1231 req.Start(); 1232 base::MessageLoop::current()->Run(); 1233 1234 // Check the interceptor got called as expected 1235 EXPECT_TRUE(interceptor.did_intercept_main_); 1236 EXPECT_TRUE(interceptor.did_intercept_redirect_); 1237 1238 // Check we got one good response 1239 EXPECT_TRUE(req.status().is_success()); 1240 if (req.status().is_success()) { 1241 EXPECT_EQ(200, req.response_headers()->response_code()); 1242 } 1243 EXPECT_EQ(TestInterceptor::ok_data(), d.data_received()); 1244 EXPECT_EQ(1, d.response_started_count()); 1245 EXPECT_EQ(0, d.received_redirect_count()); 1246 } 1247 1248 TEST_F(URLRequestTest, InterceptServerError) { 1249 TestInterceptor interceptor; 1250 1251 // intercept the main request to generate a server error response 1252 interceptor.intercept_main_request_ = true; 1253 interceptor.main_headers_ = TestInterceptor::error_headers(); 1254 interceptor.main_data_ = TestInterceptor::error_data(); 1255 1256 // intercept that error and respond with an OK response 1257 interceptor.intercept_final_response_ = true; 1258 interceptor.final_headers_ = TestInterceptor::ok_headers(); 1259 interceptor.final_data_ = TestInterceptor::ok_data(); 1260 1261 TestDelegate d; 1262 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1263 req.set_method("GET"); 1264 req.Start(); 1265 base::MessageLoop::current()->Run(); 1266 1267 // Check the interceptor got called as expected 1268 EXPECT_TRUE(interceptor.did_intercept_main_); 1269 EXPECT_TRUE(interceptor.did_intercept_final_); 1270 1271 // Check we got one good response 1272 EXPECT_TRUE(req.status().is_success()); 1273 EXPECT_EQ(200, req.response_headers()->response_code()); 1274 EXPECT_EQ(TestInterceptor::ok_data(), d.data_received()); 1275 EXPECT_EQ(1, d.response_started_count()); 1276 EXPECT_EQ(0, d.received_redirect_count()); 1277 } 1278 1279 TEST_F(URLRequestTest, InterceptNetworkError) { 1280 TestInterceptor interceptor; 1281 1282 // intercept the main request to simulate a network error 1283 interceptor.simulate_main_network_error_ = true; 1284 1285 // intercept that error and respond with an OK response 1286 interceptor.intercept_final_response_ = true; 1287 interceptor.final_headers_ = TestInterceptor::ok_headers(); 1288 interceptor.final_data_ = TestInterceptor::ok_data(); 1289 1290 TestDelegate d; 1291 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1292 req.set_method("GET"); 1293 req.Start(); 1294 base::MessageLoop::current()->Run(); 1295 1296 // Check the interceptor got called as expected 1297 EXPECT_TRUE(interceptor.did_simulate_error_main_); 1298 EXPECT_TRUE(interceptor.did_intercept_final_); 1299 1300 // Check we received one good response 1301 EXPECT_TRUE(req.status().is_success()); 1302 EXPECT_EQ(200, req.response_headers()->response_code()); 1303 EXPECT_EQ(TestInterceptor::ok_data(), d.data_received()); 1304 EXPECT_EQ(1, d.response_started_count()); 1305 EXPECT_EQ(0, d.received_redirect_count()); 1306 } 1307 1308 TEST_F(URLRequestTest, InterceptRestartRequired) { 1309 TestInterceptor interceptor; 1310 1311 // restart the main request 1312 interceptor.restart_main_request_ = true; 1313 1314 // then intercept the new main request and respond with an OK response 1315 interceptor.intercept_main_request_ = true; 1316 interceptor.main_headers_ = TestInterceptor::ok_headers(); 1317 interceptor.main_data_ = TestInterceptor::ok_data(); 1318 1319 TestDelegate d; 1320 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1321 req.set_method("GET"); 1322 req.Start(); 1323 base::MessageLoop::current()->Run(); 1324 1325 // Check the interceptor got called as expected 1326 EXPECT_TRUE(interceptor.did_restart_main_); 1327 EXPECT_TRUE(interceptor.did_intercept_main_); 1328 1329 // Check we received one good response 1330 EXPECT_TRUE(req.status().is_success()); 1331 if (req.status().is_success()) { 1332 EXPECT_EQ(200, req.response_headers()->response_code()); 1333 } 1334 EXPECT_EQ(TestInterceptor::ok_data(), d.data_received()); 1335 EXPECT_EQ(1, d.response_started_count()); 1336 EXPECT_EQ(0, d.received_redirect_count()); 1337 } 1338 1339 TEST_F(URLRequestTest, InterceptRespectsCancelMain) { 1340 TestInterceptor interceptor; 1341 1342 // intercept the main request and cancel from within the restarted job 1343 interceptor.cancel_main_request_ = true; 1344 1345 // setup to intercept final response and override it with an OK response 1346 interceptor.intercept_final_response_ = true; 1347 interceptor.final_headers_ = TestInterceptor::ok_headers(); 1348 interceptor.final_data_ = TestInterceptor::ok_data(); 1349 1350 TestDelegate d; 1351 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1352 req.set_method("GET"); 1353 req.Start(); 1354 base::MessageLoop::current()->Run(); 1355 1356 // Check the interceptor got called as expected 1357 EXPECT_TRUE(interceptor.did_cancel_main_); 1358 EXPECT_FALSE(interceptor.did_intercept_final_); 1359 1360 // Check we see a canceled request 1361 EXPECT_FALSE(req.status().is_success()); 1362 EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status()); 1363 } 1364 1365 TEST_F(URLRequestTest, InterceptRespectsCancelRedirect) { 1366 TestInterceptor interceptor; 1367 1368 // intercept the main request and respond with a redirect 1369 interceptor.intercept_main_request_ = true; 1370 interceptor.main_headers_ = TestInterceptor::redirect_headers(); 1371 interceptor.main_data_ = TestInterceptor::redirect_data(); 1372 1373 // intercept the redirect and cancel from within that job 1374 interceptor.cancel_redirect_request_ = true; 1375 1376 // setup to intercept final response and override it with an OK response 1377 interceptor.intercept_final_response_ = true; 1378 interceptor.final_headers_ = TestInterceptor::ok_headers(); 1379 interceptor.final_data_ = TestInterceptor::ok_data(); 1380 1381 TestDelegate d; 1382 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1383 req.set_method("GET"); 1384 req.Start(); 1385 base::MessageLoop::current()->Run(); 1386 1387 // Check the interceptor got called as expected 1388 EXPECT_TRUE(interceptor.did_intercept_main_); 1389 EXPECT_TRUE(interceptor.did_cancel_redirect_); 1390 EXPECT_FALSE(interceptor.did_intercept_final_); 1391 1392 // Check we see a canceled request 1393 EXPECT_FALSE(req.status().is_success()); 1394 EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status()); 1395 } 1396 1397 TEST_F(URLRequestTest, InterceptRespectsCancelFinal) { 1398 TestInterceptor interceptor; 1399 1400 // intercept the main request to simulate a network error 1401 interceptor.simulate_main_network_error_ = true; 1402 1403 // setup to intercept final response and cancel from within that job 1404 interceptor.cancel_final_request_ = true; 1405 1406 TestDelegate d; 1407 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1408 req.set_method("GET"); 1409 req.Start(); 1410 base::MessageLoop::current()->Run(); 1411 1412 // Check the interceptor got called as expected 1413 EXPECT_TRUE(interceptor.did_simulate_error_main_); 1414 EXPECT_TRUE(interceptor.did_cancel_final_); 1415 1416 // Check we see a canceled request 1417 EXPECT_FALSE(req.status().is_success()); 1418 EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status()); 1419 } 1420 1421 TEST_F(URLRequestTest, InterceptRespectsCancelInRestart) { 1422 TestInterceptor interceptor; 1423 1424 // intercept the main request and cancel then restart from within that job 1425 interceptor.cancel_then_restart_main_request_ = true; 1426 1427 // setup to intercept final response and override it with an OK response 1428 interceptor.intercept_final_response_ = true; 1429 interceptor.final_headers_ = TestInterceptor::ok_headers(); 1430 interceptor.final_data_ = TestInterceptor::ok_data(); 1431 1432 TestDelegate d; 1433 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1434 req.set_method("GET"); 1435 req.Start(); 1436 base::MessageLoop::current()->Run(); 1437 1438 // Check the interceptor got called as expected 1439 EXPECT_TRUE(interceptor.did_cancel_then_restart_main_); 1440 EXPECT_FALSE(interceptor.did_intercept_final_); 1441 1442 // Check we see a canceled request 1443 EXPECT_FALSE(req.status().is_success()); 1444 EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status()); 1445 } 1446 1447 LoadTimingInfo RunLoadTimingTest(const LoadTimingInfo& job_load_timing, 1448 URLRequestContext* context) { 1449 TestInterceptor interceptor; 1450 interceptor.intercept_main_request_ = true; 1451 interceptor.main_request_load_timing_info_ = job_load_timing; 1452 TestDelegate d; 1453 URLRequest req(GURL("http://test_intercept/foo"), &d, context); 1454 req.Start(); 1455 base::MessageLoop::current()->Run(); 1456 1457 LoadTimingInfo resulting_load_timing; 1458 req.GetLoadTimingInfo(&resulting_load_timing); 1459 1460 // None of these should be modified by the URLRequest. 1461 EXPECT_EQ(job_load_timing.socket_reused, resulting_load_timing.socket_reused); 1462 EXPECT_EQ(job_load_timing.socket_log_id, resulting_load_timing.socket_log_id); 1463 EXPECT_EQ(job_load_timing.send_start, resulting_load_timing.send_start); 1464 EXPECT_EQ(job_load_timing.send_end, resulting_load_timing.send_end); 1465 EXPECT_EQ(job_load_timing.receive_headers_end, 1466 resulting_load_timing.receive_headers_end); 1467 1468 return resulting_load_timing; 1469 } 1470 1471 // "Normal" LoadTimingInfo as returned by a job. Everything is in order, not 1472 // reused. |connect_time_flags| is used to indicate if there should be dns 1473 // or SSL times, and |used_proxy| is used for proxy times. 1474 LoadTimingInfo NormalLoadTimingInfo(base::TimeTicks now, 1475 int connect_time_flags, 1476 bool used_proxy) { 1477 LoadTimingInfo load_timing; 1478 load_timing.socket_log_id = 1; 1479 1480 if (used_proxy) { 1481 load_timing.proxy_resolve_start = now + base::TimeDelta::FromDays(1); 1482 load_timing.proxy_resolve_end = now + base::TimeDelta::FromDays(2); 1483 } 1484 1485 LoadTimingInfo::ConnectTiming& connect_timing = load_timing.connect_timing; 1486 if (connect_time_flags & CONNECT_TIMING_HAS_DNS_TIMES) { 1487 connect_timing.dns_start = now + base::TimeDelta::FromDays(3); 1488 connect_timing.dns_end = now + base::TimeDelta::FromDays(4); 1489 } 1490 connect_timing.connect_start = now + base::TimeDelta::FromDays(5); 1491 if (connect_time_flags & CONNECT_TIMING_HAS_SSL_TIMES) { 1492 connect_timing.ssl_start = now + base::TimeDelta::FromDays(6); 1493 connect_timing.ssl_end = now + base::TimeDelta::FromDays(7); 1494 } 1495 connect_timing.connect_end = now + base::TimeDelta::FromDays(8); 1496 1497 load_timing.send_start = now + base::TimeDelta::FromDays(9); 1498 load_timing.send_end = now + base::TimeDelta::FromDays(10); 1499 load_timing.receive_headers_end = now + base::TimeDelta::FromDays(11); 1500 return load_timing; 1501 } 1502 1503 // Same as above, but in the case of a reused socket. 1504 LoadTimingInfo NormalLoadTimingInfoReused(base::TimeTicks now, 1505 bool used_proxy) { 1506 LoadTimingInfo load_timing; 1507 load_timing.socket_log_id = 1; 1508 load_timing.socket_reused = true; 1509 1510 if (used_proxy) { 1511 load_timing.proxy_resolve_start = now + base::TimeDelta::FromDays(1); 1512 load_timing.proxy_resolve_end = now + base::TimeDelta::FromDays(2); 1513 } 1514 1515 load_timing.send_start = now + base::TimeDelta::FromDays(9); 1516 load_timing.send_end = now + base::TimeDelta::FromDays(10); 1517 load_timing.receive_headers_end = now + base::TimeDelta::FromDays(11); 1518 return load_timing; 1519 } 1520 1521 // Basic test that the intercept + load timing tests work. 1522 TEST_F(URLRequestTest, InterceptLoadTiming) { 1523 base::TimeTicks now = base::TimeTicks::Now(); 1524 LoadTimingInfo job_load_timing = 1525 NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_DNS_TIMES, false); 1526 1527 LoadTimingInfo load_timing_result = RunLoadTimingTest(job_load_timing, 1528 &default_context_); 1529 1530 // Nothing should have been changed by the URLRequest. 1531 EXPECT_EQ(job_load_timing.proxy_resolve_start, 1532 load_timing_result.proxy_resolve_start); 1533 EXPECT_EQ(job_load_timing.proxy_resolve_end, 1534 load_timing_result.proxy_resolve_end); 1535 EXPECT_EQ(job_load_timing.connect_timing.dns_start, 1536 load_timing_result.connect_timing.dns_start); 1537 EXPECT_EQ(job_load_timing.connect_timing.dns_end, 1538 load_timing_result.connect_timing.dns_end); 1539 EXPECT_EQ(job_load_timing.connect_timing.connect_start, 1540 load_timing_result.connect_timing.connect_start); 1541 EXPECT_EQ(job_load_timing.connect_timing.connect_end, 1542 load_timing_result.connect_timing.connect_end); 1543 EXPECT_EQ(job_load_timing.connect_timing.ssl_start, 1544 load_timing_result.connect_timing.ssl_start); 1545 EXPECT_EQ(job_load_timing.connect_timing.ssl_end, 1546 load_timing_result.connect_timing.ssl_end); 1547 1548 // Redundant sanity check. 1549 TestLoadTimingNotReused(load_timing_result, CONNECT_TIMING_HAS_DNS_TIMES); 1550 } 1551 1552 // Another basic test, with proxy and SSL times, but no DNS times. 1553 TEST_F(URLRequestTest, InterceptLoadTimingProxy) { 1554 base::TimeTicks now = base::TimeTicks::Now(); 1555 LoadTimingInfo job_load_timing = 1556 NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_SSL_TIMES, true); 1557 1558 LoadTimingInfo load_timing_result = RunLoadTimingTest(job_load_timing, 1559 &default_context_); 1560 1561 // Nothing should have been changed by the URLRequest. 1562 EXPECT_EQ(job_load_timing.proxy_resolve_start, 1563 load_timing_result.proxy_resolve_start); 1564 EXPECT_EQ(job_load_timing.proxy_resolve_end, 1565 load_timing_result.proxy_resolve_end); 1566 EXPECT_EQ(job_load_timing.connect_timing.dns_start, 1567 load_timing_result.connect_timing.dns_start); 1568 EXPECT_EQ(job_load_timing.connect_timing.dns_end, 1569 load_timing_result.connect_timing.dns_end); 1570 EXPECT_EQ(job_load_timing.connect_timing.connect_start, 1571 load_timing_result.connect_timing.connect_start); 1572 EXPECT_EQ(job_load_timing.connect_timing.connect_end, 1573 load_timing_result.connect_timing.connect_end); 1574 EXPECT_EQ(job_load_timing.connect_timing.ssl_start, 1575 load_timing_result.connect_timing.ssl_start); 1576 EXPECT_EQ(job_load_timing.connect_timing.ssl_end, 1577 load_timing_result.connect_timing.ssl_end); 1578 1579 // Redundant sanity check. 1580 TestLoadTimingNotReusedWithProxy(load_timing_result, 1581 CONNECT_TIMING_HAS_SSL_TIMES); 1582 } 1583 1584 // Make sure that URLRequest correctly adjusts proxy times when they're before 1585 // |request_start|, due to already having a connected socket. This happens in 1586 // the case of reusing a SPDY session or HTTP pipeline. The connected socket is 1587 // not considered reused in this test (May be a preconnect). 1588 // 1589 // To mix things up from the test above, assumes DNS times but no SSL times. 1590 TEST_F(URLRequestTest, InterceptLoadTimingEarlyProxyResolution) { 1591 base::TimeTicks now = base::TimeTicks::Now(); 1592 LoadTimingInfo job_load_timing = 1593 NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_DNS_TIMES, true); 1594 job_load_timing.proxy_resolve_start = now - base::TimeDelta::FromDays(6); 1595 job_load_timing.proxy_resolve_end = now - base::TimeDelta::FromDays(5); 1596 job_load_timing.connect_timing.dns_start = now - base::TimeDelta::FromDays(4); 1597 job_load_timing.connect_timing.dns_end = now - base::TimeDelta::FromDays(3); 1598 job_load_timing.connect_timing.connect_start = 1599 now - base::TimeDelta::FromDays(2); 1600 job_load_timing.connect_timing.connect_end = 1601 now - base::TimeDelta::FromDays(1); 1602 1603 LoadTimingInfo load_timing_result = RunLoadTimingTest(job_load_timing, 1604 &default_context_); 1605 1606 // Proxy times, connect times, and DNS times should all be replaced with 1607 // request_start. 1608 EXPECT_EQ(load_timing_result.request_start, 1609 load_timing_result.proxy_resolve_start); 1610 EXPECT_EQ(load_timing_result.request_start, 1611 load_timing_result.proxy_resolve_end); 1612 EXPECT_EQ(load_timing_result.request_start, 1613 load_timing_result.connect_timing.dns_start); 1614 EXPECT_EQ(load_timing_result.request_start, 1615 load_timing_result.connect_timing.dns_end); 1616 EXPECT_EQ(load_timing_result.request_start, 1617 load_timing_result.connect_timing.connect_start); 1618 EXPECT_EQ(load_timing_result.request_start, 1619 load_timing_result.connect_timing.connect_end); 1620 1621 // Other times should have been left null. 1622 TestLoadTimingNotReusedWithProxy(load_timing_result, 1623 CONNECT_TIMING_HAS_DNS_TIMES); 1624 } 1625 1626 // Same as above, but in the reused case. 1627 TEST_F(URLRequestTest, InterceptLoadTimingEarlyProxyResolutionReused) { 1628 base::TimeTicks now = base::TimeTicks::Now(); 1629 LoadTimingInfo job_load_timing = NormalLoadTimingInfoReused(now, true); 1630 job_load_timing.proxy_resolve_start = now - base::TimeDelta::FromDays(4); 1631 job_load_timing.proxy_resolve_end = now - base::TimeDelta::FromDays(3); 1632 1633 LoadTimingInfo load_timing_result = RunLoadTimingTest(job_load_timing, 1634 &default_context_); 1635 1636 // Proxy times and connect times should all be replaced with request_start. 1637 EXPECT_EQ(load_timing_result.request_start, 1638 load_timing_result.proxy_resolve_start); 1639 EXPECT_EQ(load_timing_result.request_start, 1640 load_timing_result.proxy_resolve_end); 1641 1642 // Other times should have been left null. 1643 TestLoadTimingReusedWithProxy(load_timing_result); 1644 } 1645 1646 // Make sure that URLRequest correctly adjusts connect times when they're before 1647 // |request_start|, due to reusing a connected socket. The connected socket is 1648 // not considered reused in this test (May be a preconnect). 1649 // 1650 // To mix things up, the request has SSL times, but no DNS times. 1651 TEST_F(URLRequestTest, InterceptLoadTimingEarlyConnect) { 1652 base::TimeTicks now = base::TimeTicks::Now(); 1653 LoadTimingInfo job_load_timing = 1654 NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_SSL_TIMES, false); 1655 job_load_timing.connect_timing.connect_start = 1656 now - base::TimeDelta::FromDays(1); 1657 job_load_timing.connect_timing.ssl_start = now - base::TimeDelta::FromDays(2); 1658 job_load_timing.connect_timing.ssl_end = now - base::TimeDelta::FromDays(3); 1659 job_load_timing.connect_timing.connect_end = 1660 now - base::TimeDelta::FromDays(4); 1661 1662 LoadTimingInfo load_timing_result = RunLoadTimingTest(job_load_timing, 1663 &default_context_); 1664 1665 // Connect times, and SSL times should be replaced with request_start. 1666 EXPECT_EQ(load_timing_result.request_start, 1667 load_timing_result.connect_timing.connect_start); 1668 EXPECT_EQ(load_timing_result.request_start, 1669 load_timing_result.connect_timing.ssl_start); 1670 EXPECT_EQ(load_timing_result.request_start, 1671 load_timing_result.connect_timing.ssl_end); 1672 EXPECT_EQ(load_timing_result.request_start, 1673 load_timing_result.connect_timing.connect_end); 1674 1675 // Other times should have been left null. 1676 TestLoadTimingNotReused(load_timing_result, CONNECT_TIMING_HAS_SSL_TIMES); 1677 } 1678 1679 // Make sure that URLRequest correctly adjusts connect times when they're before 1680 // |request_start|, due to reusing a connected socket in the case that there 1681 // are also proxy times. The connected socket is not considered reused in this 1682 // test (May be a preconnect). 1683 // 1684 // In this test, there are no SSL or DNS times. 1685 TEST_F(URLRequestTest, InterceptLoadTimingEarlyConnectWithProxy) { 1686 base::TimeTicks now = base::TimeTicks::Now(); 1687 LoadTimingInfo job_load_timing = 1688 NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY, true); 1689 job_load_timing.connect_timing.connect_start = 1690 now - base::TimeDelta::FromDays(1); 1691 job_load_timing.connect_timing.connect_end = 1692 now - base::TimeDelta::FromDays(2); 1693 1694 LoadTimingInfo load_timing_result = RunLoadTimingTest(job_load_timing, 1695 &default_context_); 1696 1697 // Connect times should be replaced with proxy_resolve_end. 1698 EXPECT_EQ(load_timing_result.proxy_resolve_end, 1699 load_timing_result.connect_timing.connect_start); 1700 EXPECT_EQ(load_timing_result.proxy_resolve_end, 1701 load_timing_result.connect_timing.connect_end); 1702 1703 // Other times should have been left null. 1704 TestLoadTimingNotReusedWithProxy(load_timing_result, 1705 CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY); 1706 } 1707 1708 // Check that two different URL requests have different identifiers. 1709 TEST_F(URLRequestTest, Identifiers) { 1710 TestDelegate d; 1711 TestURLRequestContext context; 1712 TestURLRequest req(GURL("http://example.com"), &d, &context, NULL); 1713 TestURLRequest other_req(GURL("http://example.com"), &d, &context, NULL); 1714 1715 ASSERT_NE(req.identifier(), other_req.identifier()); 1716 } 1717 1718 // Check that a failure to connect to the proxy is reported to the network 1719 // delegate. 1720 TEST_F(URLRequestTest, NetworkDelegateProxyError) { 1721 MockHostResolver host_resolver; 1722 host_resolver.rules()->AddSimulatedFailure("*"); 1723 1724 TestNetworkDelegate network_delegate; // Must outlive URLRequests. 1725 TestURLRequestContextWithProxy context("myproxy:70", &network_delegate); 1726 1727 TestDelegate d; 1728 URLRequest req(GURL("http://example.com"), &d, &context); 1729 req.set_method("GET"); 1730 1731 req.Start(); 1732 base::MessageLoop::current()->Run(); 1733 1734 // Check we see a failed request. 1735 EXPECT_FALSE(req.status().is_success()); 1736 EXPECT_EQ(URLRequestStatus::FAILED, req.status().status()); 1737 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req.status().error()); 1738 1739 EXPECT_EQ(1, network_delegate.error_count()); 1740 EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error()); 1741 EXPECT_EQ(1, network_delegate.completed_requests()); 1742 } 1743 1744 // Make sure that net::NetworkDelegate::NotifyCompleted is called if 1745 // content is empty. 1746 TEST_F(URLRequestTest, RequestCompletionForEmptyResponse) { 1747 TestDelegate d; 1748 URLRequest req(GURL("data:,"), &d, &default_context_); 1749 req.Start(); 1750 base::MessageLoop::current()->Run(); 1751 EXPECT_EQ("", d.data_received()); 1752 EXPECT_EQ(1, default_network_delegate_.completed_requests()); 1753 } 1754 1755 // Make sure that SetPriority actually sets the URLRequest's priority 1756 // correctly, both before and after start. 1757 TEST_F(URLRequestTest, SetPriorityBasic) { 1758 TestDelegate d; 1759 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1760 EXPECT_EQ(DEFAULT_PRIORITY, req.priority()); 1761 1762 req.SetPriority(LOW); 1763 EXPECT_EQ(LOW, req.priority()); 1764 1765 req.Start(); 1766 EXPECT_EQ(LOW, req.priority()); 1767 1768 req.SetPriority(MEDIUM); 1769 EXPECT_EQ(MEDIUM, req.priority()); 1770 } 1771 1772 // Make sure that URLRequest calls SetPriority on a job before calling 1773 // Start on it. 1774 TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) { 1775 TestDelegate d; 1776 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1777 EXPECT_EQ(DEFAULT_PRIORITY, req.priority()); 1778 1779 scoped_refptr<URLRequestTestJob> job = 1780 new URLRequestTestJob(&req, &default_network_delegate_); 1781 AddTestInterceptor()->set_main_intercept_job(job.get()); 1782 EXPECT_EQ(DEFAULT_PRIORITY, job->priority()); 1783 1784 req.SetPriority(LOW); 1785 1786 req.Start(); 1787 EXPECT_EQ(LOW, job->priority()); 1788 } 1789 1790 // Make sure that URLRequest passes on its priority updates to its 1791 // job. 1792 TEST_F(URLRequestTest, SetJobPriority) { 1793 TestDelegate d; 1794 URLRequest req(GURL("http://test_intercept/foo"), &d, &default_context_); 1795 1796 scoped_refptr<URLRequestTestJob> job = 1797 new URLRequestTestJob(&req, &default_network_delegate_); 1798 AddTestInterceptor()->set_main_intercept_job(job.get()); 1799 1800 req.SetPriority(LOW); 1801 req.Start(); 1802 EXPECT_EQ(LOW, job->priority()); 1803 1804 req.SetPriority(MEDIUM); 1805 EXPECT_EQ(MEDIUM, req.priority()); 1806 EXPECT_EQ(MEDIUM, job->priority()); 1807 } 1808 1809 // TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666). 1810 #if !defined(OS_IOS) 1811 // A subclass of SpawnedTestServer that uses a statically-configured hostname. 1812 // This is to work around mysterious failures in chrome_frame_net_tests. See: 1813 // http://crbug.com/114369 1814 class LocalHttpTestServer : public SpawnedTestServer { 1815 public: 1816 explicit LocalHttpTestServer(const base::FilePath& document_root) 1817 : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP, 1818 ScopedCustomUrlRequestTestHttpHost::value(), 1819 document_root) {} 1820 LocalHttpTestServer() 1821 : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP, 1822 ScopedCustomUrlRequestTestHttpHost::value(), 1823 base::FilePath()) {} 1824 }; 1825 1826 TEST_F(URLRequestTest, DelayedCookieCallback) { 1827 LocalHttpTestServer test_server; 1828 ASSERT_TRUE(test_server.Start()); 1829 1830 TestURLRequestContext context; 1831 scoped_refptr<DelayedCookieMonster> delayed_cm = 1832 new DelayedCookieMonster(); 1833 scoped_refptr<CookieStore> cookie_store = delayed_cm; 1834 context.set_cookie_store(delayed_cm.get()); 1835 1836 // Set up a cookie. 1837 { 1838 TestNetworkDelegate network_delegate; 1839 context.set_network_delegate(&network_delegate); 1840 TestDelegate d; 1841 URLRequest req( 1842 test_server.GetURL("set-cookie?CookieToNotSend=1"), &d, &context); 1843 req.Start(); 1844 base::MessageLoop::current()->Run(); 1845 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1846 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1847 EXPECT_EQ(1, network_delegate.set_cookie_count()); 1848 } 1849 1850 // Verify that the cookie is set. 1851 { 1852 TestNetworkDelegate network_delegate; 1853 context.set_network_delegate(&network_delegate); 1854 TestDelegate d; 1855 URLRequest req(test_server.GetURL("echoheader?Cookie"), &d, &context); 1856 req.Start(); 1857 base::MessageLoop::current()->Run(); 1858 1859 EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") 1860 != std::string::npos); 1861 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1862 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1863 } 1864 } 1865 1866 TEST_F(URLRequestTest, DoNotSendCookies) { 1867 LocalHttpTestServer test_server; 1868 ASSERT_TRUE(test_server.Start()); 1869 1870 // Set up a cookie. 1871 { 1872 TestNetworkDelegate network_delegate; 1873 default_context_.set_network_delegate(&network_delegate); 1874 TestDelegate d; 1875 URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), 1876 &d, 1877 &default_context_); 1878 req.Start(); 1879 base::MessageLoop::current()->Run(); 1880 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1881 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1882 } 1883 1884 // Verify that the cookie is set. 1885 { 1886 TestNetworkDelegate network_delegate; 1887 default_context_.set_network_delegate(&network_delegate); 1888 TestDelegate d; 1889 URLRequest req( 1890 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 1891 req.Start(); 1892 base::MessageLoop::current()->Run(); 1893 1894 EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") 1895 != std::string::npos); 1896 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1897 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1898 } 1899 1900 // Verify that the cookie isn't sent when LOAD_DO_NOT_SEND_COOKIES is set. 1901 { 1902 TestNetworkDelegate network_delegate; 1903 default_context_.set_network_delegate(&network_delegate); 1904 TestDelegate d; 1905 URLRequest req( 1906 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 1907 req.set_load_flags(LOAD_DO_NOT_SEND_COOKIES); 1908 req.Start(); 1909 base::MessageLoop::current()->Run(); 1910 1911 EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1") 1912 == std::string::npos); 1913 1914 // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies. 1915 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1916 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1917 } 1918 } 1919 1920 TEST_F(URLRequestTest, DoNotSaveCookies) { 1921 LocalHttpTestServer test_server; 1922 ASSERT_TRUE(test_server.Start()); 1923 1924 // Set up a cookie. 1925 { 1926 TestNetworkDelegate network_delegate; 1927 default_context_.set_network_delegate(&network_delegate); 1928 TestDelegate d; 1929 URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"), 1930 &d, 1931 &default_context_); 1932 req.Start(); 1933 base::MessageLoop::current()->Run(); 1934 1935 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1936 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1937 EXPECT_EQ(1, network_delegate.set_cookie_count()); 1938 } 1939 1940 // Try to set-up another cookie and update the previous cookie. 1941 { 1942 TestNetworkDelegate network_delegate; 1943 default_context_.set_network_delegate(&network_delegate); 1944 TestDelegate d; 1945 URLRequest req( 1946 test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"), 1947 &d, 1948 &default_context_); 1949 req.set_load_flags(LOAD_DO_NOT_SAVE_COOKIES); 1950 req.Start(); 1951 1952 base::MessageLoop::current()->Run(); 1953 1954 // LOAD_DO_NOT_SAVE_COOKIES does not trigger OnSetCookie. 1955 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1956 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1957 EXPECT_EQ(0, network_delegate.set_cookie_count()); 1958 } 1959 1960 // Verify the cookies weren't saved or updated. 1961 { 1962 TestNetworkDelegate network_delegate; 1963 default_context_.set_network_delegate(&network_delegate); 1964 TestDelegate d; 1965 URLRequest req( 1966 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 1967 req.Start(); 1968 base::MessageLoop::current()->Run(); 1969 1970 EXPECT_TRUE(d.data_received().find("CookieToNotSave=1") 1971 == std::string::npos); 1972 EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2") 1973 != std::string::npos); 1974 1975 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1976 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1977 EXPECT_EQ(0, network_delegate.set_cookie_count()); 1978 } 1979 } 1980 1981 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) { 1982 LocalHttpTestServer test_server; 1983 ASSERT_TRUE(test_server.Start()); 1984 1985 // Set up a cookie. 1986 { 1987 TestNetworkDelegate network_delegate; 1988 default_context_.set_network_delegate(&network_delegate); 1989 TestDelegate d; 1990 URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), 1991 &d, 1992 &default_context_); 1993 req.Start(); 1994 base::MessageLoop::current()->Run(); 1995 1996 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 1997 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 1998 } 1999 2000 // Verify that the cookie is set. 2001 { 2002 TestNetworkDelegate network_delegate; 2003 default_context_.set_network_delegate(&network_delegate); 2004 TestDelegate d; 2005 URLRequest req( 2006 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2007 req.Start(); 2008 base::MessageLoop::current()->Run(); 2009 2010 EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") 2011 != std::string::npos); 2012 2013 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2014 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2015 } 2016 2017 // Verify that the cookie isn't sent. 2018 { 2019 TestNetworkDelegate network_delegate; 2020 default_context_.set_network_delegate(&network_delegate); 2021 TestDelegate d; 2022 network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES); 2023 URLRequest req( 2024 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2025 req.Start(); 2026 base::MessageLoop::current()->Run(); 2027 2028 EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1") 2029 == std::string::npos); 2030 2031 EXPECT_EQ(1, network_delegate.blocked_get_cookies_count()); 2032 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2033 } 2034 } 2035 2036 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) { 2037 LocalHttpTestServer test_server; 2038 ASSERT_TRUE(test_server.Start()); 2039 2040 // Set up a cookie. 2041 { 2042 TestNetworkDelegate network_delegate; 2043 default_context_.set_network_delegate(&network_delegate); 2044 TestDelegate d; 2045 URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"), 2046 &d, 2047 &default_context_); 2048 req.Start(); 2049 base::MessageLoop::current()->Run(); 2050 2051 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2052 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2053 } 2054 2055 // Try to set-up another cookie and update the previous cookie. 2056 { 2057 TestNetworkDelegate network_delegate; 2058 default_context_.set_network_delegate(&network_delegate); 2059 TestDelegate d; 2060 network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE); 2061 URLRequest req( 2062 test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"), 2063 &d, 2064 &default_context_); 2065 req.Start(); 2066 2067 base::MessageLoop::current()->Run(); 2068 2069 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2070 EXPECT_EQ(2, network_delegate.blocked_set_cookie_count()); 2071 } 2072 2073 // Verify the cookies weren't saved or updated. 2074 { 2075 TestNetworkDelegate network_delegate; 2076 default_context_.set_network_delegate(&network_delegate); 2077 TestDelegate d; 2078 URLRequest req( 2079 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2080 req.Start(); 2081 base::MessageLoop::current()->Run(); 2082 2083 EXPECT_TRUE(d.data_received().find("CookieToNotSave=1") 2084 == std::string::npos); 2085 EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2") 2086 != std::string::npos); 2087 2088 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2089 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2090 } 2091 } 2092 2093 TEST_F(URLRequestTest, DoNotSaveEmptyCookies) { 2094 LocalHttpTestServer test_server; 2095 ASSERT_TRUE(test_server.Start()); 2096 2097 // Set up an empty cookie. 2098 { 2099 TestNetworkDelegate network_delegate; 2100 default_context_.set_network_delegate(&network_delegate); 2101 TestDelegate d; 2102 URLRequest req(test_server.GetURL("set-cookie"), &d, &default_context_); 2103 req.Start(); 2104 base::MessageLoop::current()->Run(); 2105 2106 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2107 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2108 EXPECT_EQ(0, network_delegate.set_cookie_count()); 2109 } 2110 } 2111 2112 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) { 2113 LocalHttpTestServer test_server; 2114 ASSERT_TRUE(test_server.Start()); 2115 2116 // Set up a cookie. 2117 { 2118 TestNetworkDelegate network_delegate; 2119 default_context_.set_network_delegate(&network_delegate); 2120 TestDelegate d; 2121 URLRequest req(test_server.GetURL("set-cookie?CookieToNotSend=1"), 2122 &d, 2123 &default_context_); 2124 req.Start(); 2125 base::MessageLoop::current()->Run(); 2126 2127 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2128 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2129 } 2130 2131 // Verify that the cookie is set. 2132 { 2133 TestNetworkDelegate network_delegate; 2134 default_context_.set_network_delegate(&network_delegate); 2135 TestDelegate d; 2136 URLRequest req( 2137 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2138 req.Start(); 2139 base::MessageLoop::current()->Run(); 2140 2141 EXPECT_TRUE(d.data_received().find("CookieToNotSend=1") 2142 != std::string::npos); 2143 2144 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2145 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2146 } 2147 2148 // Verify that the cookie isn't sent. 2149 { 2150 TestNetworkDelegate network_delegate; 2151 default_context_.set_network_delegate(&network_delegate); 2152 TestDelegate d; 2153 network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES); 2154 URLRequest req( 2155 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2156 req.Start(); 2157 base::MessageLoop::current()->Run(); 2158 2159 EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1") 2160 == std::string::npos); 2161 2162 EXPECT_EQ(1, network_delegate.blocked_get_cookies_count()); 2163 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2164 } 2165 } 2166 2167 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) { 2168 LocalHttpTestServer test_server; 2169 ASSERT_TRUE(test_server.Start()); 2170 2171 // Set up a cookie. 2172 { 2173 TestNetworkDelegate network_delegate; 2174 default_context_.set_network_delegate(&network_delegate); 2175 TestDelegate d; 2176 URLRequest req(test_server.GetURL("set-cookie?CookieToNotUpdate=2"), 2177 &d, 2178 &default_context_); 2179 req.Start(); 2180 base::MessageLoop::current()->Run(); 2181 2182 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2183 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2184 } 2185 2186 // Try to set-up another cookie and update the previous cookie. 2187 { 2188 TestNetworkDelegate network_delegate; 2189 default_context_.set_network_delegate(&network_delegate); 2190 TestDelegate d; 2191 network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE); 2192 URLRequest req( 2193 test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"), 2194 &d, 2195 &default_context_); 2196 req.Start(); 2197 2198 base::MessageLoop::current()->Run(); 2199 2200 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2201 EXPECT_EQ(2, network_delegate.blocked_set_cookie_count()); 2202 } 2203 2204 // Verify the cookies weren't saved or updated. 2205 { 2206 TestNetworkDelegate network_delegate; 2207 default_context_.set_network_delegate(&network_delegate); 2208 TestDelegate d; 2209 URLRequest req( 2210 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2211 req.Start(); 2212 base::MessageLoop::current()->Run(); 2213 2214 EXPECT_TRUE(d.data_received().find("CookieToNotSave=1") 2215 == std::string::npos); 2216 EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2") 2217 != std::string::npos); 2218 2219 EXPECT_EQ(0, network_delegate.blocked_get_cookies_count()); 2220 EXPECT_EQ(0, network_delegate.blocked_set_cookie_count()); 2221 } 2222 } 2223 2224 // FixedDateNetworkDelegate swaps out the server's HTTP Date response header 2225 // value for the |fixed_date| argument given to the constructor. 2226 class FixedDateNetworkDelegate : public TestNetworkDelegate { 2227 public: 2228 explicit FixedDateNetworkDelegate(const std::string& fixed_date) 2229 : fixed_date_(fixed_date) {} 2230 virtual ~FixedDateNetworkDelegate() {} 2231 2232 // net::NetworkDelegate implementation 2233 virtual int OnHeadersReceived( 2234 net::URLRequest* request, 2235 const net::CompletionCallback& callback, 2236 const net::HttpResponseHeaders* original_response_headers, 2237 scoped_refptr<net::HttpResponseHeaders>* override_response_headers) 2238 OVERRIDE; 2239 2240 private: 2241 std::string fixed_date_; 2242 2243 DISALLOW_COPY_AND_ASSIGN(FixedDateNetworkDelegate); 2244 }; 2245 2246 int FixedDateNetworkDelegate::OnHeadersReceived( 2247 net::URLRequest* request, 2248 const net::CompletionCallback& callback, 2249 const net::HttpResponseHeaders* original_response_headers, 2250 scoped_refptr<net::HttpResponseHeaders>* override_response_headers) { 2251 net::HttpResponseHeaders* new_response_headers = 2252 new net::HttpResponseHeaders(original_response_headers->raw_headers()); 2253 2254 new_response_headers->RemoveHeader("Date"); 2255 new_response_headers->AddHeader("Date: " + fixed_date_); 2256 2257 *override_response_headers = new_response_headers; 2258 return TestNetworkDelegate::OnHeadersReceived(request, 2259 callback, 2260 original_response_headers, 2261 override_response_headers); 2262 } 2263 2264 // Test that cookie expiration times are adjusted for server/client clock 2265 // skew and that we handle incorrect timezone specifier "UTC" in HTTP Date 2266 // headers by defaulting to GMT. (crbug.com/135131) 2267 TEST_F(URLRequestTest, AcceptClockSkewCookieWithWrongDateTimezone) { 2268 LocalHttpTestServer test_server; 2269 ASSERT_TRUE(test_server.Start()); 2270 2271 // Set up an expired cookie. 2272 { 2273 TestNetworkDelegate network_delegate; 2274 default_context_.set_network_delegate(&network_delegate); 2275 TestDelegate d; 2276 URLRequest req(test_server.GetURL( 2277 "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"), 2278 &d, 2279 &default_context_); 2280 req.Start(); 2281 base::MessageLoop::current()->Run(); 2282 } 2283 // Verify that the cookie is not set. 2284 { 2285 TestNetworkDelegate network_delegate; 2286 default_context_.set_network_delegate(&network_delegate); 2287 TestDelegate d; 2288 URLRequest req( 2289 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2290 req.Start(); 2291 base::MessageLoop::current()->Run(); 2292 2293 EXPECT_TRUE(d.data_received().find("StillGood=1") == std::string::npos); 2294 } 2295 // Set up a cookie with clock skew and "UTC" HTTP Date timezone specifier. 2296 { 2297 FixedDateNetworkDelegate network_delegate("18-Apr-1977 22:49:13 UTC"); 2298 default_context_.set_network_delegate(&network_delegate); 2299 TestDelegate d; 2300 URLRequest req(test_server.GetURL( 2301 "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"), 2302 &d, 2303 &default_context_); 2304 req.Start(); 2305 base::MessageLoop::current()->Run(); 2306 } 2307 // Verify that the cookie is set. 2308 { 2309 TestNetworkDelegate network_delegate; 2310 default_context_.set_network_delegate(&network_delegate); 2311 TestDelegate d; 2312 URLRequest req( 2313 test_server.GetURL("echoheader?Cookie"), &d, &default_context_); 2314 req.Start(); 2315 base::MessageLoop::current()->Run(); 2316 2317 EXPECT_TRUE(d.data_received().find("StillGood=1") != std::string::npos); 2318 } 2319 } 2320 2321 2322 // Check that it is impossible to change the referrer in the extra headers of 2323 // an URLRequest. 2324 TEST_F(URLRequestTest, DoNotOverrideReferrer) { 2325 LocalHttpTestServer test_server; 2326 ASSERT_TRUE(test_server.Start()); 2327 2328 // If extra headers contain referer and the request contains a referer, 2329 // only the latter shall be respected. 2330 { 2331 TestDelegate d; 2332 URLRequest req( 2333 test_server.GetURL("echoheader?Referer"), &d, &default_context_); 2334 req.SetReferrer("http://foo.com/"); 2335 2336 HttpRequestHeaders headers; 2337 headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/"); 2338 req.SetExtraRequestHeaders(headers); 2339 2340 req.Start(); 2341 base::MessageLoop::current()->Run(); 2342 2343 EXPECT_EQ("http://foo.com/", d.data_received()); 2344 } 2345 2346 // If extra headers contain a referer but the request does not, no referer 2347 // shall be sent in the header. 2348 { 2349 TestDelegate d; 2350 URLRequest req( 2351 test_server.GetURL("echoheader?Referer"), &d, &default_context_); 2352 2353 HttpRequestHeaders headers; 2354 headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/"); 2355 req.SetExtraRequestHeaders(headers); 2356 req.set_load_flags(LOAD_VALIDATE_CACHE); 2357 2358 req.Start(); 2359 base::MessageLoop::current()->Run(); 2360 2361 EXPECT_EQ("None", d.data_received()); 2362 } 2363 } 2364 2365 class URLRequestTestHTTP : public URLRequestTest { 2366 public: 2367 URLRequestTestHTTP() 2368 : test_server_(base::FilePath(FILE_PATH_LITERAL( 2369 "net/data/url_request_unittest"))) { 2370 } 2371 2372 protected: 2373 // Requests |redirect_url|, which must return a HTTP 3xx redirect. 2374 // |request_method| is the method to use for the initial request. 2375 // |redirect_method| is the method that is expected to be used for the second 2376 // request, after redirection. 2377 // If |include_data| is true, data is uploaded with the request. The 2378 // response body is expected to match it exactly, if and only if 2379 // |request_method| == |redirect_method|. 2380 void HTTPRedirectMethodTest(const GURL& redirect_url, 2381 const std::string& request_method, 2382 const std::string& redirect_method, 2383 bool include_data) { 2384 static const char kData[] = "hello world"; 2385 TestDelegate d; 2386 URLRequest req(redirect_url, &d, &default_context_); 2387 req.set_method(request_method); 2388 if (include_data) { 2389 req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData))); 2390 HttpRequestHeaders headers; 2391 headers.SetHeader(HttpRequestHeaders::kContentLength, 2392 base::UintToString(arraysize(kData) - 1)); 2393 req.SetExtraRequestHeaders(headers); 2394 } 2395 req.Start(); 2396 base::MessageLoop::current()->Run(); 2397 EXPECT_EQ(redirect_method, req.method()); 2398 EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status()); 2399 EXPECT_EQ(OK, req.status().error()); 2400 if (include_data) { 2401 if (request_method == redirect_method) { 2402 EXPECT_EQ(kData, d.data_received()); 2403 } else { 2404 EXPECT_NE(kData, d.data_received()); 2405 } 2406 } 2407 if (HasFailure()) 2408 LOG(WARNING) << "Request method was: " << request_method; 2409 } 2410 2411 void HTTPUploadDataOperationTest(const std::string& method) { 2412 const int kMsgSize = 20000; // multiple of 10 2413 const int kIterations = 50; 2414 char* uploadBytes = new char[kMsgSize+1]; 2415 char* ptr = uploadBytes; 2416 char marker = 'a'; 2417 for (int idx = 0; idx < kMsgSize/10; idx++) { 2418 memcpy(ptr, "----------", 10); 2419 ptr += 10; 2420 if (idx % 100 == 0) { 2421 ptr--; 2422 *ptr++ = marker; 2423 if (++marker > 'z') 2424 marker = 'a'; 2425 } 2426 } 2427 uploadBytes[kMsgSize] = '\0'; 2428 2429 for (int i = 0; i < kIterations; ++i) { 2430 TestDelegate d; 2431 URLRequest r(test_server_.GetURL("echo"), &d, &default_context_); 2432 r.set_method(method.c_str()); 2433 2434 r.set_upload(make_scoped_ptr(CreateSimpleUploadData(uploadBytes))); 2435 2436 r.Start(); 2437 EXPECT_TRUE(r.is_pending()); 2438 2439 base::MessageLoop::current()->Run(); 2440 2441 ASSERT_EQ(1, d.response_started_count()) 2442 << "request failed: " << r.status().status() 2443 << ", os error: " << r.status().error(); 2444 2445 EXPECT_FALSE(d.received_data_before_response()); 2446 EXPECT_EQ(uploadBytes, d.data_received()); 2447 } 2448 delete[] uploadBytes; 2449 } 2450 2451 void AddChunksToUpload(URLRequest* r) { 2452 r->AppendChunkToUpload("a", 1, false); 2453 r->AppendChunkToUpload("bcd", 3, false); 2454 r->AppendChunkToUpload("this is a longer chunk than before.", 35, false); 2455 r->AppendChunkToUpload("\r\n\r\n", 4, false); 2456 r->AppendChunkToUpload("0", 1, false); 2457 r->AppendChunkToUpload("2323", 4, true); 2458 } 2459 2460 void VerifyReceivedDataMatchesChunks(URLRequest* r, TestDelegate* d) { 2461 // This should match the chunks sent by AddChunksToUpload(). 2462 const std::string expected_data = 2463 "abcdthis is a longer chunk than before.\r\n\r\n02323"; 2464 2465 ASSERT_EQ(1, d->response_started_count()) 2466 << "request failed: " << r->status().status() 2467 << ", os error: " << r->status().error(); 2468 2469 EXPECT_FALSE(d->received_data_before_response()); 2470 2471 EXPECT_EQ(expected_data.size(), static_cast<size_t>(d->bytes_received())); 2472 EXPECT_EQ(expected_data, d->data_received()); 2473 } 2474 2475 bool DoManyCookiesRequest(int num_cookies) { 2476 TestDelegate d; 2477 URLRequest r(test_server_.GetURL("set-many-cookies?" + 2478 base::IntToString(num_cookies)), 2479 &d, 2480 &default_context_); 2481 2482 r.Start(); 2483 EXPECT_TRUE(r.is_pending()); 2484 2485 base::MessageLoop::current()->Run(); 2486 2487 bool is_success = r.status().is_success(); 2488 2489 if (!is_success) { 2490 // Requests handled by ChromeFrame send a less precise error message, 2491 // ERR_CONNECTION_ABORTED. 2492 EXPECT_TRUE(r.status().error() == ERR_RESPONSE_HEADERS_TOO_BIG || 2493 r.status().error() == ERR_CONNECTION_ABORTED); 2494 // The test server appears to be unable to handle subsequent requests 2495 // after this error is triggered. Force it to restart. 2496 EXPECT_TRUE(test_server_.Stop()); 2497 EXPECT_TRUE(test_server_.Start()); 2498 } 2499 2500 return is_success; 2501 } 2502 2503 LocalHttpTestServer test_server_; 2504 }; 2505 2506 // In this unit test, we're using the HTTPTestServer as a proxy server and 2507 // issuing a CONNECT request with the magic host name "www.redirect.com". 2508 // The HTTPTestServer will return a 302 response, which we should not 2509 // follow. 2510 TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) { 2511 ASSERT_TRUE(test_server_.Start()); 2512 2513 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 2514 TestURLRequestContextWithProxy context( 2515 test_server_.host_port_pair().ToString(), 2516 &network_delegate); 2517 2518 TestDelegate d; 2519 { 2520 URLRequest r(GURL("https://www.redirect.com/"), &d, &context); 2521 r.Start(); 2522 EXPECT_TRUE(r.is_pending()); 2523 2524 base::MessageLoop::current()->Run(); 2525 2526 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 2527 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error()); 2528 EXPECT_EQ(1, d.response_started_count()); 2529 // We should not have followed the redirect. 2530 EXPECT_EQ(0, d.received_redirect_count()); 2531 } 2532 } 2533 2534 // This is the same as the previous test, but checks that the network delegate 2535 // registers the error. 2536 TEST_F(URLRequestTestHTTP, NetworkDelegateTunnelConnectionFailed) { 2537 ASSERT_TRUE(test_server_.Start()); 2538 2539 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 2540 TestURLRequestContextWithProxy context( 2541 test_server_.host_port_pair().ToString(), 2542 &network_delegate); 2543 2544 TestDelegate d; 2545 { 2546 URLRequest r(GURL("https://www.redirect.com/"), &d, &context); 2547 r.Start(); 2548 EXPECT_TRUE(r.is_pending()); 2549 2550 base::MessageLoop::current()->Run(); 2551 2552 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 2553 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error()); 2554 EXPECT_EQ(1, d.response_started_count()); 2555 // We should not have followed the redirect. 2556 EXPECT_EQ(0, d.received_redirect_count()); 2557 2558 EXPECT_EQ(1, network_delegate.error_count()); 2559 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error()); 2560 } 2561 } 2562 2563 // Tests that we can block and asynchronously return OK in various stages. 2564 TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) { 2565 static const BlockingNetworkDelegate::Stage blocking_stages[] = { 2566 BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST, 2567 BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS, 2568 BlockingNetworkDelegate::ON_HEADERS_RECEIVED 2569 }; 2570 static const size_t blocking_stages_length = arraysize(blocking_stages); 2571 2572 ASSERT_TRUE(test_server_.Start()); 2573 2574 TestDelegate d; 2575 BlockingNetworkDelegate network_delegate( 2576 BlockingNetworkDelegate::USER_CALLBACK); 2577 network_delegate.set_block_on( 2578 BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST | 2579 BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS | 2580 BlockingNetworkDelegate::ON_HEADERS_RECEIVED); 2581 2582 TestURLRequestContext context(true); 2583 context.set_network_delegate(&network_delegate); 2584 context.Init(); 2585 2586 { 2587 URLRequest r(test_server_.GetURL("empty.html"), &d, &context); 2588 2589 r.Start(); 2590 for (size_t i = 0; i < blocking_stages_length; ++i) { 2591 base::MessageLoop::current()->Run(); 2592 EXPECT_EQ(blocking_stages[i], 2593 network_delegate.stage_blocked_for_callback()); 2594 network_delegate.DoCallback(OK); 2595 } 2596 base::MessageLoop::current()->Run(); 2597 EXPECT_EQ(200, r.GetResponseCode()); 2598 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2599 EXPECT_EQ(1, network_delegate.created_requests()); 2600 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2601 } 2602 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2603 } 2604 2605 // Tests that the network delegate can block and cancel a request. 2606 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) { 2607 ASSERT_TRUE(test_server_.Start()); 2608 2609 TestDelegate d; 2610 BlockingNetworkDelegate network_delegate( 2611 BlockingNetworkDelegate::AUTO_CALLBACK); 2612 network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST); 2613 network_delegate.set_retval(ERR_EMPTY_RESPONSE); 2614 2615 TestURLRequestContextWithProxy context( 2616 test_server_.host_port_pair().ToString(), 2617 &network_delegate); 2618 2619 { 2620 URLRequest r(test_server_.GetURL(std::string()), &d, &context); 2621 2622 r.Start(); 2623 base::MessageLoop::current()->Run(); 2624 2625 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 2626 EXPECT_EQ(ERR_EMPTY_RESPONSE, r.status().error()); 2627 EXPECT_EQ(1, network_delegate.created_requests()); 2628 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2629 } 2630 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2631 } 2632 2633 // Helper function for NetworkDelegateCancelRequestAsynchronously and 2634 // NetworkDelegateCancelRequestSynchronously. Sets up a blocking network 2635 // delegate operating in |block_mode| and a request for |url|. It blocks the 2636 // request in |stage| and cancels it with ERR_BLOCKED_BY_CLIENT. 2637 void NetworkDelegateCancelRequest(BlockingNetworkDelegate::BlockMode block_mode, 2638 BlockingNetworkDelegate::Stage stage, 2639 const GURL& url) { 2640 TestDelegate d; 2641 BlockingNetworkDelegate network_delegate(block_mode); 2642 network_delegate.set_retval(ERR_BLOCKED_BY_CLIENT); 2643 network_delegate.set_block_on(stage); 2644 2645 TestURLRequestContext context(true); 2646 context.set_network_delegate(&network_delegate); 2647 context.Init(); 2648 2649 { 2650 URLRequest r(url, &d, &context); 2651 2652 r.Start(); 2653 base::MessageLoop::current()->Run(); 2654 2655 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 2656 EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, r.status().error()); 2657 EXPECT_EQ(1, network_delegate.created_requests()); 2658 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2659 } 2660 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2661 } 2662 2663 // The following 3 tests check that the network delegate can cancel a request 2664 // synchronously in various stages of the request. 2665 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) { 2666 ASSERT_TRUE(test_server_.Start()); 2667 NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS, 2668 BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST, 2669 test_server_.GetURL(std::string())); 2670 } 2671 2672 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously2) { 2673 ASSERT_TRUE(test_server_.Start()); 2674 NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS, 2675 BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS, 2676 test_server_.GetURL(std::string())); 2677 } 2678 2679 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously3) { 2680 ASSERT_TRUE(test_server_.Start()); 2681 NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS, 2682 BlockingNetworkDelegate::ON_HEADERS_RECEIVED, 2683 test_server_.GetURL(std::string())); 2684 } 2685 2686 // The following 3 tests check that the network delegate can cancel a request 2687 // asynchronously in various stages of the request. 2688 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously1) { 2689 ASSERT_TRUE(test_server_.Start()); 2690 NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK, 2691 BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST, 2692 test_server_.GetURL(std::string())); 2693 } 2694 2695 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously2) { 2696 ASSERT_TRUE(test_server_.Start()); 2697 NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK, 2698 BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS, 2699 test_server_.GetURL(std::string())); 2700 } 2701 2702 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously3) { 2703 ASSERT_TRUE(test_server_.Start()); 2704 NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK, 2705 BlockingNetworkDelegate::ON_HEADERS_RECEIVED, 2706 test_server_.GetURL(std::string())); 2707 } 2708 2709 // Tests that the network delegate can block and redirect a request to a new 2710 // URL. 2711 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) { 2712 ASSERT_TRUE(test_server_.Start()); 2713 2714 TestDelegate d; 2715 BlockingNetworkDelegate network_delegate( 2716 BlockingNetworkDelegate::AUTO_CALLBACK); 2717 network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST); 2718 GURL redirect_url(test_server_.GetURL("simple.html")); 2719 network_delegate.set_redirect_url(redirect_url); 2720 2721 TestURLRequestContextWithProxy context( 2722 test_server_.host_port_pair().ToString(), 2723 &network_delegate); 2724 2725 { 2726 GURL original_url(test_server_.GetURL("empty.html")); 2727 URLRequest r(original_url, &d, &context); 2728 2729 r.Start(); 2730 base::MessageLoop::current()->Run(); 2731 2732 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2733 EXPECT_EQ(0, r.status().error()); 2734 EXPECT_EQ(redirect_url, r.url()); 2735 EXPECT_EQ(original_url, r.original_url()); 2736 EXPECT_EQ(2U, r.url_chain().size()); 2737 EXPECT_EQ(1, network_delegate.created_requests()); 2738 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2739 } 2740 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2741 } 2742 2743 // Tests that the network delegate can block and redirect a request to a new 2744 // URL by setting a redirect_url and returning in OnBeforeURLRequest directly. 2745 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestSynchronously) { 2746 ASSERT_TRUE(test_server_.Start()); 2747 2748 TestDelegate d; 2749 BlockingNetworkDelegate network_delegate( 2750 BlockingNetworkDelegate::SYNCHRONOUS); 2751 GURL redirect_url(test_server_.GetURL("simple.html")); 2752 network_delegate.set_redirect_url(redirect_url); 2753 2754 TestURLRequestContextWithProxy context( 2755 test_server_.host_port_pair().ToString(), 2756 &network_delegate); 2757 2758 { 2759 GURL original_url(test_server_.GetURL("empty.html")); 2760 URLRequest r(original_url, &d, &context); 2761 2762 r.Start(); 2763 base::MessageLoop::current()->Run(); 2764 2765 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2766 EXPECT_EQ(0, r.status().error()); 2767 EXPECT_EQ(redirect_url, r.url()); 2768 EXPECT_EQ(original_url, r.original_url()); 2769 EXPECT_EQ(2U, r.url_chain().size()); 2770 EXPECT_EQ(1, network_delegate.created_requests()); 2771 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2772 } 2773 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2774 } 2775 2776 // Tests that redirects caused by the network delegate preserve POST data. 2777 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestPost) { 2778 ASSERT_TRUE(test_server_.Start()); 2779 2780 const char kData[] = "hello world"; 2781 2782 TestDelegate d; 2783 BlockingNetworkDelegate network_delegate( 2784 BlockingNetworkDelegate::AUTO_CALLBACK); 2785 network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST); 2786 GURL redirect_url(test_server_.GetURL("echo")); 2787 network_delegate.set_redirect_url(redirect_url); 2788 2789 TestURLRequestContext context(true); 2790 context.set_network_delegate(&network_delegate); 2791 context.Init(); 2792 2793 { 2794 GURL original_url(test_server_.GetURL("empty.html")); 2795 URLRequest r(original_url, &d, &context); 2796 r.set_method("POST"); 2797 r.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData))); 2798 HttpRequestHeaders headers; 2799 headers.SetHeader(HttpRequestHeaders::kContentLength, 2800 base::UintToString(arraysize(kData) - 1)); 2801 r.SetExtraRequestHeaders(headers); 2802 r.Start(); 2803 base::MessageLoop::current()->Run(); 2804 2805 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2806 EXPECT_EQ(0, r.status().error()); 2807 EXPECT_EQ(redirect_url, r.url()); 2808 EXPECT_EQ(original_url, r.original_url()); 2809 EXPECT_EQ(2U, r.url_chain().size()); 2810 EXPECT_EQ(1, network_delegate.created_requests()); 2811 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2812 EXPECT_EQ("POST", r.method()); 2813 EXPECT_EQ(kData, d.data_received()); 2814 } 2815 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2816 } 2817 2818 // Tests that the network delegate can synchronously complete OnAuthRequired 2819 // by taking no action. This indicates that the NetworkDelegate does not want to 2820 // handle the challenge, and is passing the buck along to the 2821 // URLRequest::Delegate. 2822 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncNoAction) { 2823 ASSERT_TRUE(test_server_.Start()); 2824 2825 TestDelegate d; 2826 BlockingNetworkDelegate network_delegate( 2827 BlockingNetworkDelegate::SYNCHRONOUS); 2828 2829 TestURLRequestContext context(true); 2830 context.set_network_delegate(&network_delegate); 2831 context.Init(); 2832 2833 d.set_credentials(AuthCredentials(kUser, kSecret)); 2834 2835 { 2836 GURL url(test_server_.GetURL("auth-basic")); 2837 URLRequest r(url, &d, &context); 2838 r.Start(); 2839 2840 base::MessageLoop::current()->Run(); 2841 2842 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2843 EXPECT_EQ(0, r.status().error()); 2844 EXPECT_EQ(200, r.GetResponseCode()); 2845 EXPECT_TRUE(d.auth_required_called()); 2846 EXPECT_EQ(1, network_delegate.created_requests()); 2847 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2848 } 2849 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2850 } 2851 2852 TEST_F(URLRequestTestHTTP, 2853 NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) { 2854 ASSERT_TRUE(test_server_.Start()); 2855 2856 TestDelegate d; 2857 BlockingNetworkDelegate network_delegate( 2858 BlockingNetworkDelegate::SYNCHRONOUS); 2859 2860 TestURLRequestContext context(true); 2861 context.set_network_delegate(&network_delegate); 2862 context.Init(); 2863 2864 d.set_credentials(AuthCredentials(kUser, kSecret)); 2865 2866 { 2867 GURL url(test_server_.GetURL("auth-basic")); 2868 URLRequest r(url, &d, &context); 2869 r.Start(); 2870 2871 { 2872 HttpRequestHeaders headers; 2873 EXPECT_TRUE(r.GetFullRequestHeaders(&headers)); 2874 EXPECT_FALSE(headers.HasHeader("Authorization")); 2875 } 2876 2877 base::MessageLoop::current()->Run(); 2878 2879 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2880 EXPECT_EQ(0, r.status().error()); 2881 EXPECT_EQ(200, r.GetResponseCode()); 2882 EXPECT_TRUE(d.auth_required_called()); 2883 EXPECT_EQ(1, network_delegate.created_requests()); 2884 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2885 } 2886 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2887 } 2888 2889 // Tests that the network delegate can synchronously complete OnAuthRequired 2890 // by setting credentials. 2891 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncSetAuth) { 2892 ASSERT_TRUE(test_server_.Start()); 2893 2894 TestDelegate d; 2895 BlockingNetworkDelegate network_delegate( 2896 BlockingNetworkDelegate::SYNCHRONOUS); 2897 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 2898 network_delegate.set_auth_retval( 2899 NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH); 2900 2901 network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret)); 2902 2903 TestURLRequestContext context(true); 2904 context.set_network_delegate(&network_delegate); 2905 context.Init(); 2906 2907 { 2908 GURL url(test_server_.GetURL("auth-basic")); 2909 URLRequest r(url, &d, &context); 2910 r.Start(); 2911 base::MessageLoop::current()->Run(); 2912 2913 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2914 EXPECT_EQ(0, r.status().error()); 2915 EXPECT_EQ(200, r.GetResponseCode()); 2916 EXPECT_FALSE(d.auth_required_called()); 2917 EXPECT_EQ(1, network_delegate.created_requests()); 2918 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2919 } 2920 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2921 } 2922 2923 // Same as above, but also tests that GetFullRequestHeaders returns the proper 2924 // headers (for the first or second request) when called at the proper times. 2925 TEST_F(URLRequestTestHTTP, 2926 NetworkDelegateOnAuthRequiredSyncSetAuth_GetFullRequestHeaders) { 2927 ASSERT_TRUE(test_server_.Start()); 2928 2929 TestDelegate d; 2930 BlockingNetworkDelegate network_delegate( 2931 BlockingNetworkDelegate::SYNCHRONOUS); 2932 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 2933 network_delegate.set_auth_retval( 2934 NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH); 2935 2936 network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret)); 2937 2938 TestURLRequestContext context(true); 2939 context.set_network_delegate(&network_delegate); 2940 context.Init(); 2941 2942 { 2943 GURL url(test_server_.GetURL("auth-basic")); 2944 URLRequest r(url, &d, &context); 2945 r.Start(); 2946 base::MessageLoop::current()->Run(); 2947 2948 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2949 EXPECT_EQ(0, r.status().error()); 2950 EXPECT_EQ(200, r.GetResponseCode()); 2951 EXPECT_FALSE(d.auth_required_called()); 2952 EXPECT_EQ(1, network_delegate.created_requests()); 2953 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2954 2955 { 2956 HttpRequestHeaders headers; 2957 EXPECT_TRUE(r.GetFullRequestHeaders(&headers)); 2958 EXPECT_TRUE(headers.HasHeader("Authorization")); 2959 } 2960 } 2961 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2962 } 2963 2964 // Tests that the network delegate can synchronously complete OnAuthRequired 2965 // by cancelling authentication. 2966 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncCancel) { 2967 ASSERT_TRUE(test_server_.Start()); 2968 2969 TestDelegate d; 2970 BlockingNetworkDelegate network_delegate( 2971 BlockingNetworkDelegate::SYNCHRONOUS); 2972 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 2973 network_delegate.set_auth_retval( 2974 NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH); 2975 2976 TestURLRequestContext context(true); 2977 context.set_network_delegate(&network_delegate); 2978 context.Init(); 2979 2980 { 2981 GURL url(test_server_.GetURL("auth-basic")); 2982 URLRequest r(url, &d, &context); 2983 r.Start(); 2984 base::MessageLoop::current()->Run(); 2985 2986 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 2987 EXPECT_EQ(OK, r.status().error()); 2988 EXPECT_EQ(401, r.GetResponseCode()); 2989 EXPECT_FALSE(d.auth_required_called()); 2990 EXPECT_EQ(1, network_delegate.created_requests()); 2991 EXPECT_EQ(0, network_delegate.destroyed_requests()); 2992 } 2993 EXPECT_EQ(1, network_delegate.destroyed_requests()); 2994 } 2995 2996 // Tests that the network delegate can asynchronously complete OnAuthRequired 2997 // by taking no action. This indicates that the NetworkDelegate does not want 2998 // to handle the challenge, and is passing the buck along to the 2999 // URLRequest::Delegate. 3000 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncNoAction) { 3001 ASSERT_TRUE(test_server_.Start()); 3002 3003 TestDelegate d; 3004 BlockingNetworkDelegate network_delegate( 3005 BlockingNetworkDelegate::AUTO_CALLBACK); 3006 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 3007 3008 TestURLRequestContext context(true); 3009 context.set_network_delegate(&network_delegate); 3010 context.Init(); 3011 3012 d.set_credentials(AuthCredentials(kUser, kSecret)); 3013 3014 { 3015 GURL url(test_server_.GetURL("auth-basic")); 3016 URLRequest r(url, &d, &context); 3017 r.Start(); 3018 base::MessageLoop::current()->Run(); 3019 3020 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 3021 EXPECT_EQ(0, r.status().error()); 3022 EXPECT_EQ(200, r.GetResponseCode()); 3023 EXPECT_TRUE(d.auth_required_called()); 3024 EXPECT_EQ(1, network_delegate.created_requests()); 3025 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3026 } 3027 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3028 } 3029 3030 // Tests that the network delegate can asynchronously complete OnAuthRequired 3031 // by setting credentials. 3032 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncSetAuth) { 3033 ASSERT_TRUE(test_server_.Start()); 3034 3035 TestDelegate d; 3036 BlockingNetworkDelegate network_delegate( 3037 BlockingNetworkDelegate::AUTO_CALLBACK); 3038 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 3039 network_delegate.set_auth_retval( 3040 NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH); 3041 3042 AuthCredentials auth_credentials(kUser, kSecret); 3043 network_delegate.set_auth_credentials(auth_credentials); 3044 3045 TestURLRequestContext context(true); 3046 context.set_network_delegate(&network_delegate); 3047 context.Init(); 3048 3049 { 3050 GURL url(test_server_.GetURL("auth-basic")); 3051 URLRequest r(url, &d, &context); 3052 r.Start(); 3053 base::MessageLoop::current()->Run(); 3054 3055 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 3056 EXPECT_EQ(0, r.status().error()); 3057 3058 EXPECT_EQ(200, r.GetResponseCode()); 3059 EXPECT_FALSE(d.auth_required_called()); 3060 EXPECT_EQ(1, network_delegate.created_requests()); 3061 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3062 } 3063 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3064 } 3065 3066 // Tests that the network delegate can asynchronously complete OnAuthRequired 3067 // by cancelling authentication. 3068 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncCancel) { 3069 ASSERT_TRUE(test_server_.Start()); 3070 3071 TestDelegate d; 3072 BlockingNetworkDelegate network_delegate( 3073 BlockingNetworkDelegate::AUTO_CALLBACK); 3074 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 3075 network_delegate.set_auth_retval( 3076 NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH); 3077 3078 TestURLRequestContext context(true); 3079 context.set_network_delegate(&network_delegate); 3080 context.Init(); 3081 3082 { 3083 GURL url(test_server_.GetURL("auth-basic")); 3084 URLRequest r(url, &d, &context); 3085 r.Start(); 3086 base::MessageLoop::current()->Run(); 3087 3088 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 3089 EXPECT_EQ(OK, r.status().error()); 3090 EXPECT_EQ(401, r.GetResponseCode()); 3091 EXPECT_FALSE(d.auth_required_called()); 3092 EXPECT_EQ(1, network_delegate.created_requests()); 3093 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3094 } 3095 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3096 } 3097 3098 // Tests that we can handle when a network request was canceled while we were 3099 // waiting for the network delegate. 3100 // Part 1: Request is cancelled while waiting for OnBeforeURLRequest callback. 3101 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) { 3102 ASSERT_TRUE(test_server_.Start()); 3103 3104 TestDelegate d; 3105 BlockingNetworkDelegate network_delegate( 3106 BlockingNetworkDelegate::USER_CALLBACK); 3107 network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST); 3108 3109 TestURLRequestContext context(true); 3110 context.set_network_delegate(&network_delegate); 3111 context.Init(); 3112 3113 { 3114 URLRequest r(test_server_.GetURL(std::string()), &d, &context); 3115 3116 r.Start(); 3117 base::MessageLoop::current()->Run(); 3118 EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST, 3119 network_delegate.stage_blocked_for_callback()); 3120 EXPECT_EQ(0, network_delegate.completed_requests()); 3121 // Cancel before callback. 3122 r.Cancel(); 3123 // Ensure that network delegate is notified. 3124 EXPECT_EQ(1, network_delegate.completed_requests()); 3125 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3126 EXPECT_EQ(ERR_ABORTED, r.status().error()); 3127 EXPECT_EQ(1, network_delegate.created_requests()); 3128 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3129 } 3130 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3131 } 3132 3133 // Tests that we can handle when a network request was canceled while we were 3134 // waiting for the network delegate. 3135 // Part 2: Request is cancelled while waiting for OnBeforeSendHeaders callback. 3136 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) { 3137 ASSERT_TRUE(test_server_.Start()); 3138 3139 TestDelegate d; 3140 BlockingNetworkDelegate network_delegate( 3141 BlockingNetworkDelegate::USER_CALLBACK); 3142 network_delegate.set_block_on( 3143 BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS); 3144 3145 TestURLRequestContext context(true); 3146 context.set_network_delegate(&network_delegate); 3147 context.Init(); 3148 3149 { 3150 URLRequest r(test_server_.GetURL(std::string()), &d, &context); 3151 3152 r.Start(); 3153 base::MessageLoop::current()->Run(); 3154 EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS, 3155 network_delegate.stage_blocked_for_callback()); 3156 EXPECT_EQ(0, network_delegate.completed_requests()); 3157 // Cancel before callback. 3158 r.Cancel(); 3159 // Ensure that network delegate is notified. 3160 EXPECT_EQ(1, network_delegate.completed_requests()); 3161 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3162 EXPECT_EQ(ERR_ABORTED, r.status().error()); 3163 EXPECT_EQ(1, network_delegate.created_requests()); 3164 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3165 } 3166 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3167 } 3168 3169 // Tests that we can handle when a network request was canceled while we were 3170 // waiting for the network delegate. 3171 // Part 3: Request is cancelled while waiting for OnHeadersReceived callback. 3172 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) { 3173 ASSERT_TRUE(test_server_.Start()); 3174 3175 TestDelegate d; 3176 BlockingNetworkDelegate network_delegate( 3177 BlockingNetworkDelegate::USER_CALLBACK); 3178 network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED); 3179 3180 TestURLRequestContext context(true); 3181 context.set_network_delegate(&network_delegate); 3182 context.Init(); 3183 3184 { 3185 URLRequest r(test_server_.GetURL(std::string()), &d, &context); 3186 3187 r.Start(); 3188 base::MessageLoop::current()->Run(); 3189 EXPECT_EQ(BlockingNetworkDelegate::ON_HEADERS_RECEIVED, 3190 network_delegate.stage_blocked_for_callback()); 3191 EXPECT_EQ(0, network_delegate.completed_requests()); 3192 // Cancel before callback. 3193 r.Cancel(); 3194 // Ensure that network delegate is notified. 3195 EXPECT_EQ(1, network_delegate.completed_requests()); 3196 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3197 EXPECT_EQ(ERR_ABORTED, r.status().error()); 3198 EXPECT_EQ(1, network_delegate.created_requests()); 3199 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3200 } 3201 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3202 } 3203 3204 // Tests that we can handle when a network request was canceled while we were 3205 // waiting for the network delegate. 3206 // Part 4: Request is cancelled while waiting for OnAuthRequired callback. 3207 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting4) { 3208 ASSERT_TRUE(test_server_.Start()); 3209 3210 TestDelegate d; 3211 BlockingNetworkDelegate network_delegate( 3212 BlockingNetworkDelegate::USER_CALLBACK); 3213 network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED); 3214 3215 TestURLRequestContext context(true); 3216 context.set_network_delegate(&network_delegate); 3217 context.Init(); 3218 3219 { 3220 URLRequest r(test_server_.GetURL("auth-basic"), &d, &context); 3221 3222 r.Start(); 3223 base::MessageLoop::current()->Run(); 3224 EXPECT_EQ(BlockingNetworkDelegate::ON_AUTH_REQUIRED, 3225 network_delegate.stage_blocked_for_callback()); 3226 EXPECT_EQ(0, network_delegate.completed_requests()); 3227 // Cancel before callback. 3228 r.Cancel(); 3229 // Ensure that network delegate is notified. 3230 EXPECT_EQ(1, network_delegate.completed_requests()); 3231 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3232 EXPECT_EQ(ERR_ABORTED, r.status().error()); 3233 EXPECT_EQ(1, network_delegate.created_requests()); 3234 EXPECT_EQ(0, network_delegate.destroyed_requests()); 3235 } 3236 EXPECT_EQ(1, network_delegate.destroyed_requests()); 3237 } 3238 3239 // In this unit test, we're using the HTTPTestServer as a proxy server and 3240 // issuing a CONNECT request with the magic host name "www.server-auth.com". 3241 // The HTTPTestServer will return a 401 response, which we should balk at. 3242 TEST_F(URLRequestTestHTTP, UnexpectedServerAuthTest) { 3243 ASSERT_TRUE(test_server_.Start()); 3244 3245 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 3246 TestURLRequestContextWithProxy context( 3247 test_server_.host_port_pair().ToString(), 3248 &network_delegate); 3249 3250 TestDelegate d; 3251 { 3252 URLRequest r(GURL("https://www.server-auth.com/"), &d, &context); 3253 3254 r.Start(); 3255 EXPECT_TRUE(r.is_pending()); 3256 3257 base::MessageLoop::current()->Run(); 3258 3259 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 3260 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r.status().error()); 3261 } 3262 } 3263 3264 TEST_F(URLRequestTestHTTP, GetTest_NoCache) { 3265 ASSERT_TRUE(test_server_.Start()); 3266 3267 TestDelegate d; 3268 { 3269 URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); 3270 3271 r.Start(); 3272 EXPECT_TRUE(r.is_pending()); 3273 3274 base::MessageLoop::current()->Run(); 3275 3276 EXPECT_EQ(1, d.response_started_count()); 3277 EXPECT_FALSE(d.received_data_before_response()); 3278 EXPECT_NE(0, d.bytes_received()); 3279 EXPECT_EQ(test_server_.host_port_pair().host(), 3280 r.GetSocketAddress().host()); 3281 EXPECT_EQ(test_server_.host_port_pair().port(), 3282 r.GetSocketAddress().port()); 3283 3284 // TODO(eroman): Add back the NetLog tests... 3285 } 3286 } 3287 3288 // This test has the server send a large number of cookies to the client. 3289 // To ensure that no number of cookies causes a crash, a galloping binary 3290 // search is used to estimate that maximum number of cookies that are accepted 3291 // by the browser. Beyond the maximum number, the request will fail with 3292 // ERR_RESPONSE_HEADERS_TOO_BIG. 3293 #if defined(OS_WIN) 3294 // http://crbug.com/177916 3295 #define MAYBE_GetTest_ManyCookies DISABLED_GetTest_ManyCookies 3296 #else 3297 #define MAYBE_GetTest_ManyCookies GetTest_ManyCookies 3298 #endif // defined(OS_WIN) 3299 TEST_F(URLRequestTestHTTP, MAYBE_GetTest_ManyCookies) { 3300 ASSERT_TRUE(test_server_.Start()); 3301 3302 int lower_bound = 0; 3303 int upper_bound = 1; 3304 3305 // Double the number of cookies until the response header limits are 3306 // exceeded. 3307 while (DoManyCookiesRequest(upper_bound)) { 3308 lower_bound = upper_bound; 3309 upper_bound *= 2; 3310 ASSERT_LT(upper_bound, 1000000); 3311 } 3312 3313 int tolerance = upper_bound * 0.005; 3314 if (tolerance < 2) 3315 tolerance = 2; 3316 3317 // Perform a binary search to find the highest possible number of cookies, 3318 // within the desired tolerance. 3319 while (upper_bound - lower_bound >= tolerance) { 3320 int num_cookies = (lower_bound + upper_bound) / 2; 3321 3322 if (DoManyCookiesRequest(num_cookies)) 3323 lower_bound = num_cookies; 3324 else 3325 upper_bound = num_cookies; 3326 } 3327 // Success: the test did not crash. 3328 } 3329 3330 TEST_F(URLRequestTestHTTP, GetTest) { 3331 ASSERT_TRUE(test_server_.Start()); 3332 3333 TestDelegate d; 3334 { 3335 URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); 3336 3337 r.Start(); 3338 EXPECT_TRUE(r.is_pending()); 3339 3340 base::MessageLoop::current()->Run(); 3341 3342 EXPECT_EQ(1, d.response_started_count()); 3343 EXPECT_FALSE(d.received_data_before_response()); 3344 EXPECT_NE(0, d.bytes_received()); 3345 EXPECT_EQ(test_server_.host_port_pair().host(), 3346 r.GetSocketAddress().host()); 3347 EXPECT_EQ(test_server_.host_port_pair().port(), 3348 r.GetSocketAddress().port()); 3349 } 3350 } 3351 3352 TEST_F(URLRequestTestHTTP, GetTest_GetFullRequestHeaders) { 3353 ASSERT_TRUE(test_server_.Start()); 3354 3355 TestDelegate d; 3356 { 3357 GURL test_url(test_server_.GetURL(std::string())); 3358 URLRequest r(test_url, &d, &default_context_); 3359 3360 HttpRequestHeaders headers; 3361 EXPECT_FALSE(r.GetFullRequestHeaders(&headers)); 3362 3363 r.Start(); 3364 EXPECT_TRUE(r.is_pending()); 3365 3366 base::MessageLoop::current()->Run(); 3367 3368 EXPECT_EQ(1, d.response_started_count()); 3369 EXPECT_FALSE(d.received_data_before_response()); 3370 EXPECT_NE(0, d.bytes_received()); 3371 EXPECT_EQ(test_server_.host_port_pair().host(), 3372 r.GetSocketAddress().host()); 3373 EXPECT_EQ(test_server_.host_port_pair().port(), 3374 r.GetSocketAddress().port()); 3375 3376 EXPECT_TRUE(d.have_full_request_headers()); 3377 CheckFullRequestHeaders(d.full_request_headers(), test_url); 3378 } 3379 } 3380 3381 TEST_F(URLRequestTestHTTP, GetTestLoadTiming) { 3382 ASSERT_TRUE(test_server_.Start()); 3383 3384 TestDelegate d; 3385 { 3386 URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); 3387 3388 r.Start(); 3389 EXPECT_TRUE(r.is_pending()); 3390 3391 base::MessageLoop::current()->Run(); 3392 3393 LoadTimingInfo load_timing_info; 3394 r.GetLoadTimingInfo(&load_timing_info); 3395 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 3396 3397 EXPECT_EQ(1, d.response_started_count()); 3398 EXPECT_FALSE(d.received_data_before_response()); 3399 EXPECT_NE(0, d.bytes_received()); 3400 EXPECT_EQ(test_server_.host_port_pair().host(), 3401 r.GetSocketAddress().host()); 3402 EXPECT_EQ(test_server_.host_port_pair().port(), 3403 r.GetSocketAddress().port()); 3404 } 3405 } 3406 3407 TEST_F(URLRequestTestHTTP, GetZippedTest) { 3408 ASSERT_TRUE(test_server_.Start()); 3409 3410 // Parameter that specifies the Content-Length field in the response: 3411 // C - Compressed length. 3412 // U - Uncompressed length. 3413 // L - Large length (larger than both C & U). 3414 // M - Medium length (between C & U). 3415 // S - Small length (smaller than both C & U). 3416 const char test_parameters[] = "CULMS"; 3417 const int num_tests = arraysize(test_parameters)- 1; // Skip NULL. 3418 // C & U should be OK. 3419 // L & M are larger than the data sent, and show an error. 3420 // S has too little data, but we seem to accept it. 3421 const bool test_expect_success[num_tests] = 3422 { true, true, false, false, true }; 3423 3424 for (int i = 0; i < num_tests ; i++) { 3425 TestDelegate d; 3426 { 3427 std::string test_file = 3428 base::StringPrintf("compressedfiles/BullRunSpeech.txt?%c", 3429 test_parameters[i]); 3430 3431 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 3432 TestURLRequestContext context(true); 3433 context.set_network_delegate(&network_delegate); 3434 context.Init(); 3435 3436 URLRequest r(test_server_.GetURL(test_file), &d, &context); 3437 r.Start(); 3438 EXPECT_TRUE(r.is_pending()); 3439 3440 base::MessageLoop::current()->Run(); 3441 3442 EXPECT_EQ(1, d.response_started_count()); 3443 EXPECT_FALSE(d.received_data_before_response()); 3444 VLOG(1) << " Received " << d.bytes_received() << " bytes" 3445 << " status = " << r.status().status() 3446 << " error = " << r.status().error(); 3447 if (test_expect_success[i]) { 3448 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()) 3449 << " Parameter = \"" << test_file << "\""; 3450 } else { 3451 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 3452 EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r.status().error()) 3453 << " Parameter = \"" << test_file << "\""; 3454 } 3455 } 3456 } 3457 } 3458 3459 TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) { 3460 ASSERT_TRUE(test_server_.Start()); 3461 3462 SpawnedTestServer https_test_server( 3463 SpawnedTestServer::TYPE_HTTPS, SpawnedTestServer::kLocalhost, 3464 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 3465 ASSERT_TRUE(https_test_server.Start()); 3466 3467 // An https server is sent a request with an https referer, 3468 // and responds with a redirect to an http url. The http 3469 // server should not be sent the referer. 3470 GURL http_destination = test_server_.GetURL(std::string()); 3471 TestDelegate d; 3472 URLRequest req(https_test_server.GetURL( 3473 "server-redirect?" + http_destination.spec()), &d, &default_context_); 3474 req.SetReferrer("https://www.referrer.com/"); 3475 req.Start(); 3476 base::MessageLoop::current()->Run(); 3477 3478 EXPECT_EQ(1, d.response_started_count()); 3479 EXPECT_EQ(1, d.received_redirect_count()); 3480 EXPECT_EQ(http_destination, req.url()); 3481 EXPECT_EQ(std::string(), req.referrer()); 3482 } 3483 3484 TEST_F(URLRequestTestHTTP, RedirectLoadTiming) { 3485 ASSERT_TRUE(test_server_.Start()); 3486 3487 GURL destination_url = test_server_.GetURL(std::string()); 3488 GURL original_url = 3489 test_server_.GetURL("server-redirect?" + destination_url.spec()); 3490 TestDelegate d; 3491 URLRequest req(original_url, &d, &default_context_); 3492 req.Start(); 3493 base::MessageLoop::current()->Run(); 3494 3495 EXPECT_EQ(1, d.response_started_count()); 3496 EXPECT_EQ(1, d.received_redirect_count()); 3497 EXPECT_EQ(destination_url, req.url()); 3498 EXPECT_EQ(original_url, req.original_url()); 3499 ASSERT_EQ(2U, req.url_chain().size()); 3500 EXPECT_EQ(original_url, req.url_chain()[0]); 3501 EXPECT_EQ(destination_url, req.url_chain()[1]); 3502 3503 LoadTimingInfo load_timing_info_before_redirect; 3504 EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeRedirect( 3505 &load_timing_info_before_redirect)); 3506 TestLoadTimingNotReused(load_timing_info_before_redirect, 3507 CONNECT_TIMING_HAS_DNS_TIMES); 3508 3509 LoadTimingInfo load_timing_info; 3510 req.GetLoadTimingInfo(&load_timing_info); 3511 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 3512 3513 // Check that a new socket was used on redirect, since the server does not 3514 // supposed keep-alive sockets, and that the times before the redirect are 3515 // before the ones recorded for the second request. 3516 EXPECT_NE(load_timing_info_before_redirect.socket_log_id, 3517 load_timing_info.socket_log_id); 3518 EXPECT_LE(load_timing_info_before_redirect.receive_headers_end, 3519 load_timing_info.connect_timing.connect_start); 3520 } 3521 3522 TEST_F(URLRequestTestHTTP, MultipleRedirectTest) { 3523 ASSERT_TRUE(test_server_.Start()); 3524 3525 GURL destination_url = test_server_.GetURL(std::string()); 3526 GURL middle_redirect_url = 3527 test_server_.GetURL("server-redirect?" + destination_url.spec()); 3528 GURL original_url = test_server_.GetURL( 3529 "server-redirect?" + middle_redirect_url.spec()); 3530 TestDelegate d; 3531 URLRequest req(original_url, &d, &default_context_); 3532 req.Start(); 3533 base::MessageLoop::current()->Run(); 3534 3535 EXPECT_EQ(1, d.response_started_count()); 3536 EXPECT_EQ(2, d.received_redirect_count()); 3537 EXPECT_EQ(destination_url, req.url()); 3538 EXPECT_EQ(original_url, req.original_url()); 3539 ASSERT_EQ(3U, req.url_chain().size()); 3540 EXPECT_EQ(original_url, req.url_chain()[0]); 3541 EXPECT_EQ(middle_redirect_url, req.url_chain()[1]); 3542 EXPECT_EQ(destination_url, req.url_chain()[2]); 3543 } 3544 3545 namespace { 3546 3547 const char kExtraHeader[] = "Allow-Snafu"; 3548 const char kExtraValue[] = "fubar"; 3549 3550 class RedirectWithAdditionalHeadersDelegate : public TestDelegate { 3551 virtual void OnReceivedRedirect(net::URLRequest* request, 3552 const GURL& new_url, 3553 bool* defer_redirect) OVERRIDE { 3554 TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect); 3555 request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false); 3556 } 3557 }; 3558 3559 } // namespace 3560 3561 TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) { 3562 ASSERT_TRUE(test_server_.Start()); 3563 3564 GURL destination_url = test_server_.GetURL( 3565 "echoheader?" + std::string(kExtraHeader)); 3566 GURL original_url = test_server_.GetURL( 3567 "server-redirect?" + destination_url.spec()); 3568 RedirectWithAdditionalHeadersDelegate d; 3569 URLRequest req(original_url, &d, &default_context_); 3570 req.Start(); 3571 base::MessageLoop::current()->Run(); 3572 3573 std::string value; 3574 const HttpRequestHeaders& headers = req.extra_request_headers(); 3575 EXPECT_TRUE(headers.GetHeader(kExtraHeader, &value)); 3576 EXPECT_EQ(kExtraValue, value); 3577 EXPECT_FALSE(req.is_pending()); 3578 EXPECT_FALSE(req.is_redirecting()); 3579 EXPECT_EQ(kExtraValue, d.data_received()); 3580 } 3581 3582 namespace { 3583 3584 const char kExtraHeaderToRemove[] = "To-Be-Removed"; 3585 3586 class RedirectWithHeaderRemovalDelegate : public TestDelegate { 3587 virtual void OnReceivedRedirect(net::URLRequest* request, 3588 const GURL& new_url, 3589 bool* defer_redirect) OVERRIDE { 3590 TestDelegate::OnReceivedRedirect(request, new_url, defer_redirect); 3591 request->RemoveRequestHeaderByName(kExtraHeaderToRemove); 3592 } 3593 }; 3594 3595 } // namespace 3596 3597 TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) { 3598 ASSERT_TRUE(test_server_.Start()); 3599 3600 GURL destination_url = test_server_.GetURL( 3601 "echoheader?" + std::string(kExtraHeaderToRemove)); 3602 GURL original_url = test_server_.GetURL( 3603 "server-redirect?" + destination_url.spec()); 3604 RedirectWithHeaderRemovalDelegate d; 3605 URLRequest req(original_url, &d, &default_context_); 3606 req.SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false); 3607 req.Start(); 3608 base::MessageLoop::current()->Run(); 3609 3610 std::string value; 3611 const HttpRequestHeaders& headers = req.extra_request_headers(); 3612 EXPECT_FALSE(headers.GetHeader(kExtraHeaderToRemove, &value)); 3613 EXPECT_FALSE(req.is_pending()); 3614 EXPECT_FALSE(req.is_redirecting()); 3615 EXPECT_EQ("None", d.data_received()); 3616 } 3617 3618 TEST_F(URLRequestTestHTTP, CancelTest) { 3619 TestDelegate d; 3620 { 3621 URLRequest r(GURL("http://www.google.com/"), &d, &default_context_); 3622 3623 r.Start(); 3624 EXPECT_TRUE(r.is_pending()); 3625 3626 r.Cancel(); 3627 3628 base::MessageLoop::current()->Run(); 3629 3630 // We expect to receive OnResponseStarted even though the request has been 3631 // cancelled. 3632 EXPECT_EQ(1, d.response_started_count()); 3633 EXPECT_EQ(0, d.bytes_received()); 3634 EXPECT_FALSE(d.received_data_before_response()); 3635 } 3636 } 3637 3638 TEST_F(URLRequestTestHTTP, CancelTest2) { 3639 ASSERT_TRUE(test_server_.Start()); 3640 3641 TestDelegate d; 3642 { 3643 URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); 3644 3645 d.set_cancel_in_response_started(true); 3646 3647 r.Start(); 3648 EXPECT_TRUE(r.is_pending()); 3649 3650 base::MessageLoop::current()->Run(); 3651 3652 EXPECT_EQ(1, d.response_started_count()); 3653 EXPECT_EQ(0, d.bytes_received()); 3654 EXPECT_FALSE(d.received_data_before_response()); 3655 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3656 } 3657 } 3658 3659 TEST_F(URLRequestTestHTTP, CancelTest3) { 3660 ASSERT_TRUE(test_server_.Start()); 3661 3662 TestDelegate d; 3663 { 3664 URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); 3665 3666 d.set_cancel_in_received_data(true); 3667 3668 r.Start(); 3669 EXPECT_TRUE(r.is_pending()); 3670 3671 base::MessageLoop::current()->Run(); 3672 3673 EXPECT_EQ(1, d.response_started_count()); 3674 // There is no guarantee about how much data was received 3675 // before the cancel was issued. It could have been 0 bytes, 3676 // or it could have been all the bytes. 3677 // EXPECT_EQ(0, d.bytes_received()); 3678 EXPECT_FALSE(d.received_data_before_response()); 3679 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3680 } 3681 } 3682 3683 TEST_F(URLRequestTestHTTP, CancelTest4) { 3684 ASSERT_TRUE(test_server_.Start()); 3685 3686 TestDelegate d; 3687 { 3688 URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); 3689 3690 r.Start(); 3691 EXPECT_TRUE(r.is_pending()); 3692 3693 // The request will be implicitly canceled when it is destroyed. The 3694 // test delegate must not post a quit message when this happens because 3695 // this test doesn't actually have a message loop. The quit message would 3696 // get put on this thread's message queue and the next test would exit 3697 // early, causing problems. 3698 d.set_quit_on_complete(false); 3699 } 3700 // expect things to just cleanup properly. 3701 3702 // we won't actually get a received reponse here because we've never run the 3703 // message loop 3704 EXPECT_FALSE(d.received_data_before_response()); 3705 EXPECT_EQ(0, d.bytes_received()); 3706 } 3707 3708 TEST_F(URLRequestTestHTTP, CancelTest5) { 3709 ASSERT_TRUE(test_server_.Start()); 3710 3711 // populate cache 3712 { 3713 TestDelegate d; 3714 URLRequest r(test_server_.GetURL("cachetime"), &d, &default_context_); 3715 r.Start(); 3716 base::MessageLoop::current()->Run(); 3717 EXPECT_EQ(URLRequestStatus::SUCCESS, r.status().status()); 3718 } 3719 3720 // cancel read from cache (see bug 990242) 3721 { 3722 TestDelegate d; 3723 URLRequest r(test_server_.GetURL("cachetime"), &d, &default_context_); 3724 r.Start(); 3725 r.Cancel(); 3726 base::MessageLoop::current()->Run(); 3727 3728 EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status()); 3729 EXPECT_EQ(1, d.response_started_count()); 3730 EXPECT_EQ(0, d.bytes_received()); 3731 EXPECT_FALSE(d.received_data_before_response()); 3732 } 3733 } 3734 3735 TEST_F(URLRequestTestHTTP, PostTest) { 3736 ASSERT_TRUE(test_server_.Start()); 3737 HTTPUploadDataOperationTest("POST"); 3738 } 3739 3740 TEST_F(URLRequestTestHTTP, PutTest) { 3741 ASSERT_TRUE(test_server_.Start()); 3742 HTTPUploadDataOperationTest("PUT"); 3743 } 3744 3745 TEST_F(URLRequestTestHTTP, PostEmptyTest) { 3746 ASSERT_TRUE(test_server_.Start()); 3747 3748 TestDelegate d; 3749 { 3750 URLRequest r(test_server_.GetURL("echo"), &d, &default_context_); 3751 r.set_method("POST"); 3752 3753 r.Start(); 3754 EXPECT_TRUE(r.is_pending()); 3755 3756 base::MessageLoop::current()->Run(); 3757 3758 ASSERT_EQ(1, d.response_started_count()) 3759 << "request failed: " << r.status().status() 3760 << ", error: " << r.status().error(); 3761 3762 EXPECT_FALSE(d.received_data_before_response()); 3763 EXPECT_TRUE(d.data_received().empty()); 3764 } 3765 } 3766 3767 TEST_F(URLRequestTestHTTP, PostFileTest) { 3768 ASSERT_TRUE(test_server_.Start()); 3769 3770 TestDelegate d; 3771 { 3772 URLRequest r(test_server_.GetURL("echo"), &d, &default_context_); 3773 r.set_method("POST"); 3774 3775 base::FilePath dir; 3776 PathService::Get(base::DIR_EXE, &dir); 3777 file_util::SetCurrentDirectory(dir); 3778 3779 ScopedVector<UploadElementReader> element_readers; 3780 3781 base::FilePath path; 3782 PathService::Get(base::DIR_SOURCE_ROOT, &path); 3783 path = path.Append(FILE_PATH_LITERAL("net")); 3784 path = path.Append(FILE_PATH_LITERAL("data")); 3785 path = path.Append(FILE_PATH_LITERAL("url_request_unittest")); 3786 path = path.Append(FILE_PATH_LITERAL("with-headers.html")); 3787 element_readers.push_back( 3788 new UploadFileElementReader(base::MessageLoopProxy::current().get(), 3789 path, 3790 0, 3791 kuint64max, 3792 base::Time())); 3793 3794 // This file should just be ignored in the upload stream. 3795 element_readers.push_back(new UploadFileElementReader( 3796 base::MessageLoopProxy::current().get(), 3797 base::FilePath(FILE_PATH_LITERAL( 3798 "c:\\path\\to\\non\\existant\\file.randomness.12345")), 3799 0, 3800 kuint64max, 3801 base::Time())); 3802 r.set_upload(make_scoped_ptr(new UploadDataStream(&element_readers, 0))); 3803 3804 r.Start(); 3805 EXPECT_TRUE(r.is_pending()); 3806 3807 base::MessageLoop::current()->Run(); 3808 3809 int64 size = 0; 3810 ASSERT_EQ(true, file_util::GetFileSize(path, &size)); 3811 scoped_ptr<char[]> buf(new char[size]); 3812 3813 ASSERT_EQ(size, file_util::ReadFile(path, buf.get(), size)); 3814 3815 ASSERT_EQ(1, d.response_started_count()) 3816 << "request failed: " << r.status().status() 3817 << ", error: " << r.status().error(); 3818 3819 EXPECT_FALSE(d.received_data_before_response()); 3820 3821 EXPECT_EQ(size, d.bytes_received()); 3822 EXPECT_EQ(std::string(&buf[0], size), d.data_received()); 3823 } 3824 } 3825 3826 TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) { 3827 ASSERT_TRUE(test_server_.Start()); 3828 3829 TestDelegate d; 3830 { 3831 URLRequest r(test_server_.GetURL("echo"), &d, &default_context_); 3832 r.EnableChunkedUpload(); 3833 r.set_method("POST"); 3834 AddChunksToUpload(&r); 3835 r.Start(); 3836 EXPECT_TRUE(r.is_pending()); 3837 3838 base::MessageLoop::current()->Run(); 3839 3840 VerifyReceivedDataMatchesChunks(&r, &d); 3841 } 3842 } 3843 3844 TEST_F(URLRequestTestHTTP, TestPostChunkedDataJustAfterStart) { 3845 ASSERT_TRUE(test_server_.Start()); 3846 3847 TestDelegate d; 3848 { 3849 URLRequest r(test_server_.GetURL("echo"), &d, &default_context_); 3850 r.EnableChunkedUpload(); 3851 r.set_method("POST"); 3852 r.Start(); 3853 EXPECT_TRUE(r.is_pending()); 3854 AddChunksToUpload(&r); 3855 base::MessageLoop::current()->Run(); 3856 3857 VerifyReceivedDataMatchesChunks(&r, &d); 3858 } 3859 } 3860 3861 TEST_F(URLRequestTestHTTP, TestPostChunkedDataAfterStart) { 3862 ASSERT_TRUE(test_server_.Start()); 3863 3864 TestDelegate d; 3865 { 3866 URLRequest r(test_server_.GetURL("echo"), &d, &default_context_); 3867 r.EnableChunkedUpload(); 3868 r.set_method("POST"); 3869 r.Start(); 3870 EXPECT_TRUE(r.is_pending()); 3871 3872 base::MessageLoop::current()->RunUntilIdle(); 3873 AddChunksToUpload(&r); 3874 base::MessageLoop::current()->Run(); 3875 3876 VerifyReceivedDataMatchesChunks(&r, &d); 3877 } 3878 } 3879 3880 TEST_F(URLRequestTestHTTP, ResponseHeadersTest) { 3881 ASSERT_TRUE(test_server_.Start()); 3882 3883 TestDelegate d; 3884 URLRequest req( 3885 test_server_.GetURL("files/with-headers.html"), &d, &default_context_); 3886 req.Start(); 3887 base::MessageLoop::current()->Run(); 3888 3889 const HttpResponseHeaders* headers = req.response_headers(); 3890 3891 // Simple sanity check that response_info() accesses the same data. 3892 EXPECT_EQ(headers, req.response_info().headers.get()); 3893 3894 std::string header; 3895 EXPECT_TRUE(headers->GetNormalizedHeader("cache-control", &header)); 3896 EXPECT_EQ("private", header); 3897 3898 header.clear(); 3899 EXPECT_TRUE(headers->GetNormalizedHeader("content-type", &header)); 3900 EXPECT_EQ("text/html; charset=ISO-8859-1", header); 3901 3902 // The response has two "X-Multiple-Entries" headers. 3903 // This verfies our output has them concatenated together. 3904 header.clear(); 3905 EXPECT_TRUE(headers->GetNormalizedHeader("x-multiple-entries", &header)); 3906 EXPECT_EQ("a, b", header); 3907 } 3908 3909 TEST_F(URLRequestTestHTTP, ProcessSTS) { 3910 SpawnedTestServer::SSLOptions ssl_options; 3911 SpawnedTestServer https_test_server( 3912 SpawnedTestServer::TYPE_HTTPS, 3913 ssl_options, 3914 base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))); 3915 ASSERT_TRUE(https_test_server.Start()); 3916 3917 TestDelegate d; 3918 URLRequest request( 3919 https_test_server.GetURL("files/hsts-headers.html"), 3920 &d, 3921 &default_context_); 3922 request.Start(); 3923 base::MessageLoop::current()->Run(); 3924 3925 TransportSecurityState* security_state = 3926 default_context_.transport_security_state(); 3927 bool sni_available = true; 3928 TransportSecurityState::DomainState domain_state; 3929 EXPECT_TRUE(security_state->GetDomainState( 3930 SpawnedTestServer::kLocalhost, sni_available, &domain_state)); 3931 EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS, 3932 domain_state.upgrade_mode); 3933 EXPECT_TRUE(domain_state.sts_include_subdomains); 3934 EXPECT_FALSE(domain_state.pkp_include_subdomains); 3935 #if defined(OS_ANDROID) 3936 // Android's CertVerifyProc does not (yet) handle pins. 3937 #else 3938 EXPECT_FALSE(domain_state.HasPublicKeyPins()); 3939 #endif 3940 } 3941 3942 // Android's CertVerifyProc does not (yet) handle pins. Therefore, it will 3943 // reject HPKP headers, and a test setting only HPKP headers will fail (no 3944 // DomainState present because header rejected). 3945 #if defined(OS_ANDROID) 3946 #define MAYBE_ProcessPKP DISABLED_ProcessPKP 3947 #else 3948 #define MAYBE_ProcessPKP ProcessPKP 3949 #endif 3950 3951 // Tests that enabling HPKP on a domain does not affect the HSTS 3952 // validity/expiration. 3953 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKP) { 3954 SpawnedTestServer::SSLOptions ssl_options; 3955 SpawnedTestServer https_test_server( 3956 SpawnedTestServer::TYPE_HTTPS, 3957 ssl_options, 3958 base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))); 3959 ASSERT_TRUE(https_test_server.Start()); 3960 3961 TestDelegate d; 3962 URLRequest request( 3963 https_test_server.GetURL("files/hpkp-headers.html"), 3964 &d, 3965 &default_context_); 3966 request.Start(); 3967 base::MessageLoop::current()->Run(); 3968 3969 TransportSecurityState* security_state = 3970 default_context_.transport_security_state(); 3971 bool sni_available = true; 3972 TransportSecurityState::DomainState domain_state; 3973 EXPECT_TRUE(security_state->GetDomainState( 3974 SpawnedTestServer::kLocalhost, sni_available, &domain_state)); 3975 EXPECT_EQ(TransportSecurityState::DomainState::MODE_DEFAULT, 3976 domain_state.upgrade_mode); 3977 EXPECT_FALSE(domain_state.sts_include_subdomains); 3978 EXPECT_FALSE(domain_state.pkp_include_subdomains); 3979 EXPECT_TRUE(domain_state.HasPublicKeyPins()); 3980 EXPECT_NE(domain_state.upgrade_expiry, 3981 domain_state.dynamic_spki_hashes_expiry); 3982 } 3983 3984 TEST_F(URLRequestTestHTTP, ProcessSTSOnce) { 3985 SpawnedTestServer::SSLOptions ssl_options; 3986 SpawnedTestServer https_test_server( 3987 SpawnedTestServer::TYPE_HTTPS, 3988 ssl_options, 3989 base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))); 3990 ASSERT_TRUE(https_test_server.Start()); 3991 3992 TestDelegate d; 3993 URLRequest request( 3994 https_test_server.GetURL("files/hsts-multiple-headers.html"), 3995 &d, 3996 &default_context_); 3997 request.Start(); 3998 base::MessageLoop::current()->Run(); 3999 4000 // We should have set parameters from the first header, not the second. 4001 TransportSecurityState* security_state = 4002 default_context_.transport_security_state(); 4003 bool sni_available = true; 4004 TransportSecurityState::DomainState domain_state; 4005 EXPECT_TRUE(security_state->GetDomainState( 4006 SpawnedTestServer::kLocalhost, sni_available, &domain_state)); 4007 EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS, 4008 domain_state.upgrade_mode); 4009 EXPECT_FALSE(domain_state.sts_include_subdomains); 4010 EXPECT_FALSE(domain_state.pkp_include_subdomains); 4011 } 4012 4013 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP) { 4014 SpawnedTestServer::SSLOptions ssl_options; 4015 SpawnedTestServer https_test_server( 4016 SpawnedTestServer::TYPE_HTTPS, 4017 ssl_options, 4018 base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))); 4019 ASSERT_TRUE(https_test_server.Start()); 4020 4021 TestDelegate d; 4022 URLRequest request( 4023 https_test_server.GetURL("files/hsts-and-hpkp-headers.html"), 4024 &d, 4025 &default_context_); 4026 request.Start(); 4027 base::MessageLoop::current()->Run(); 4028 4029 // We should have set parameters from the first header, not the second. 4030 TransportSecurityState* security_state = 4031 default_context_.transport_security_state(); 4032 bool sni_available = true; 4033 TransportSecurityState::DomainState domain_state; 4034 EXPECT_TRUE(security_state->GetDomainState( 4035 SpawnedTestServer::kLocalhost, sni_available, &domain_state)); 4036 EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS, 4037 domain_state.upgrade_mode); 4038 #if defined(OS_ANDROID) 4039 // Android's CertVerifyProc does not (yet) handle pins. 4040 #else 4041 EXPECT_TRUE(domain_state.HasPublicKeyPins()); 4042 #endif 4043 EXPECT_NE(domain_state.upgrade_expiry, 4044 domain_state.dynamic_spki_hashes_expiry); 4045 4046 // Even though there is an HSTS header asserting includeSubdomains, it is 4047 // the *second* such header, and we MUST process only the first. 4048 EXPECT_FALSE(domain_state.sts_include_subdomains); 4049 // includeSubdomains does not occur in the test HPKP header. 4050 EXPECT_FALSE(domain_state.pkp_include_subdomains); 4051 } 4052 4053 // Tests that when multiple HPKP headers are present, asserting different 4054 // policies, that only the first such policy is processed. 4055 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP2) { 4056 SpawnedTestServer::SSLOptions ssl_options; 4057 SpawnedTestServer https_test_server( 4058 SpawnedTestServer::TYPE_HTTPS, 4059 ssl_options, 4060 base::FilePath(FILE_PATH_LITERAL("net/data/url_request_unittest"))); 4061 ASSERT_TRUE(https_test_server.Start()); 4062 4063 TestDelegate d; 4064 URLRequest request( 4065 https_test_server.GetURL("files/hsts-and-hpkp-headers2.html"), 4066 &d, 4067 &default_context_); 4068 request.Start(); 4069 base::MessageLoop::current()->Run(); 4070 4071 TransportSecurityState* security_state = 4072 default_context_.transport_security_state(); 4073 bool sni_available = true; 4074 TransportSecurityState::DomainState domain_state; 4075 EXPECT_TRUE(security_state->GetDomainState( 4076 SpawnedTestServer::kLocalhost, sni_available, &domain_state)); 4077 EXPECT_EQ(TransportSecurityState::DomainState::MODE_FORCE_HTTPS, 4078 domain_state.upgrade_mode); 4079 #if defined(OS_ANDROID) 4080 // Android's CertVerifyProc does not (yet) handle pins. 4081 #else 4082 EXPECT_TRUE(domain_state.HasPublicKeyPins()); 4083 #endif 4084 EXPECT_NE(domain_state.upgrade_expiry, 4085 domain_state.dynamic_spki_hashes_expiry); 4086 4087 EXPECT_TRUE(domain_state.sts_include_subdomains); 4088 EXPECT_FALSE(domain_state.pkp_include_subdomains); 4089 } 4090 4091 TEST_F(URLRequestTestHTTP, ContentTypeNormalizationTest) { 4092 ASSERT_TRUE(test_server_.Start()); 4093 4094 TestDelegate d; 4095 URLRequest req(test_server_.GetURL( 4096 "files/content-type-normalization.html"), &d, &default_context_); 4097 req.Start(); 4098 base::MessageLoop::current()->Run(); 4099 4100 std::string mime_type; 4101 req.GetMimeType(&mime_type); 4102 EXPECT_EQ("text/html", mime_type); 4103 4104 std::string charset; 4105 req.GetCharset(&charset); 4106 EXPECT_EQ("utf-8", charset); 4107 req.Cancel(); 4108 } 4109 4110 TEST_F(URLRequestTestHTTP, ProtocolHandlerAndFactoryRestrictRedirects) { 4111 // Test URLRequestJobFactory::ProtocolHandler::IsSafeRedirectTarget(). 4112 GURL file_url("file:///foo.txt"); 4113 GURL data_url("data:,foo"); 4114 FileProtocolHandler file_protocol_handler; 4115 EXPECT_FALSE(file_protocol_handler.IsSafeRedirectTarget(file_url)); 4116 DataProtocolHandler data_protocol_handler; 4117 EXPECT_TRUE(data_protocol_handler.IsSafeRedirectTarget(data_url)); 4118 4119 // Test URLRequestJobFactoryImpl::IsSafeRedirectTarget(). 4120 EXPECT_FALSE(job_factory_.IsSafeRedirectTarget(file_url)); 4121 EXPECT_TRUE(job_factory_.IsSafeRedirectTarget(data_url)); 4122 } 4123 4124 TEST_F(URLRequestTestHTTP, RestrictRedirects) { 4125 ASSERT_TRUE(test_server_.Start()); 4126 4127 TestDelegate d; 4128 URLRequest req(test_server_.GetURL( 4129 "files/redirect-to-file.html"), &d, &default_context_); 4130 req.Start(); 4131 base::MessageLoop::current()->Run(); 4132 4133 EXPECT_EQ(URLRequestStatus::FAILED, req.status().status()); 4134 EXPECT_EQ(ERR_UNSAFE_REDIRECT, req.status().error()); 4135 } 4136 4137 TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) { 4138 ASSERT_TRUE(test_server_.Start()); 4139 4140 TestDelegate d; 4141 URLRequest req(test_server_.GetURL( 4142 "files/redirect-to-invalid-url.html"), &d, &default_context_); 4143 req.Start(); 4144 base::MessageLoop::current()->Run(); 4145 4146 EXPECT_EQ(URLRequestStatus::FAILED, req.status().status()); 4147 EXPECT_EQ(ERR_INVALID_URL, req.status().error()); 4148 } 4149 4150 TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) { 4151 ASSERT_TRUE(test_server_.Start()); 4152 4153 TestDelegate d; 4154 URLRequest req( 4155 test_server_.GetURL("echoheader?Referer"), &d, &default_context_); 4156 req.SetReferrer("http://user:pass@foo.com/"); 4157 req.Start(); 4158 base::MessageLoop::current()->Run(); 4159 4160 EXPECT_EQ(std::string("http://foo.com/"), d.data_received()); 4161 } 4162 4163 TEST_F(URLRequestTestHTTP, NoFragmentInReferrer) { 4164 ASSERT_TRUE(test_server_.Start()); 4165 4166 TestDelegate d; 4167 URLRequest req( 4168 test_server_.GetURL("echoheader?Referer"), &d, &default_context_); 4169 req.SetReferrer("http://foo.com/test#fragment"); 4170 req.Start(); 4171 base::MessageLoop::current()->Run(); 4172 4173 EXPECT_EQ(std::string("http://foo.com/test"), d.data_received()); 4174 } 4175 4176 TEST_F(URLRequestTestHTTP, EmptyReferrerAfterValidReferrer) { 4177 ASSERT_TRUE(test_server_.Start()); 4178 4179 TestDelegate d; 4180 URLRequest req( 4181 test_server_.GetURL("echoheader?Referer"), &d, &default_context_); 4182 req.SetReferrer("http://foo.com/test#fragment"); 4183 req.SetReferrer(""); 4184 req.Start(); 4185 base::MessageLoop::current()->Run(); 4186 4187 EXPECT_EQ(std::string("None"), d.data_received()); 4188 } 4189 4190 TEST_F(URLRequestTestHTTP, CancelRedirect) { 4191 ASSERT_TRUE(test_server_.Start()); 4192 4193 TestDelegate d; 4194 { 4195 d.set_cancel_in_received_redirect(true); 4196 URLRequest req( 4197 test_server_.GetURL("files/redirect-test.html"), &d, &default_context_); 4198 req.Start(); 4199 base::MessageLoop::current()->Run(); 4200 4201 EXPECT_EQ(1, d.response_started_count()); 4202 EXPECT_EQ(0, d.bytes_received()); 4203 EXPECT_FALSE(d.received_data_before_response()); 4204 EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status()); 4205 } 4206 } 4207 4208 TEST_F(URLRequestTestHTTP, DeferredRedirect) { 4209 ASSERT_TRUE(test_server_.Start()); 4210 4211 TestDelegate d; 4212 { 4213 d.set_quit_on_redirect(true); 4214 GURL test_url(test_server_.GetURL("files/redirect-test.html")); 4215 URLRequest req(test_url, &d, &default_context_); 4216 4217 req.Start(); 4218 base::MessageLoop::current()->Run(); 4219 4220 EXPECT_EQ(1, d.received_redirect_count()); 4221 4222 req.FollowDeferredRedirect(); 4223 base::MessageLoop::current()->Run(); 4224 4225 EXPECT_EQ(1, d.response_started_count()); 4226 EXPECT_FALSE(d.received_data_before_response()); 4227 EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status()); 4228 4229 base::FilePath path; 4230 PathService::Get(base::DIR_SOURCE_ROOT, &path); 4231 path = path.Append(FILE_PATH_LITERAL("net")); 4232 path = path.Append(FILE_PATH_LITERAL("data")); 4233 path = path.Append(FILE_PATH_LITERAL("url_request_unittest")); 4234 path = path.Append(FILE_PATH_LITERAL("with-headers.html")); 4235 4236 std::string contents; 4237 EXPECT_TRUE(file_util::ReadFileToString(path, &contents)); 4238 EXPECT_EQ(contents, d.data_received()); 4239 } 4240 } 4241 4242 TEST_F(URLRequestTestHTTP, DeferredRedirect_GetFullRequestHeaders) { 4243 ASSERT_TRUE(test_server_.Start()); 4244 4245 TestDelegate d; 4246 { 4247 d.set_quit_on_redirect(true); 4248 GURL test_url(test_server_.GetURL("files/redirect-test.html")); 4249 URLRequest req(test_url, &d, &default_context_); 4250 4251 EXPECT_FALSE(d.have_full_request_headers()); 4252 4253 req.Start(); 4254 base::MessageLoop::current()->Run(); 4255 4256 EXPECT_EQ(1, d.received_redirect_count()); 4257 EXPECT_TRUE(d.have_full_request_headers()); 4258 CheckFullRequestHeaders(d.full_request_headers(), test_url); 4259 d.ClearFullRequestHeaders(); 4260 4261 req.FollowDeferredRedirect(); 4262 base::MessageLoop::current()->Run(); 4263 4264 GURL target_url(test_server_.GetURL("files/with-headers.html")); 4265 EXPECT_EQ(1, d.response_started_count()); 4266 EXPECT_TRUE(d.have_full_request_headers()); 4267 CheckFullRequestHeaders(d.full_request_headers(), target_url); 4268 EXPECT_FALSE(d.received_data_before_response()); 4269 EXPECT_EQ(URLRequestStatus::SUCCESS, req.status().status()); 4270 4271 base::FilePath path; 4272 PathService::Get(base::DIR_SOURCE_ROOT, &path); 4273 path = path.Append(FILE_PATH_LITERAL("net")); 4274 path = path.Append(FILE_PATH_LITERAL("data")); 4275 path = path.Append(FILE_PATH_LITERAL("url_request_unittest")); 4276 path = path.Append(FILE_PATH_LITERAL("with-headers.html")); 4277 4278 std::string contents; 4279 EXPECT_TRUE(file_util::ReadFileToString(path, &contents)); 4280 EXPECT_EQ(contents, d.data_received()); 4281 } 4282 } 4283 4284 TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) { 4285 ASSERT_TRUE(test_server_.Start()); 4286 4287 TestDelegate d; 4288 { 4289 d.set_quit_on_redirect(true); 4290 URLRequest req( 4291 test_server_.GetURL("files/redirect-test.html"), &d, &default_context_); 4292 req.Start(); 4293 base::MessageLoop::current()->Run(); 4294 4295 EXPECT_EQ(1, d.received_redirect_count()); 4296 4297 req.Cancel(); 4298 base::MessageLoop::current()->Run(); 4299 4300 EXPECT_EQ(1, d.response_started_count()); 4301 EXPECT_EQ(0, d.bytes_received()); 4302 EXPECT_FALSE(d.received_data_before_response()); 4303 EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status()); 4304 } 4305 } 4306 4307 TEST_F(URLRequestTestHTTP, VaryHeader) { 4308 ASSERT_TRUE(test_server_.Start()); 4309 4310 // Populate the cache. 4311 { 4312 TestDelegate d; 4313 URLRequest req( 4314 test_server_.GetURL("echoheadercache?foo"), &d, &default_context_); 4315 HttpRequestHeaders headers; 4316 headers.SetHeader("foo", "1"); 4317 req.SetExtraRequestHeaders(headers); 4318 req.Start(); 4319 base::MessageLoop::current()->Run(); 4320 4321 LoadTimingInfo load_timing_info; 4322 req.GetLoadTimingInfo(&load_timing_info); 4323 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 4324 } 4325 4326 // Expect a cache hit. 4327 { 4328 TestDelegate d; 4329 URLRequest req( 4330 test_server_.GetURL("echoheadercache?foo"), &d, &default_context_); 4331 HttpRequestHeaders headers; 4332 headers.SetHeader("foo", "1"); 4333 req.SetExtraRequestHeaders(headers); 4334 req.Start(); 4335 base::MessageLoop::current()->Run(); 4336 4337 EXPECT_TRUE(req.was_cached()); 4338 4339 LoadTimingInfo load_timing_info; 4340 req.GetLoadTimingInfo(&load_timing_info); 4341 TestLoadTimingCacheHitNoNetwork(load_timing_info); 4342 } 4343 4344 // Expect a cache miss. 4345 { 4346 TestDelegate d; 4347 URLRequest req( 4348 test_server_.GetURL("echoheadercache?foo"), &d, &default_context_); 4349 HttpRequestHeaders headers; 4350 headers.SetHeader("foo", "2"); 4351 req.SetExtraRequestHeaders(headers); 4352 req.Start(); 4353 base::MessageLoop::current()->Run(); 4354 4355 EXPECT_FALSE(req.was_cached()); 4356 4357 LoadTimingInfo load_timing_info; 4358 req.GetLoadTimingInfo(&load_timing_info); 4359 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 4360 } 4361 } 4362 4363 TEST_F(URLRequestTestHTTP, BasicAuth) { 4364 ASSERT_TRUE(test_server_.Start()); 4365 4366 // populate the cache 4367 { 4368 TestDelegate d; 4369 d.set_credentials(AuthCredentials(kUser, kSecret)); 4370 4371 URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_); 4372 r.Start(); 4373 4374 base::MessageLoop::current()->Run(); 4375 4376 EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos); 4377 } 4378 4379 // repeat request with end-to-end validation. since auth-basic results in a 4380 // cachable page, we expect this test to result in a 304. in which case, the 4381 // response should be fetched from the cache. 4382 { 4383 TestDelegate d; 4384 d.set_credentials(AuthCredentials(kUser, kSecret)); 4385 4386 URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_); 4387 r.set_load_flags(LOAD_VALIDATE_CACHE); 4388 r.Start(); 4389 4390 base::MessageLoop::current()->Run(); 4391 4392 EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos); 4393 4394 // Should be the same cached document. 4395 EXPECT_TRUE(r.was_cached()); 4396 } 4397 } 4398 4399 // Check that Set-Cookie headers in 401 responses are respected. 4400 // http://crbug.com/6450 4401 TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) { 4402 ASSERT_TRUE(test_server_.Start()); 4403 4404 GURL url_requiring_auth = 4405 test_server_.GetURL("auth-basic?set-cookie-if-challenged"); 4406 4407 // Request a page that will give a 401 containing a Set-Cookie header. 4408 // Verify that when the transaction is restarted, it includes the new cookie. 4409 { 4410 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 4411 TestURLRequestContext context(true); 4412 context.set_network_delegate(&network_delegate); 4413 context.Init(); 4414 4415 TestDelegate d; 4416 d.set_credentials(AuthCredentials(kUser, kSecret)); 4417 4418 URLRequest r(url_requiring_auth, &d, &context); 4419 r.Start(); 4420 4421 base::MessageLoop::current()->Run(); 4422 4423 EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos); 4424 4425 // Make sure we sent the cookie in the restarted transaction. 4426 EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true") 4427 != std::string::npos); 4428 } 4429 4430 // Same test as above, except this time the restart is initiated earlier 4431 // (without user intervention since identity is embedded in the URL). 4432 { 4433 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 4434 TestURLRequestContext context(true); 4435 context.set_network_delegate(&network_delegate); 4436 context.Init(); 4437 4438 TestDelegate d; 4439 4440 GURL::Replacements replacements; 4441 std::string username("user2"); 4442 std::string password("secret"); 4443 replacements.SetUsernameStr(username); 4444 replacements.SetPasswordStr(password); 4445 GURL url_with_identity = url_requiring_auth.ReplaceComponents(replacements); 4446 4447 URLRequest r(url_with_identity, &d, &context); 4448 r.Start(); 4449 4450 base::MessageLoop::current()->Run(); 4451 4452 EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos); 4453 4454 // Make sure we sent the cookie in the restarted transaction. 4455 EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true") 4456 != std::string::npos); 4457 } 4458 } 4459 4460 // Tests that load timing works as expected with auth and the cache. 4461 TEST_F(URLRequestTestHTTP, BasicAuthLoadTiming) { 4462 ASSERT_TRUE(test_server_.Start()); 4463 4464 // populate the cache 4465 { 4466 TestDelegate d; 4467 d.set_credentials(AuthCredentials(kUser, kSecret)); 4468 4469 URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_); 4470 r.Start(); 4471 4472 base::MessageLoop::current()->Run(); 4473 4474 EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos); 4475 4476 LoadTimingInfo load_timing_info_before_auth; 4477 EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeAuth( 4478 &load_timing_info_before_auth)); 4479 TestLoadTimingNotReused(load_timing_info_before_auth, 4480 CONNECT_TIMING_HAS_DNS_TIMES); 4481 4482 LoadTimingInfo load_timing_info; 4483 r.GetLoadTimingInfo(&load_timing_info); 4484 // The test server does not support keep alive sockets, so the second 4485 // request with auth should use a new socket. 4486 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 4487 EXPECT_NE(load_timing_info_before_auth.socket_log_id, 4488 load_timing_info.socket_log_id); 4489 EXPECT_LE(load_timing_info_before_auth.receive_headers_end, 4490 load_timing_info.connect_timing.connect_start); 4491 } 4492 4493 // Repeat request with end-to-end validation. Since auth-basic results in a 4494 // cachable page, we expect this test to result in a 304. In which case, the 4495 // response should be fetched from the cache. 4496 { 4497 TestDelegate d; 4498 d.set_credentials(AuthCredentials(kUser, kSecret)); 4499 4500 URLRequest r(test_server_.GetURL("auth-basic"), &d, &default_context_); 4501 r.set_load_flags(LOAD_VALIDATE_CACHE); 4502 r.Start(); 4503 4504 base::MessageLoop::current()->Run(); 4505 4506 EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos); 4507 4508 // Should be the same cached document. 4509 EXPECT_TRUE(r.was_cached()); 4510 4511 // Since there was a request that went over the wire, the load timing 4512 // information should include connection times. 4513 LoadTimingInfo load_timing_info; 4514 r.GetLoadTimingInfo(&load_timing_info); 4515 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES); 4516 } 4517 } 4518 4519 // In this test, we do a POST which the server will 302 redirect. 4520 // The subsequent transaction should use GET, and should not send the 4521 // Content-Type header. 4522 // http://code.google.com/p/chromium/issues/detail?id=843 4523 TEST_F(URLRequestTestHTTP, Post302RedirectGet) { 4524 ASSERT_TRUE(test_server_.Start()); 4525 4526 const char kData[] = "hello world"; 4527 4528 TestDelegate d; 4529 URLRequest req( 4530 test_server_.GetURL("files/redirect-to-echoall"), &d, &default_context_); 4531 req.set_method("POST"); 4532 req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData))); 4533 4534 // Set headers (some of which are specific to the POST). 4535 HttpRequestHeaders headers; 4536 headers.AddHeadersFromString( 4537 "Content-Type: multipart/form-data; " 4538 "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n" 4539 "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9," 4540 "text/plain;q=0.8,image/png,*/*;q=0.5\r\n" 4541 "Accept-Language: en-US,en\r\n" 4542 "Accept-Charset: ISO-8859-1,*,utf-8\r\n" 4543 "Content-Length: 11\r\n" 4544 "Origin: http://localhost:1337/"); 4545 req.SetExtraRequestHeaders(headers); 4546 req.Start(); 4547 base::MessageLoop::current()->Run(); 4548 4549 std::string mime_type; 4550 req.GetMimeType(&mime_type); 4551 EXPECT_EQ("text/html", mime_type); 4552 4553 const std::string& data = d.data_received(); 4554 4555 // Check that the post-specific headers were stripped: 4556 EXPECT_FALSE(ContainsString(data, "Content-Length:")); 4557 EXPECT_FALSE(ContainsString(data, "Content-Type:")); 4558 EXPECT_FALSE(ContainsString(data, "Origin:")); 4559 4560 // These extra request headers should not have been stripped. 4561 EXPECT_TRUE(ContainsString(data, "Accept:")); 4562 EXPECT_TRUE(ContainsString(data, "Accept-Language:")); 4563 EXPECT_TRUE(ContainsString(data, "Accept-Charset:")); 4564 } 4565 4566 // The following tests check that we handle mutating the request method for 4567 // HTTP redirects as expected. 4568 // See http://crbug.com/56373 and http://crbug.com/102130. 4569 4570 TEST_F(URLRequestTestHTTP, Redirect301Tests) { 4571 ASSERT_TRUE(test_server_.Start()); 4572 4573 const GURL url = test_server_.GetURL("files/redirect301-to-echo"); 4574 4575 HTTPRedirectMethodTest(url, "POST", "GET", true); 4576 HTTPRedirectMethodTest(url, "PUT", "PUT", true); 4577 HTTPRedirectMethodTest(url, "HEAD", "HEAD", false); 4578 } 4579 4580 TEST_F(URLRequestTestHTTP, Redirect302Tests) { 4581 ASSERT_TRUE(test_server_.Start()); 4582 4583 const GURL url = test_server_.GetURL("files/redirect302-to-echo"); 4584 4585 HTTPRedirectMethodTest(url, "POST", "GET", true); 4586 HTTPRedirectMethodTest(url, "PUT", "PUT", true); 4587 HTTPRedirectMethodTest(url, "HEAD", "HEAD", false); 4588 } 4589 4590 TEST_F(URLRequestTestHTTP, Redirect303Tests) { 4591 ASSERT_TRUE(test_server_.Start()); 4592 4593 const GURL url = test_server_.GetURL("files/redirect303-to-echo"); 4594 4595 HTTPRedirectMethodTest(url, "POST", "GET", true); 4596 HTTPRedirectMethodTest(url, "PUT", "GET", true); 4597 HTTPRedirectMethodTest(url, "HEAD", "HEAD", false); 4598 } 4599 4600 TEST_F(URLRequestTestHTTP, Redirect307Tests) { 4601 ASSERT_TRUE(test_server_.Start()); 4602 4603 const GURL url = test_server_.GetURL("files/redirect307-to-echo"); 4604 4605 HTTPRedirectMethodTest(url, "POST", "POST", true); 4606 HTTPRedirectMethodTest(url, "PUT", "PUT", true); 4607 HTTPRedirectMethodTest(url, "HEAD", "HEAD", false); 4608 } 4609 4610 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) { 4611 ASSERT_TRUE(test_server_.Start()); 4612 4613 const char kData[] = "hello world"; 4614 4615 TestDelegate d; 4616 URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_); 4617 req.set_method("POST"); 4618 req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData))); 4619 HttpRequestHeaders headers; 4620 headers.SetHeader(HttpRequestHeaders::kContentLength, 4621 base::UintToString(arraysize(kData) - 1)); 4622 req.SetExtraRequestHeaders(headers); 4623 4624 URLRequestRedirectJob* job = new URLRequestRedirectJob( 4625 &req, &default_network_delegate_, test_server_.GetURL("echo"), 4626 URLRequestRedirectJob::REDIRECT_302_FOUND); 4627 AddTestInterceptor()->set_main_intercept_job(job); 4628 4629 req.Start(); 4630 base::MessageLoop::current()->Run(); 4631 EXPECT_EQ("GET", req.method()); 4632 } 4633 4634 TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) { 4635 ASSERT_TRUE(test_server_.Start()); 4636 4637 const char kData[] = "hello world"; 4638 4639 TestDelegate d; 4640 URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_); 4641 req.set_method("POST"); 4642 req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData))); 4643 HttpRequestHeaders headers; 4644 headers.SetHeader(HttpRequestHeaders::kContentLength, 4645 base::UintToString(arraysize(kData) - 1)); 4646 req.SetExtraRequestHeaders(headers); 4647 4648 URLRequestRedirectJob* job = new URLRequestRedirectJob( 4649 &req, &default_network_delegate_, test_server_.GetURL("echo"), 4650 URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT); 4651 AddTestInterceptor()->set_main_intercept_job(job); 4652 4653 req.Start(); 4654 base::MessageLoop::current()->Run(); 4655 EXPECT_EQ("POST", req.method()); 4656 EXPECT_EQ(kData, d.data_received()); 4657 } 4658 4659 // Check that default A-L header is sent. 4660 TEST_F(URLRequestTestHTTP, DefaultAcceptLanguage) { 4661 ASSERT_TRUE(test_server_.Start()); 4662 4663 StaticHttpUserAgentSettings settings("en", EmptyString()); 4664 TestNetworkDelegate network_delegate; // Must outlive URLRequests. 4665 TestURLRequestContext context(true); 4666 context.set_network_delegate(&network_delegate); 4667 context.set_http_user_agent_settings(&settings); 4668 context.Init(); 4669 4670 TestDelegate d; 4671 URLRequest req( 4672 test_server_.GetURL("echoheader?Accept-Language"), &d, &context); 4673 req.Start(); 4674 base::MessageLoop::current()->Run(); 4675 EXPECT_EQ("en", d.data_received()); 4676 } 4677 4678 // Check that an empty A-L header is not sent. http://crbug.com/77365. 4679 TEST_F(URLRequestTestHTTP, EmptyAcceptLanguage) { 4680 ASSERT_TRUE(test_server_.Start()); 4681 4682 StaticHttpUserAgentSettings settings(EmptyString(), EmptyString()); 4683 TestNetworkDelegate network_delegate; // Must outlive URLRequests. 4684 TestURLRequestContext context(true); 4685 context.set_network_delegate(&network_delegate); 4686 context.Init(); 4687 // We override the language after initialization because empty entries 4688 // get overridden by Init(). 4689 context.set_http_user_agent_settings(&settings); 4690 4691 TestDelegate d; 4692 URLRequest req( 4693 test_server_.GetURL("echoheader?Accept-Language"), &d, &context); 4694 req.Start(); 4695 base::MessageLoop::current()->Run(); 4696 EXPECT_EQ("None", d.data_received()); 4697 } 4698 4699 // Check that if request overrides the A-L header, the default is not appended. 4700 // See http://crbug.com/20894 4701 TEST_F(URLRequestTestHTTP, OverrideAcceptLanguage) { 4702 ASSERT_TRUE(test_server_.Start()); 4703 4704 TestDelegate d; 4705 URLRequest req(test_server_.GetURL("echoheader?Accept-Language"), 4706 &d, 4707 &default_context_); 4708 HttpRequestHeaders headers; 4709 headers.SetHeader(HttpRequestHeaders::kAcceptLanguage, "ru"); 4710 req.SetExtraRequestHeaders(headers); 4711 req.Start(); 4712 base::MessageLoop::current()->Run(); 4713 EXPECT_EQ(std::string("ru"), d.data_received()); 4714 } 4715 4716 // Check that default A-E header is sent. 4717 TEST_F(URLRequestTestHTTP, DefaultAcceptEncoding) { 4718 ASSERT_TRUE(test_server_.Start()); 4719 4720 TestDelegate d; 4721 URLRequest req(test_server_.GetURL("echoheader?Accept-Encoding"), 4722 &d, 4723 &default_context_); 4724 HttpRequestHeaders headers; 4725 req.SetExtraRequestHeaders(headers); 4726 req.Start(); 4727 base::MessageLoop::current()->Run(); 4728 EXPECT_TRUE(ContainsString(d.data_received(), "gzip")); 4729 } 4730 4731 // Check that if request overrides the A-E header, the default is not appended. 4732 // See http://crbug.com/47381 4733 TEST_F(URLRequestTestHTTP, OverrideAcceptEncoding) { 4734 ASSERT_TRUE(test_server_.Start()); 4735 4736 TestDelegate d; 4737 URLRequest req(test_server_.GetURL("echoheader?Accept-Encoding"), 4738 &d, 4739 &default_context_); 4740 HttpRequestHeaders headers; 4741 headers.SetHeader(HttpRequestHeaders::kAcceptEncoding, "identity"); 4742 req.SetExtraRequestHeaders(headers); 4743 req.Start(); 4744 base::MessageLoop::current()->Run(); 4745 EXPECT_FALSE(ContainsString(d.data_received(), "gzip")); 4746 EXPECT_TRUE(ContainsString(d.data_received(), "identity")); 4747 } 4748 4749 // Check that setting the A-C header sends the proper header. 4750 TEST_F(URLRequestTestHTTP, SetAcceptCharset) { 4751 ASSERT_TRUE(test_server_.Start()); 4752 4753 TestDelegate d; 4754 URLRequest req(test_server_.GetURL("echoheader?Accept-Charset"), 4755 &d, 4756 &default_context_); 4757 HttpRequestHeaders headers; 4758 headers.SetHeader(HttpRequestHeaders::kAcceptCharset, "koi-8r"); 4759 req.SetExtraRequestHeaders(headers); 4760 req.Start(); 4761 base::MessageLoop::current()->Run(); 4762 EXPECT_EQ(std::string("koi-8r"), d.data_received()); 4763 } 4764 4765 // Check that default User-Agent header is sent. 4766 TEST_F(URLRequestTestHTTP, DefaultUserAgent) { 4767 ASSERT_TRUE(test_server_.Start()); 4768 4769 TestDelegate d; 4770 URLRequest req(test_server_.GetURL("echoheader?User-Agent"), 4771 &d, 4772 &default_context_); 4773 req.Start(); 4774 base::MessageLoop::current()->Run(); 4775 EXPECT_EQ(req.context()->GetUserAgent(req.url()), d.data_received()); 4776 } 4777 4778 // Check that if request overrides the User-Agent header, 4779 // the default is not appended. 4780 TEST_F(URLRequestTestHTTP, OverrideUserAgent) { 4781 ASSERT_TRUE(test_server_.Start()); 4782 4783 TestDelegate d; 4784 URLRequest req(test_server_.GetURL("echoheader?User-Agent"), 4785 &d, 4786 &default_context_); 4787 HttpRequestHeaders headers; 4788 headers.SetHeader(HttpRequestHeaders::kUserAgent, "Lynx (textmode)"); 4789 req.SetExtraRequestHeaders(headers); 4790 req.Start(); 4791 base::MessageLoop::current()->Run(); 4792 // If the net tests are being run with ChromeFrame then we need to allow for 4793 // the 'chromeframe' suffix which is added to the user agent before the 4794 // closing parentheses. 4795 EXPECT_TRUE(StartsWithASCII(d.data_received(), "Lynx (textmode", true)); 4796 } 4797 4798 // Check that a NULL HttpUserAgentSettings causes the corresponding empty 4799 // User-Agent header to be sent but does not send the Accept-Language and 4800 // Accept-Charset headers. 4801 TEST_F(URLRequestTestHTTP, EmptyHttpUserAgentSettings) { 4802 ASSERT_TRUE(test_server_.Start()); 4803 4804 TestNetworkDelegate network_delegate; // Must outlive URLRequests. 4805 TestURLRequestContext context(true); 4806 context.set_network_delegate(&network_delegate); 4807 context.Init(); 4808 // We override the HttpUserAgentSettings after initialization because empty 4809 // entries get overridden by Init(). 4810 context.set_http_user_agent_settings(NULL); 4811 4812 struct { 4813 const char* request; 4814 const char* expected_response; 4815 } tests[] = { { "echoheader?Accept-Language", "None" }, 4816 { "echoheader?Accept-Charset", "None" }, 4817 { "echoheader?User-Agent", "" } }; 4818 4819 for (size_t i = 0; i < ARRAYSIZE_UNSAFE(tests); i++) { 4820 TestDelegate d; 4821 URLRequest req(test_server_.GetURL(tests[i].request), &d, &context); 4822 req.Start(); 4823 base::MessageLoop::current()->Run(); 4824 EXPECT_EQ(tests[i].expected_response, d.data_received()) 4825 << " Request = \"" << tests[i].request << "\""; 4826 } 4827 } 4828 4829 // Make sure that URLRequest passes on its priority updates to 4830 // newly-created jobs after the first one. 4831 TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) { 4832 ASSERT_TRUE(test_server_.Start()); 4833 4834 TestDelegate d; 4835 URLRequest req(test_server_.GetURL("empty.html"), &d, &default_context_); 4836 EXPECT_EQ(DEFAULT_PRIORITY, req.priority()); 4837 4838 scoped_refptr<URLRequestRedirectJob> redirect_job = 4839 new URLRequestRedirectJob( 4840 &req, &default_network_delegate_, test_server_.GetURL("echo"), 4841 URLRequestRedirectJob::REDIRECT_302_FOUND); 4842 AddTestInterceptor()->set_main_intercept_job(redirect_job.get()); 4843 4844 req.SetPriority(LOW); 4845 req.Start(); 4846 EXPECT_TRUE(req.is_pending()); 4847 4848 scoped_refptr<URLRequestTestJob> job = 4849 new URLRequestTestJob(&req, &default_network_delegate_); 4850 AddTestInterceptor()->set_main_intercept_job(job.get()); 4851 4852 // Should trigger |job| to be started. 4853 base::MessageLoop::current()->Run(); 4854 EXPECT_EQ(LOW, job->priority()); 4855 } 4856 4857 class HTTPSRequestTest : public testing::Test { 4858 public: 4859 HTTPSRequestTest() : default_context_(true) { 4860 default_context_.set_network_delegate(&default_network_delegate_); 4861 default_context_.Init(); 4862 } 4863 virtual ~HTTPSRequestTest() {} 4864 4865 protected: 4866 TestNetworkDelegate default_network_delegate_; // Must outlive URLRequest. 4867 TestURLRequestContext default_context_; 4868 }; 4869 4870 TEST_F(HTTPSRequestTest, HTTPSGetTest) { 4871 SpawnedTestServer test_server( 4872 SpawnedTestServer::TYPE_HTTPS, 4873 SpawnedTestServer::kLocalhost, 4874 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 4875 ASSERT_TRUE(test_server.Start()); 4876 4877 TestDelegate d; 4878 { 4879 URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); 4880 r.Start(); 4881 EXPECT_TRUE(r.is_pending()); 4882 4883 base::MessageLoop::current()->Run(); 4884 4885 EXPECT_EQ(1, d.response_started_count()); 4886 EXPECT_FALSE(d.received_data_before_response()); 4887 EXPECT_NE(0, d.bytes_received()); 4888 CheckSSLInfo(r.ssl_info()); 4889 EXPECT_EQ(test_server.host_port_pair().host(), 4890 r.GetSocketAddress().host()); 4891 EXPECT_EQ(test_server.host_port_pair().port(), 4892 r.GetSocketAddress().port()); 4893 } 4894 } 4895 4896 TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) { 4897 SpawnedTestServer::SSLOptions ssl_options( 4898 SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME); 4899 SpawnedTestServer test_server( 4900 SpawnedTestServer::TYPE_HTTPS, 4901 ssl_options, 4902 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 4903 ASSERT_TRUE(test_server.Start()); 4904 4905 bool err_allowed = true; 4906 for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) { 4907 TestDelegate d; 4908 { 4909 d.set_allow_certificate_errors(err_allowed); 4910 URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); 4911 4912 r.Start(); 4913 EXPECT_TRUE(r.is_pending()); 4914 4915 base::MessageLoop::current()->Run(); 4916 4917 EXPECT_EQ(1, d.response_started_count()); 4918 EXPECT_FALSE(d.received_data_before_response()); 4919 EXPECT_TRUE(d.have_certificate_errors()); 4920 if (err_allowed) { 4921 EXPECT_NE(0, d.bytes_received()); 4922 CheckSSLInfo(r.ssl_info()); 4923 } else { 4924 EXPECT_EQ(0, d.bytes_received()); 4925 } 4926 } 4927 } 4928 } 4929 4930 TEST_F(HTTPSRequestTest, HTTPSExpiredTest) { 4931 SpawnedTestServer::SSLOptions ssl_options( 4932 SpawnedTestServer::SSLOptions::CERT_EXPIRED); 4933 SpawnedTestServer test_server( 4934 SpawnedTestServer::TYPE_HTTPS, 4935 ssl_options, 4936 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 4937 ASSERT_TRUE(test_server.Start()); 4938 4939 // Iterate from false to true, just so that we do the opposite of the 4940 // previous test in order to increase test coverage. 4941 bool err_allowed = false; 4942 for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) { 4943 TestDelegate d; 4944 { 4945 d.set_allow_certificate_errors(err_allowed); 4946 URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); 4947 4948 r.Start(); 4949 EXPECT_TRUE(r.is_pending()); 4950 4951 base::MessageLoop::current()->Run(); 4952 4953 EXPECT_EQ(1, d.response_started_count()); 4954 EXPECT_FALSE(d.received_data_before_response()); 4955 EXPECT_TRUE(d.have_certificate_errors()); 4956 if (err_allowed) { 4957 EXPECT_NE(0, d.bytes_received()); 4958 CheckSSLInfo(r.ssl_info()); 4959 } else { 4960 EXPECT_EQ(0, d.bytes_received()); 4961 } 4962 } 4963 } 4964 } 4965 4966 // Tests TLSv1.1 -> TLSv1 fallback. Verifies that we don't fall back more 4967 // than necessary. 4968 TEST_F(HTTPSRequestTest, TLSv1Fallback) { 4969 uint16 default_version_max = SSLConfigService::default_version_max(); 4970 // The OpenSSL library in use may not support TLS 1.1. 4971 #if !defined(USE_OPENSSL) 4972 EXPECT_GT(default_version_max, SSL_PROTOCOL_VERSION_TLS1); 4973 #endif 4974 if (default_version_max <= SSL_PROTOCOL_VERSION_TLS1) 4975 return; 4976 4977 SpawnedTestServer::SSLOptions ssl_options( 4978 SpawnedTestServer::SSLOptions::CERT_OK); 4979 ssl_options.tls_intolerant = 4980 SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_1; 4981 SpawnedTestServer test_server( 4982 SpawnedTestServer::TYPE_HTTPS, 4983 ssl_options, 4984 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 4985 ASSERT_TRUE(test_server.Start()); 4986 4987 TestDelegate d; 4988 TestURLRequestContext context(true); 4989 context.Init(); 4990 d.set_allow_certificate_errors(true); 4991 URLRequest r(test_server.GetURL(std::string()), &d, &context); 4992 r.Start(); 4993 4994 base::MessageLoop::current()->Run(); 4995 4996 EXPECT_EQ(1, d.response_started_count()); 4997 EXPECT_NE(0, d.bytes_received()); 4998 EXPECT_EQ(static_cast<int>(SSL_CONNECTION_VERSION_TLS1), 4999 SSLConnectionStatusToVersion(r.ssl_info().connection_status)); 5000 EXPECT_TRUE(r.ssl_info().connection_status & SSL_CONNECTION_VERSION_FALLBACK); 5001 } 5002 5003 // This tests that a load of www.google.com with a certificate error sets 5004 // the |certificate_errors_are_fatal| flag correctly. This flag will cause 5005 // the interstitial to be fatal. 5006 TEST_F(HTTPSRequestTest, HTTPSPreloadedHSTSTest) { 5007 SpawnedTestServer::SSLOptions ssl_options( 5008 SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME); 5009 SpawnedTestServer test_server( 5010 SpawnedTestServer::TYPE_HTTPS, 5011 ssl_options, 5012 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5013 ASSERT_TRUE(test_server.Start()); 5014 5015 // We require that the URL be www.google.com in order to pick up the 5016 // preloaded HSTS entries in the TransportSecurityState. This means that we 5017 // have to use a MockHostResolver in order to direct www.google.com to the 5018 // testserver. By default, MockHostResolver maps all hosts to 127.0.0.1. 5019 5020 MockHostResolver host_resolver; 5021 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 5022 TestURLRequestContext context(true); 5023 context.set_network_delegate(&network_delegate); 5024 context.set_host_resolver(&host_resolver); 5025 TransportSecurityState transport_security_state; 5026 context.set_transport_security_state(&transport_security_state); 5027 context.Init(); 5028 5029 TestDelegate d; 5030 URLRequest r(GURL(base::StringPrintf("https://www.google.com:%d", 5031 test_server.host_port_pair().port())), 5032 &d, 5033 &context); 5034 5035 r.Start(); 5036 EXPECT_TRUE(r.is_pending()); 5037 5038 base::MessageLoop::current()->Run(); 5039 5040 EXPECT_EQ(1, d.response_started_count()); 5041 EXPECT_FALSE(d.received_data_before_response()); 5042 EXPECT_TRUE(d.have_certificate_errors()); 5043 EXPECT_TRUE(d.certificate_errors_are_fatal()); 5044 } 5045 5046 // This tests that cached HTTPS page loads do not cause any updates to the 5047 // TransportSecurityState. 5048 TEST_F(HTTPSRequestTest, HTTPSErrorsNoClobberTSSTest) { 5049 // The actual problem -- CERT_MISMATCHED_NAME in this case -- doesn't 5050 // matter. It just has to be any error. 5051 SpawnedTestServer::SSLOptions ssl_options( 5052 SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME); 5053 SpawnedTestServer test_server( 5054 SpawnedTestServer::TYPE_HTTPS, 5055 ssl_options, 5056 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5057 ASSERT_TRUE(test_server.Start()); 5058 5059 // We require that the URL be www.google.com in order to pick up the 5060 // preloaded and dynamic HSTS and public key pin entries in the 5061 // TransportSecurityState. This means that we have to use a 5062 // MockHostResolver in order to direct www.google.com to the testserver. 5063 // By default, MockHostResolver maps all hosts to 127.0.0.1. 5064 5065 MockHostResolver host_resolver; 5066 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 5067 TestURLRequestContext context(true); 5068 context.set_network_delegate(&network_delegate); 5069 context.set_host_resolver(&host_resolver); 5070 TransportSecurityState transport_security_state; 5071 TransportSecurityState::DomainState domain_state; 5072 EXPECT_TRUE(transport_security_state.GetDomainState("www.google.com", true, 5073 &domain_state)); 5074 context.set_transport_security_state(&transport_security_state); 5075 context.Init(); 5076 5077 TestDelegate d; 5078 URLRequest r(GURL(base::StringPrintf("https://www.google.com:%d", 5079 test_server.host_port_pair().port())), 5080 &d, 5081 &context); 5082 5083 r.Start(); 5084 EXPECT_TRUE(r.is_pending()); 5085 5086 base::MessageLoop::current()->Run(); 5087 5088 EXPECT_EQ(1, d.response_started_count()); 5089 EXPECT_FALSE(d.received_data_before_response()); 5090 EXPECT_TRUE(d.have_certificate_errors()); 5091 EXPECT_TRUE(d.certificate_errors_are_fatal()); 5092 5093 // Get a fresh copy of the state, and check that it hasn't been updated. 5094 TransportSecurityState::DomainState new_domain_state; 5095 EXPECT_TRUE(transport_security_state.GetDomainState("www.google.com", true, 5096 &new_domain_state)); 5097 EXPECT_EQ(new_domain_state.upgrade_mode, domain_state.upgrade_mode); 5098 EXPECT_EQ(new_domain_state.sts_include_subdomains, 5099 domain_state.sts_include_subdomains); 5100 EXPECT_EQ(new_domain_state.pkp_include_subdomains, 5101 domain_state.pkp_include_subdomains); 5102 EXPECT_TRUE(FingerprintsEqual(new_domain_state.static_spki_hashes, 5103 domain_state.static_spki_hashes)); 5104 EXPECT_TRUE(FingerprintsEqual(new_domain_state.dynamic_spki_hashes, 5105 domain_state.dynamic_spki_hashes)); 5106 EXPECT_TRUE(FingerprintsEqual(new_domain_state.bad_static_spki_hashes, 5107 domain_state.bad_static_spki_hashes)); 5108 } 5109 5110 // Make sure HSTS preserves a POST request's method and body. 5111 TEST_F(HTTPSRequestTest, HSTSPreservesPosts) { 5112 static const char kData[] = "hello world"; 5113 5114 SpawnedTestServer::SSLOptions ssl_options( 5115 SpawnedTestServer::SSLOptions::CERT_OK); 5116 SpawnedTestServer test_server( 5117 SpawnedTestServer::TYPE_HTTPS, 5118 ssl_options, 5119 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5120 ASSERT_TRUE(test_server.Start()); 5121 5122 5123 // Per spec, TransportSecurityState expects a domain name, rather than an IP 5124 // address, so a MockHostResolver is needed to redirect www.somewhere.com to 5125 // the SpawnedTestServer. By default, MockHostResolver maps all hosts 5126 // to 127.0.0.1. 5127 MockHostResolver host_resolver; 5128 5129 // Force https for www.somewhere.com. 5130 TransportSecurityState transport_security_state; 5131 base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000); 5132 bool include_subdomains = false; 5133 transport_security_state.AddHSTS("www.somewhere.com", expiry, 5134 include_subdomains); 5135 5136 TestNetworkDelegate network_delegate; // Must outlive URLRequest. 5137 5138 TestURLRequestContext context(true); 5139 context.set_host_resolver(&host_resolver); 5140 context.set_transport_security_state(&transport_security_state); 5141 context.set_network_delegate(&network_delegate); 5142 context.Init(); 5143 5144 TestDelegate d; 5145 // Navigating to https://www.somewhere.com instead of https://127.0.0.1 will 5146 // cause a certificate error. Ignore the error. 5147 d.set_allow_certificate_errors(true); 5148 5149 URLRequest req(GURL(base::StringPrintf("http://www.somewhere.com:%d/echo", 5150 test_server.host_port_pair().port())), 5151 &d, 5152 &context); 5153 req.set_method("POST"); 5154 req.set_upload(make_scoped_ptr(CreateSimpleUploadData(kData))); 5155 5156 req.Start(); 5157 base::MessageLoop::current()->Run(); 5158 5159 EXPECT_EQ("https", req.url().scheme()); 5160 EXPECT_EQ("POST", req.method()); 5161 EXPECT_EQ(kData, d.data_received()); 5162 5163 LoadTimingInfo load_timing_info; 5164 network_delegate.GetLoadTimingInfoBeforeRedirect(&load_timing_info); 5165 // LoadTimingInfo of HSTS redirects is similar to that of network cache hits 5166 TestLoadTimingCacheHitNoNetwork(load_timing_info); 5167 } 5168 5169 TEST_F(HTTPSRequestTest, SSLv3Fallback) { 5170 SpawnedTestServer::SSLOptions ssl_options( 5171 SpawnedTestServer::SSLOptions::CERT_OK); 5172 ssl_options.tls_intolerant = 5173 SpawnedTestServer::SSLOptions::TLS_INTOLERANT_ALL; 5174 SpawnedTestServer test_server( 5175 SpawnedTestServer::TYPE_HTTPS, 5176 ssl_options, 5177 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5178 ASSERT_TRUE(test_server.Start()); 5179 5180 TestDelegate d; 5181 TestURLRequestContext context(true); 5182 context.Init(); 5183 d.set_allow_certificate_errors(true); 5184 URLRequest r(test_server.GetURL(std::string()), &d, &context); 5185 r.Start(); 5186 5187 base::MessageLoop::current()->Run(); 5188 5189 EXPECT_EQ(1, d.response_started_count()); 5190 EXPECT_NE(0, d.bytes_received()); 5191 EXPECT_EQ(static_cast<int>(SSL_CONNECTION_VERSION_SSL3), 5192 SSLConnectionStatusToVersion(r.ssl_info().connection_status)); 5193 EXPECT_TRUE(r.ssl_info().connection_status & SSL_CONNECTION_VERSION_FALLBACK); 5194 } 5195 5196 namespace { 5197 5198 class SSLClientAuthTestDelegate : public TestDelegate { 5199 public: 5200 SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) { 5201 } 5202 virtual void OnCertificateRequested( 5203 URLRequest* request, 5204 SSLCertRequestInfo* cert_request_info) OVERRIDE { 5205 on_certificate_requested_count_++; 5206 base::MessageLoop::current()->Quit(); 5207 } 5208 int on_certificate_requested_count() { 5209 return on_certificate_requested_count_; 5210 } 5211 private: 5212 int on_certificate_requested_count_; 5213 }; 5214 5215 } // namespace 5216 5217 // TODO(davidben): Test the rest of the code. Specifically, 5218 // - Filtering which certificates to select. 5219 // - Sending a certificate back. 5220 // - Getting a certificate request in an SSL renegotiation sending the 5221 // HTTP request. 5222 TEST_F(HTTPSRequestTest, ClientAuthTest) { 5223 SpawnedTestServer::SSLOptions ssl_options; 5224 ssl_options.request_client_certificate = true; 5225 SpawnedTestServer test_server( 5226 SpawnedTestServer::TYPE_HTTPS, 5227 ssl_options, 5228 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5229 ASSERT_TRUE(test_server.Start()); 5230 5231 SSLClientAuthTestDelegate d; 5232 { 5233 URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); 5234 5235 r.Start(); 5236 EXPECT_TRUE(r.is_pending()); 5237 5238 base::MessageLoop::current()->Run(); 5239 5240 EXPECT_EQ(1, d.on_certificate_requested_count()); 5241 EXPECT_FALSE(d.received_data_before_response()); 5242 EXPECT_EQ(0, d.bytes_received()); 5243 5244 // Send no certificate. 5245 // TODO(davidben): Get temporary client cert import (with keys) working on 5246 // all platforms so we can test sending a cert as well. 5247 r.ContinueWithCertificate(NULL); 5248 5249 base::MessageLoop::current()->Run(); 5250 5251 EXPECT_EQ(1, d.response_started_count()); 5252 EXPECT_FALSE(d.received_data_before_response()); 5253 EXPECT_NE(0, d.bytes_received()); 5254 } 5255 } 5256 5257 TEST_F(HTTPSRequestTest, ResumeTest) { 5258 // Test that we attempt a session resume when making two connections to the 5259 // same host. 5260 SpawnedTestServer::SSLOptions ssl_options; 5261 ssl_options.record_resume = true; 5262 SpawnedTestServer test_server( 5263 SpawnedTestServer::TYPE_HTTPS, 5264 ssl_options, 5265 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5266 ASSERT_TRUE(test_server.Start()); 5267 5268 SSLClientSocket::ClearSessionCache(); 5269 5270 { 5271 TestDelegate d; 5272 URLRequest r( 5273 test_server.GetURL("ssl-session-cache"), &d, &default_context_); 5274 5275 r.Start(); 5276 EXPECT_TRUE(r.is_pending()); 5277 5278 base::MessageLoop::current()->Run(); 5279 5280 EXPECT_EQ(1, d.response_started_count()); 5281 } 5282 5283 reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())-> 5284 CloseAllConnections(); 5285 5286 { 5287 TestDelegate d; 5288 URLRequest r( 5289 test_server.GetURL("ssl-session-cache"), &d, &default_context_); 5290 5291 r.Start(); 5292 EXPECT_TRUE(r.is_pending()); 5293 5294 base::MessageLoop::current()->Run(); 5295 5296 // The response will look like; 5297 // insert abc 5298 // lookup abc 5299 // insert xyz 5300 // 5301 // With a newline at the end which makes the split think that there are 5302 // four lines. 5303 5304 EXPECT_EQ(1, d.response_started_count()); 5305 std::vector<std::string> lines; 5306 base::SplitString(d.data_received(), '\n', &lines); 5307 ASSERT_EQ(4u, lines.size()) << d.data_received(); 5308 5309 std::string session_id; 5310 5311 for (size_t i = 0; i < 2; i++) { 5312 std::vector<std::string> parts; 5313 base::SplitString(lines[i], '\t', &parts); 5314 ASSERT_EQ(2u, parts.size()); 5315 if (i == 0) { 5316 EXPECT_EQ("insert", parts[0]); 5317 session_id = parts[1]; 5318 } else { 5319 EXPECT_EQ("lookup", parts[0]); 5320 EXPECT_EQ(session_id, parts[1]); 5321 } 5322 } 5323 } 5324 } 5325 5326 TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) { 5327 // Test that sessions aren't resumed when the value of ssl_session_cache_shard 5328 // differs. 5329 SpawnedTestServer::SSLOptions ssl_options; 5330 ssl_options.record_resume = true; 5331 SpawnedTestServer test_server( 5332 SpawnedTestServer::TYPE_HTTPS, 5333 ssl_options, 5334 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5335 ASSERT_TRUE(test_server.Start()); 5336 5337 SSLClientSocket::ClearSessionCache(); 5338 5339 { 5340 TestDelegate d; 5341 URLRequest r( 5342 test_server.GetURL("ssl-session-cache"), &d, &default_context_); 5343 5344 r.Start(); 5345 EXPECT_TRUE(r.is_pending()); 5346 5347 base::MessageLoop::current()->Run(); 5348 5349 EXPECT_EQ(1, d.response_started_count()); 5350 } 5351 5352 // Now create a new HttpCache with a different ssl_session_cache_shard value. 5353 HttpNetworkSession::Params params; 5354 params.host_resolver = default_context_.host_resolver(); 5355 params.cert_verifier = default_context_.cert_verifier(); 5356 params.transport_security_state = default_context_.transport_security_state(); 5357 params.proxy_service = default_context_.proxy_service(); 5358 params.ssl_config_service = default_context_.ssl_config_service(); 5359 params.http_auth_handler_factory = 5360 default_context_.http_auth_handler_factory(); 5361 params.network_delegate = &default_network_delegate_; 5362 params.http_server_properties = default_context_.http_server_properties(); 5363 params.ssl_session_cache_shard = "alternate"; 5364 5365 scoped_ptr<net::HttpCache> cache(new net::HttpCache( 5366 new net::HttpNetworkSession(params), 5367 net::HttpCache::DefaultBackend::InMemory(0))); 5368 5369 default_context_.set_http_transaction_factory(cache.get()); 5370 5371 { 5372 TestDelegate d; 5373 URLRequest r( 5374 test_server.GetURL("ssl-session-cache"), &d, &default_context_); 5375 5376 r.Start(); 5377 EXPECT_TRUE(r.is_pending()); 5378 5379 base::MessageLoop::current()->Run(); 5380 5381 // The response will look like; 5382 // insert abc 5383 // insert xyz 5384 // 5385 // With a newline at the end which makes the split think that there are 5386 // three lines. 5387 5388 EXPECT_EQ(1, d.response_started_count()); 5389 std::vector<std::string> lines; 5390 base::SplitString(d.data_received(), '\n', &lines); 5391 ASSERT_EQ(3u, lines.size()); 5392 5393 std::string session_id; 5394 for (size_t i = 0; i < 2; i++) { 5395 std::vector<std::string> parts; 5396 base::SplitString(lines[i], '\t', &parts); 5397 ASSERT_EQ(2u, parts.size()); 5398 EXPECT_EQ("insert", parts[0]); 5399 if (i == 0) { 5400 session_id = parts[1]; 5401 } else { 5402 EXPECT_NE(session_id, parts[1]); 5403 } 5404 } 5405 } 5406 } 5407 5408 class TestSSLConfigService : public SSLConfigService { 5409 public: 5410 TestSSLConfigService(bool ev_enabled, 5411 bool online_rev_checking, 5412 bool rev_checking_required_local_anchors) 5413 : ev_enabled_(ev_enabled), 5414 online_rev_checking_(online_rev_checking), 5415 rev_checking_required_local_anchors_( 5416 rev_checking_required_local_anchors) {} 5417 5418 // SSLConfigService: 5419 virtual void GetSSLConfig(SSLConfig* config) OVERRIDE { 5420 *config = SSLConfig(); 5421 config->rev_checking_enabled = online_rev_checking_; 5422 config->verify_ev_cert = ev_enabled_; 5423 config->rev_checking_required_local_anchors = 5424 rev_checking_required_local_anchors_; 5425 } 5426 5427 protected: 5428 virtual ~TestSSLConfigService() {} 5429 5430 private: 5431 const bool ev_enabled_; 5432 const bool online_rev_checking_; 5433 const bool rev_checking_required_local_anchors_; 5434 }; 5435 5436 // This the fingerprint of the "Testing CA" certificate used by the testserver. 5437 // See net/data/ssl/certificates/ocsp-test-root.pem. 5438 static const SHA1HashValue kOCSPTestCertFingerprint = 5439 { { 0xf1, 0xad, 0xf6, 0xce, 0x42, 0xac, 0xe7, 0xb4, 0xf4, 0x24, 5440 0xdb, 0x1a, 0xf7, 0xa0, 0x9f, 0x09, 0xa1, 0xea, 0xf1, 0x5c } }; 5441 5442 // This is the SHA256, SPKI hash of the "Testing CA" certificate used by the 5443 // testserver. 5444 static const SHA256HashValue kOCSPTestCertSPKI = { { 5445 0xee, 0xe6, 0x51, 0x2d, 0x4c, 0xfa, 0xf7, 0x3e, 5446 0x6c, 0xd8, 0xca, 0x67, 0xed, 0xb5, 0x5d, 0x49, 5447 0x76, 0xe1, 0x52, 0xa7, 0x6e, 0x0e, 0xa0, 0x74, 5448 0x09, 0x75, 0xe6, 0x23, 0x24, 0xbd, 0x1b, 0x28, 5449 } }; 5450 5451 // This is the policy OID contained in the certificates that testserver 5452 // generates. 5453 static const char kOCSPTestCertPolicy[] = "1.3.6.1.4.1.11129.2.4.1"; 5454 5455 class HTTPSOCSPTest : public HTTPSRequestTest { 5456 public: 5457 HTTPSOCSPTest() 5458 : context_(true), 5459 ev_test_policy_( 5460 new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(), 5461 kOCSPTestCertFingerprint, 5462 kOCSPTestCertPolicy)) { 5463 } 5464 5465 virtual void SetUp() OVERRIDE { 5466 SetupContext(&context_); 5467 context_.Init(); 5468 5469 scoped_refptr<net::X509Certificate> root_cert = 5470 ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem"); 5471 CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert); 5472 test_root_.reset(new ScopedTestRoot(root_cert.get())); 5473 5474 #if defined(USE_NSS) || defined(OS_IOS) 5475 SetURLRequestContextForNSSHttpIO(&context_); 5476 EnsureNSSHttpIOInit(); 5477 #endif 5478 } 5479 5480 void DoConnection(const SpawnedTestServer::SSLOptions& ssl_options, 5481 CertStatus* out_cert_status) { 5482 // We always overwrite out_cert_status. 5483 *out_cert_status = 0; 5484 SpawnedTestServer test_server( 5485 SpawnedTestServer::TYPE_HTTPS, 5486 ssl_options, 5487 base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))); 5488 ASSERT_TRUE(test_server.Start()); 5489 5490 TestDelegate d; 5491 d.set_allow_certificate_errors(true); 5492 URLRequest r(test_server.GetURL(std::string()), &d, &context_); 5493 r.Start(); 5494 5495 base::MessageLoop::current()->Run(); 5496 5497 EXPECT_EQ(1, d.response_started_count()); 5498 *out_cert_status = r.ssl_info().cert_status; 5499 } 5500 5501 virtual ~HTTPSOCSPTest() { 5502 #if defined(USE_NSS) || defined(OS_IOS) 5503 ShutdownNSSHttpIO(); 5504 #endif 5505 } 5506 5507 protected: 5508 // SetupContext configures the URLRequestContext that will be used for making 5509 // connetions to testserver. This can be overridden in test subclasses for 5510 // different behaviour. 5511 virtual void SetupContext(URLRequestContext* context) { 5512 context->set_ssl_config_service( 5513 new TestSSLConfigService(true /* check for EV */, 5514 true /* online revocation checking */, 5515 false /* require rev. checking for local 5516 anchors */)); 5517 } 5518 5519 scoped_ptr<ScopedTestRoot> test_root_; 5520 TestURLRequestContext context_; 5521 scoped_ptr<ScopedTestEVPolicy> ev_test_policy_; 5522 }; 5523 5524 static CertStatus ExpectedCertStatusForFailedOnlineRevocationCheck() { 5525 #if defined(OS_WIN) 5526 // Windows can return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION but we don't 5527 // have that ability on other platforms. 5528 return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION; 5529 #else 5530 return 0; 5531 #endif 5532 } 5533 5534 // SystemSupportsHardFailRevocationChecking returns true iff the current 5535 // operating system supports revocation checking and can distinguish between 5536 // situations where a given certificate lacks any revocation information (eg: 5537 // no CRLDistributionPoints and no OCSP Responder AuthorityInfoAccess) and when 5538 // revocation information cannot be obtained (eg: the CRL was unreachable). 5539 // If it does not, then tests which rely on 'hard fail' behaviour should be 5540 // skipped. 5541 static bool SystemSupportsHardFailRevocationChecking() { 5542 #if defined(OS_WIN) || defined(USE_NSS) || defined(OS_IOS) 5543 return true; 5544 #else 5545 return false; 5546 #endif 5547 } 5548 5549 // SystemUsesChromiumEVMetadata returns true iff the current operating system 5550 // uses Chromium's EV metadata (i.e. EVRootCAMetadata). If it does not, then 5551 // several tests are effected because our testing EV certificate won't be 5552 // recognised as EV. 5553 static bool SystemUsesChromiumEVMetadata() { 5554 #if defined(USE_OPENSSL) 5555 // http://crbug.com/117478 - OpenSSL does not support EV validation. 5556 return false; 5557 #elif defined(OS_MACOSX) && !defined(OS_IOS) 5558 // On OS X, we use the system to tell us whether a certificate is EV or not 5559 // and the system won't recognise our testing root. 5560 return false; 5561 #else 5562 return true; 5563 #endif 5564 } 5565 5566 static bool SystemSupportsOCSP() { 5567 #if defined(USE_OPENSSL) 5568 // http://crbug.com/117478 - OpenSSL does not support OCSP. 5569 return false; 5570 #elif defined(OS_WIN) 5571 return base::win::GetVersion() >= base::win::VERSION_VISTA; 5572 #elif defined(OS_ANDROID) 5573 // TODO(jnd): http://crbug.com/117478 - EV verification is not yet supported. 5574 return false; 5575 #else 5576 return true; 5577 #endif 5578 } 5579 5580 TEST_F(HTTPSOCSPTest, Valid) { 5581 if (!SystemSupportsOCSP()) { 5582 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5583 return; 5584 } 5585 5586 SpawnedTestServer::SSLOptions ssl_options( 5587 SpawnedTestServer::SSLOptions::CERT_AUTO); 5588 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK; 5589 5590 CertStatus cert_status; 5591 DoConnection(ssl_options, &cert_status); 5592 5593 EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS); 5594 5595 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5596 static_cast<bool>(cert_status & CERT_STATUS_IS_EV)); 5597 5598 EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED); 5599 } 5600 5601 TEST_F(HTTPSOCSPTest, Revoked) { 5602 if (!SystemSupportsOCSP()) { 5603 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5604 return; 5605 } 5606 5607 SpawnedTestServer::SSLOptions ssl_options( 5608 SpawnedTestServer::SSLOptions::CERT_AUTO); 5609 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED; 5610 5611 CertStatus cert_status; 5612 DoConnection(ssl_options, &cert_status); 5613 5614 #if !(defined(OS_MACOSX) && !defined(OS_IOS)) 5615 // Doesn't pass on OS X yet for reasons that need to be investigated. 5616 EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS); 5617 #endif 5618 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5619 EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED); 5620 } 5621 5622 TEST_F(HTTPSOCSPTest, Invalid) { 5623 if (!SystemSupportsOCSP()) { 5624 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5625 return; 5626 } 5627 5628 SpawnedTestServer::SSLOptions ssl_options( 5629 SpawnedTestServer::SSLOptions::CERT_AUTO); 5630 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5631 5632 CertStatus cert_status; 5633 DoConnection(ssl_options, &cert_status); 5634 5635 EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(), 5636 cert_status & CERT_STATUS_ALL_ERRORS); 5637 5638 // Without a positive OCSP response, we shouldn't show the EV status. 5639 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5640 EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED); 5641 } 5642 5643 class HTTPSHardFailTest : public HTTPSOCSPTest { 5644 protected: 5645 virtual void SetupContext(URLRequestContext* context) OVERRIDE { 5646 context->set_ssl_config_service( 5647 new TestSSLConfigService(false /* check for EV */, 5648 false /* online revocation checking */, 5649 true /* require rev. checking for local 5650 anchors */)); 5651 } 5652 }; 5653 5654 5655 TEST_F(HTTPSHardFailTest, FailsOnOCSPInvalid) { 5656 if (!SystemSupportsOCSP()) { 5657 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5658 return; 5659 } 5660 5661 if (!SystemSupportsHardFailRevocationChecking()) { 5662 LOG(WARNING) << "Skipping test because system doesn't support hard fail " 5663 << "revocation checking"; 5664 return; 5665 } 5666 5667 SpawnedTestServer::SSLOptions ssl_options( 5668 SpawnedTestServer::SSLOptions::CERT_AUTO); 5669 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5670 5671 CertStatus cert_status; 5672 DoConnection(ssl_options, &cert_status); 5673 5674 EXPECT_EQ(CERT_STATUS_REVOKED, 5675 cert_status & CERT_STATUS_REVOKED); 5676 5677 // Without a positive OCSP response, we shouldn't show the EV status. 5678 EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED); 5679 } 5680 5681 class HTTPSEVCRLSetTest : public HTTPSOCSPTest { 5682 protected: 5683 virtual void SetupContext(URLRequestContext* context) OVERRIDE { 5684 context->set_ssl_config_service( 5685 new TestSSLConfigService(true /* check for EV */, 5686 false /* online revocation checking */, 5687 false /* require rev. checking for local 5688 anchors */)); 5689 } 5690 }; 5691 5692 TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndInvalidOCSP) { 5693 if (!SystemSupportsOCSP()) { 5694 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5695 return; 5696 } 5697 5698 SpawnedTestServer::SSLOptions ssl_options( 5699 SpawnedTestServer::SSLOptions::CERT_AUTO); 5700 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5701 SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>()); 5702 5703 CertStatus cert_status; 5704 DoConnection(ssl_options, &cert_status); 5705 5706 EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(), 5707 cert_status & CERT_STATUS_ALL_ERRORS); 5708 5709 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5710 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5711 static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED)); 5712 } 5713 5714 TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndGoodOCSP) { 5715 if (!SystemSupportsOCSP()) { 5716 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5717 return; 5718 } 5719 5720 SpawnedTestServer::SSLOptions ssl_options( 5721 SpawnedTestServer::SSLOptions::CERT_AUTO); 5722 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK; 5723 SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>()); 5724 5725 CertStatus cert_status; 5726 DoConnection(ssl_options, &cert_status); 5727 5728 EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS); 5729 5730 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5731 static_cast<bool>(cert_status & CERT_STATUS_IS_EV)); 5732 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5733 static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED)); 5734 } 5735 5736 TEST_F(HTTPSEVCRLSetTest, ExpiredCRLSet) { 5737 if (!SystemSupportsOCSP()) { 5738 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5739 return; 5740 } 5741 5742 SpawnedTestServer::SSLOptions ssl_options( 5743 SpawnedTestServer::SSLOptions::CERT_AUTO); 5744 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5745 SSLConfigService::SetCRLSet( 5746 scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting())); 5747 5748 CertStatus cert_status; 5749 DoConnection(ssl_options, &cert_status); 5750 5751 EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(), 5752 cert_status & CERT_STATUS_ALL_ERRORS); 5753 5754 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5755 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5756 static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED)); 5757 } 5758 5759 TEST_F(HTTPSEVCRLSetTest, FreshCRLSetCovered) { 5760 if (!SystemSupportsOCSP()) { 5761 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5762 return; 5763 } 5764 5765 SpawnedTestServer::SSLOptions ssl_options( 5766 SpawnedTestServer::SSLOptions::CERT_AUTO); 5767 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5768 SSLConfigService::SetCRLSet( 5769 scoped_refptr<CRLSet>(CRLSet::ForTesting( 5770 false, &kOCSPTestCertSPKI, ""))); 5771 5772 CertStatus cert_status; 5773 DoConnection(ssl_options, &cert_status); 5774 5775 // With a fresh CRLSet that covers the issuing certificate, we shouldn't do a 5776 // revocation check for EV. 5777 EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS); 5778 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5779 static_cast<bool>(cert_status & CERT_STATUS_IS_EV)); 5780 EXPECT_FALSE( 5781 static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED)); 5782 } 5783 5784 TEST_F(HTTPSEVCRLSetTest, FreshCRLSetNotCovered) { 5785 if (!SystemSupportsOCSP()) { 5786 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5787 return; 5788 } 5789 5790 SpawnedTestServer::SSLOptions ssl_options( 5791 SpawnedTestServer::SSLOptions::CERT_AUTO); 5792 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5793 SSLConfigService::SetCRLSet( 5794 scoped_refptr<CRLSet>(CRLSet::EmptyCRLSetForTesting())); 5795 5796 CertStatus cert_status = 0; 5797 DoConnection(ssl_options, &cert_status); 5798 5799 // Even with a fresh CRLSet, we should still do online revocation checks when 5800 // the certificate chain isn't covered by the CRLSet, which it isn't in this 5801 // test. 5802 EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(), 5803 cert_status & CERT_STATUS_ALL_ERRORS); 5804 5805 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5806 EXPECT_EQ(SystemUsesChromiumEVMetadata(), 5807 static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED)); 5808 } 5809 5810 TEST_F(HTTPSEVCRLSetTest, ExpiredCRLSetAndRevokedNonEVCert) { 5811 // Test that when EV verification is requested, but online revocation 5812 // checking is disabled, and the leaf certificate is not in fact EV, that 5813 // no revocation checking actually happens. 5814 if (!SystemSupportsOCSP()) { 5815 LOG(WARNING) << "Skipping test because system doesn't support OCSP"; 5816 return; 5817 } 5818 5819 // Unmark the certificate's OID as EV, which should disable revocation 5820 // checking (as per the user preference) 5821 ev_test_policy_.reset(); 5822 5823 SpawnedTestServer::SSLOptions ssl_options( 5824 SpawnedTestServer::SSLOptions::CERT_AUTO); 5825 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED; 5826 SSLConfigService::SetCRLSet( 5827 scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting())); 5828 5829 CertStatus cert_status; 5830 DoConnection(ssl_options, &cert_status); 5831 5832 EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS); 5833 5834 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5835 EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED); 5836 } 5837 5838 class HTTPSCRLSetTest : public HTTPSOCSPTest { 5839 protected: 5840 virtual void SetupContext(URLRequestContext* context) OVERRIDE { 5841 context->set_ssl_config_service( 5842 new TestSSLConfigService(false /* check for EV */, 5843 false /* online revocation checking */, 5844 false /* require rev. checking for local 5845 anchors */)); 5846 } 5847 }; 5848 5849 TEST_F(HTTPSCRLSetTest, ExpiredCRLSet) { 5850 SpawnedTestServer::SSLOptions ssl_options( 5851 SpawnedTestServer::SSLOptions::CERT_AUTO); 5852 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID; 5853 SSLConfigService::SetCRLSet( 5854 scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting())); 5855 5856 CertStatus cert_status; 5857 DoConnection(ssl_options, &cert_status); 5858 5859 // If we're not trying EV verification then, even if the CRLSet has expired, 5860 // we don't fall back to online revocation checks. 5861 EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS); 5862 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5863 EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED); 5864 } 5865 5866 TEST_F(HTTPSCRLSetTest, CRLSetRevoked) { 5867 #if defined(USE_OPENSSL) 5868 LOG(WARNING) << "Skipping test because system doesn't support CRLSets"; 5869 return; 5870 #endif 5871 5872 SpawnedTestServer::SSLOptions ssl_options( 5873 SpawnedTestServer::SSLOptions::CERT_AUTO); 5874 ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK; 5875 ssl_options.cert_serial = 10; 5876 SSLConfigService::SetCRLSet( 5877 scoped_refptr<CRLSet>(CRLSet::ForTesting( 5878 false, &kOCSPTestCertSPKI, "\x0a"))); 5879 5880 CertStatus cert_status = 0; 5881 DoConnection(ssl_options, &cert_status); 5882 5883 // If the certificate is recorded as revoked in the CRLSet, that should be 5884 // reflected without online revocation checking. 5885 EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS); 5886 EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV); 5887 EXPECT_FALSE( 5888 static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED)); 5889 } 5890 #endif // !defined(OS_IOS) 5891 5892 #if !defined(DISABLE_FTP_SUPPORT) 5893 class URLRequestTestFTP : public URLRequestTest { 5894 public: 5895 URLRequestTestFTP() 5896 : test_server_(SpawnedTestServer::TYPE_FTP, SpawnedTestServer::kLocalhost, 5897 base::FilePath()) { 5898 } 5899 5900 protected: 5901 SpawnedTestServer test_server_; 5902 }; 5903 5904 // Make sure an FTP request using an unsafe ports fails. 5905 TEST_F(URLRequestTestFTP, UnsafePort) { 5906 ASSERT_TRUE(test_server_.Start()); 5907 5908 URLRequestJobFactoryImpl job_factory; 5909 FtpNetworkLayer ftp_transaction_factory(default_context_.host_resolver()); 5910 5911 GURL url("ftp://127.0.0.1:7"); 5912 job_factory.SetProtocolHandler( 5913 "ftp", 5914 new FtpProtocolHandler(&ftp_transaction_factory)); 5915 default_context_.set_job_factory(&job_factory); 5916 5917 TestDelegate d; 5918 { 5919 URLRequest r(url, &d, &default_context_); 5920 r.Start(); 5921 EXPECT_TRUE(r.is_pending()); 5922 5923 base::MessageLoop::current()->Run(); 5924 5925 EXPECT_FALSE(r.is_pending()); 5926 EXPECT_EQ(URLRequestStatus::FAILED, r.status().status()); 5927 EXPECT_EQ(ERR_UNSAFE_PORT, r.status().error()); 5928 } 5929 } 5930 5931 // Flaky, see http://crbug.com/25045. 5932 TEST_F(URLRequestTestFTP, DISABLED_FTPDirectoryListing) { 5933 ASSERT_TRUE(test_server_.Start()); 5934 5935 TestDelegate d; 5936 { 5937 URLRequest r(test_server_.GetURL("/"), &d, &default_context_); 5938 r.Start(); 5939 EXPECT_TRUE(r.is_pending()); 5940 5941 base::MessageLoop::current()->Run(); 5942 5943 EXPECT_FALSE(r.is_pending()); 5944 EXPECT_EQ(1, d.response_started_count()); 5945 EXPECT_FALSE(d.received_data_before_response()); 5946 EXPECT_LT(0, d.bytes_received()); 5947 EXPECT_EQ(test_server_.host_port_pair().host(), 5948 r.GetSocketAddress().host()); 5949 EXPECT_EQ(test_server_.host_port_pair().port(), 5950 r.GetSocketAddress().port()); 5951 } 5952 } 5953 5954 // Flaky, see http://crbug.com/25045. 5955 TEST_F(URLRequestTestFTP, DISABLED_FTPGetTestAnonymous) { 5956 ASSERT_TRUE(test_server_.Start()); 5957 5958 base::FilePath app_path; 5959 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 5960 app_path = app_path.AppendASCII("LICENSE"); 5961 TestDelegate d; 5962 { 5963 URLRequest r(test_server_.GetURL("/LICENSE"), &d, &default_context_); 5964 r.Start(); 5965 EXPECT_TRUE(r.is_pending()); 5966 5967 base::MessageLoop::current()->Run(); 5968 5969 int64 file_size = 0; 5970 file_util::GetFileSize(app_path, &file_size); 5971 5972 EXPECT_FALSE(r.is_pending()); 5973 EXPECT_EQ(1, d.response_started_count()); 5974 EXPECT_FALSE(d.received_data_before_response()); 5975 EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size)); 5976 EXPECT_EQ(test_server_.host_port_pair().host(), 5977 r.GetSocketAddress().host()); 5978 EXPECT_EQ(test_server_.host_port_pair().port(), 5979 r.GetSocketAddress().port()); 5980 } 5981 } 5982 5983 // Flaky, see http://crbug.com/25045. 5984 TEST_F(URLRequestTestFTP, DISABLED_FTPGetTest) { 5985 ASSERT_TRUE(test_server_.Start()); 5986 5987 base::FilePath app_path; 5988 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 5989 app_path = app_path.AppendASCII("LICENSE"); 5990 TestDelegate d; 5991 { 5992 URLRequest r( 5993 test_server_.GetURLWithUserAndPassword("/LICENSE", "chrome", "chrome"), 5994 &d, 5995 &default_context_); 5996 r.Start(); 5997 EXPECT_TRUE(r.is_pending()); 5998 5999 base::MessageLoop::current()->Run(); 6000 6001 int64 file_size = 0; 6002 file_util::GetFileSize(app_path, &file_size); 6003 6004 EXPECT_FALSE(r.is_pending()); 6005 EXPECT_EQ(test_server_.host_port_pair().host(), 6006 r.GetSocketAddress().host()); 6007 EXPECT_EQ(test_server_.host_port_pair().port(), 6008 r.GetSocketAddress().port()); 6009 EXPECT_EQ(1, d.response_started_count()); 6010 EXPECT_FALSE(d.received_data_before_response()); 6011 EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size)); 6012 6013 LoadTimingInfo load_timing_info; 6014 r.GetLoadTimingInfo(&load_timing_info); 6015 TestLoadTimingNoHttpResponse(load_timing_info); 6016 } 6017 } 6018 6019 // Flaky, see http://crbug.com/25045. 6020 TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPassword) { 6021 ASSERT_TRUE(test_server_.Start()); 6022 6023 base::FilePath app_path; 6024 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 6025 app_path = app_path.AppendASCII("LICENSE"); 6026 TestDelegate d; 6027 { 6028 URLRequest r( 6029 test_server_.GetURLWithUserAndPassword("/LICENSE", 6030 "chrome", 6031 "wrong_password"), 6032 &d, 6033 &default_context_); 6034 r.Start(); 6035 EXPECT_TRUE(r.is_pending()); 6036 6037 base::MessageLoop::current()->Run(); 6038 6039 int64 file_size = 0; 6040 file_util::GetFileSize(app_path, &file_size); 6041 6042 EXPECT_FALSE(r.is_pending()); 6043 EXPECT_EQ(1, d.response_started_count()); 6044 EXPECT_FALSE(d.received_data_before_response()); 6045 EXPECT_EQ(d.bytes_received(), 0); 6046 } 6047 } 6048 6049 // Flaky, see http://crbug.com/25045. 6050 TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongPasswordRestart) { 6051 ASSERT_TRUE(test_server_.Start()); 6052 6053 base::FilePath app_path; 6054 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 6055 app_path = app_path.AppendASCII("LICENSE"); 6056 TestDelegate d; 6057 // Set correct login credentials. The delegate will be asked for them when 6058 // the initial login with wrong credentials will fail. 6059 d.set_credentials(AuthCredentials(kChrome, kChrome)); 6060 { 6061 URLRequest r( 6062 test_server_.GetURLWithUserAndPassword("/LICENSE", 6063 "chrome", 6064 "wrong_password"), 6065 &d, 6066 &default_context_); 6067 r.Start(); 6068 EXPECT_TRUE(r.is_pending()); 6069 6070 base::MessageLoop::current()->Run(); 6071 6072 int64 file_size = 0; 6073 file_util::GetFileSize(app_path, &file_size); 6074 6075 EXPECT_FALSE(r.is_pending()); 6076 EXPECT_EQ(1, d.response_started_count()); 6077 EXPECT_FALSE(d.received_data_before_response()); 6078 EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size)); 6079 } 6080 } 6081 6082 // Flaky, see http://crbug.com/25045. 6083 TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongUser) { 6084 ASSERT_TRUE(test_server_.Start()); 6085 6086 base::FilePath app_path; 6087 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 6088 app_path = app_path.AppendASCII("LICENSE"); 6089 TestDelegate d; 6090 { 6091 URLRequest r( 6092 test_server_.GetURLWithUserAndPassword("/LICENSE", 6093 "wrong_user", 6094 "chrome"), 6095 &d, 6096 &default_context_); 6097 r.Start(); 6098 EXPECT_TRUE(r.is_pending()); 6099 6100 base::MessageLoop::current()->Run(); 6101 6102 int64 file_size = 0; 6103 file_util::GetFileSize(app_path, &file_size); 6104 6105 EXPECT_FALSE(r.is_pending()); 6106 EXPECT_EQ(1, d.response_started_count()); 6107 EXPECT_FALSE(d.received_data_before_response()); 6108 EXPECT_EQ(d.bytes_received(), 0); 6109 } 6110 } 6111 6112 // Flaky, see http://crbug.com/25045. 6113 TEST_F(URLRequestTestFTP, DISABLED_FTPCheckWrongUserRestart) { 6114 ASSERT_TRUE(test_server_.Start()); 6115 6116 base::FilePath app_path; 6117 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 6118 app_path = app_path.AppendASCII("LICENSE"); 6119 TestDelegate d; 6120 // Set correct login credentials. The delegate will be asked for them when 6121 // the initial login with wrong credentials will fail. 6122 d.set_credentials(AuthCredentials(kChrome, kChrome)); 6123 { 6124 URLRequest r( 6125 test_server_.GetURLWithUserAndPassword("/LICENSE", 6126 "wrong_user", 6127 "chrome"), 6128 &d, 6129 &default_context_); 6130 r.Start(); 6131 EXPECT_TRUE(r.is_pending()); 6132 6133 base::MessageLoop::current()->Run(); 6134 6135 int64 file_size = 0; 6136 file_util::GetFileSize(app_path, &file_size); 6137 6138 EXPECT_FALSE(r.is_pending()); 6139 EXPECT_EQ(1, d.response_started_count()); 6140 EXPECT_FALSE(d.received_data_before_response()); 6141 EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size)); 6142 } 6143 } 6144 6145 // Flaky, see http://crbug.com/25045. 6146 TEST_F(URLRequestTestFTP, DISABLED_FTPCacheURLCredentials) { 6147 ASSERT_TRUE(test_server_.Start()); 6148 6149 base::FilePath app_path; 6150 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 6151 app_path = app_path.AppendASCII("LICENSE"); 6152 6153 scoped_ptr<TestDelegate> d(new TestDelegate); 6154 { 6155 // Pass correct login identity in the URL. 6156 URLRequest r( 6157 test_server_.GetURLWithUserAndPassword("/LICENSE", 6158 "chrome", 6159 "chrome"), 6160 d.get(), 6161 &default_context_); 6162 r.Start(); 6163 EXPECT_TRUE(r.is_pending()); 6164 6165 base::MessageLoop::current()->Run(); 6166 6167 int64 file_size = 0; 6168 file_util::GetFileSize(app_path, &file_size); 6169 6170 EXPECT_FALSE(r.is_pending()); 6171 EXPECT_EQ(1, d->response_started_count()); 6172 EXPECT_FALSE(d->received_data_before_response()); 6173 EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size)); 6174 } 6175 6176 d.reset(new TestDelegate); 6177 { 6178 // This request should use cached identity from previous request. 6179 URLRequest r(test_server_.GetURL("/LICENSE"), d.get(), &default_context_); 6180 r.Start(); 6181 EXPECT_TRUE(r.is_pending()); 6182 6183 base::MessageLoop::current()->Run(); 6184 6185 int64 file_size = 0; 6186 file_util::GetFileSize(app_path, &file_size); 6187 6188 EXPECT_FALSE(r.is_pending()); 6189 EXPECT_EQ(1, d->response_started_count()); 6190 EXPECT_FALSE(d->received_data_before_response()); 6191 EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size)); 6192 } 6193 } 6194 6195 // Flaky, see http://crbug.com/25045. 6196 TEST_F(URLRequestTestFTP, DISABLED_FTPCacheLoginBoxCredentials) { 6197 ASSERT_TRUE(test_server_.Start()); 6198 6199 base::FilePath app_path; 6200 PathService::Get(base::DIR_SOURCE_ROOT, &app_path); 6201 app_path = app_path.AppendASCII("LICENSE"); 6202 6203 scoped_ptr<TestDelegate> d(new TestDelegate); 6204 // Set correct login credentials. The delegate will be asked for them when 6205 // the initial login with wrong credentials will fail. 6206 d->set_credentials(AuthCredentials(kChrome, kChrome)); 6207 { 6208 URLRequest r( 6209 test_server_.GetURLWithUserAndPassword("/LICENSE", 6210 "chrome", 6211 "wrong_password"), 6212 d.get(), 6213 &default_context_); 6214 r.Start(); 6215 EXPECT_TRUE(r.is_pending()); 6216 6217 base::MessageLoop::current()->Run(); 6218 6219 int64 file_size = 0; 6220 file_util::GetFileSize(app_path, &file_size); 6221 6222 EXPECT_FALSE(r.is_pending()); 6223 EXPECT_EQ(1, d->response_started_count()); 6224 EXPECT_FALSE(d->received_data_before_response()); 6225 EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size)); 6226 } 6227 6228 // Use a new delegate without explicit credentials. The cached ones should be 6229 // used. 6230 d.reset(new TestDelegate); 6231 { 6232 // Don't pass wrong credentials in the URL, they would override valid cached 6233 // ones. 6234 URLRequest r(test_server_.GetURL("/LICENSE"), d.get(), &default_context_); 6235 r.Start(); 6236 EXPECT_TRUE(r.is_pending()); 6237 6238 base::MessageLoop::current()->Run(); 6239 6240 int64 file_size = 0; 6241 file_util::GetFileSize(app_path, &file_size); 6242 6243 EXPECT_FALSE(r.is_pending()); 6244 EXPECT_EQ(1, d->response_started_count()); 6245 EXPECT_FALSE(d->received_data_before_response()); 6246 EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size)); 6247 } 6248 } 6249 #endif // !defined(DISABLE_FTP_SUPPORT) 6250 6251 } // namespace net 6252