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