net/url_request/url_request_unittest.cc

   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 <stdint.h>
  13
  14 #include <algorithm>
  15
  16 #include "base/basictypes.h"
  17 #include "base/bind.h"
  18 #include "base/compiler_specific.h"
  19 #include "base/files/file_path.h"
  20 #include "base/files/file_util.h"
  21 #include "base/files/scoped_temp_dir.h"
  22 #include "base/format_macros.h"
  23 #include "base/json/json_reader.h"
  24 #include "base/location.h"
  25 #include "base/memory/scoped_ptr.h"
  26 #include "base/memory/weak_ptr.h"
  27 #include "base/message_loop/message_loop.h"
  28 #include "base/path_service.h"
  29 #include "base/run_loop.h"
  30 #include "base/single_thread_task_runner.h"
  31 #include "base/strings/string_number_conversions.h"
  32 #include "base/strings/string_piece.h"
  33 #include "base/strings/string_split.h"
  34 #include "base/strings/string_util.h"
  35 #include "base/strings/stringprintf.h"
  36 #include "base/strings/utf_string_conversions.h"
  37 #include "base/test/histogram_tester.h"
  38 #include "base/thread_task_runner_handle.h"
  39 #include "base/values.h"
  40 #include "net/base/chunked_upload_data_stream.h"
  41 #include "net/base/elements_upload_data_stream.h"
  42 #include "net/base/external_estimate_provider.h"
  43 #include "net/base/load_flags.h"
  44 #include "net/base/load_timing_info.h"
  45 #include "net/base/load_timing_info_test_util.h"
  46 #include "net/base/net_errors.h"
  47 #include "net/base/net_module.h"
  48 #include "net/base/net_util.h"
  49 #include "net/base/network_quality_estimator.h"
  50 #include "net/base/request_priority.h"
  51 #include "net/base/test_data_directory.h"
  52 #include "net/base/upload_bytes_element_reader.h"
  53 #include "net/base/upload_data_stream.h"
  54 #include "net/base/upload_file_element_reader.h"
  55 #include "net/cert/ev_root_ca_metadata.h"
  56 #include "net/cert/mock_cert_verifier.h"
  57 #include "net/cert/test_root_certs.h"
  58 #include "net/cert_net/nss_ocsp.h"
  59 #include "net/cookies/cookie_monster.h"
  60 #include "net/cookies/cookie_store_test_helpers.h"
  61 #include "net/disk_cache/disk_cache.h"
  62 #include "net/dns/mock_host_resolver.h"
  63 #include "net/http/http_byte_range.h"
  64 #include "net/http/http_cache.h"
  65 #include "net/http/http_network_layer.h"
  66 #include "net/http/http_network_session.h"
  67 #include "net/http/http_request_headers.h"
  68 #include "net/http/http_response_headers.h"
  69 #include "net/http/http_util.h"
  70 #include "net/log/net_log.h"
  71 #include "net/log/test_net_log.h"
  72 #include "net/log/test_net_log_entry.h"
  73 #include "net/log/test_net_log_util.h"
  74 #include "net/proxy/proxy_service.h"
  75 #include "net/socket/ssl_client_socket.h"
  76 #include "net/ssl/ssl_cipher_suite_names.h"
  77 #include "net/ssl/ssl_connection_status_flags.h"
  78 #include "net/test/cert_test_util.h"
  79 #include "net/test/spawned_test_server/spawned_test_server.h"
  80 #include "net/url_request/data_protocol_handler.h"
  81 #include "net/url_request/static_http_user_agent_settings.h"
  82 #include "net/url_request/url_request.h"
  83 #include "net/url_request/url_request_http_job.h"
  84 #include "net/url_request/url_request_intercepting_job_factory.h"
  85 #include "net/url_request/url_request_interceptor.h"
  86 #include "net/url_request/url_request_job_factory_impl.h"
  87 #include "net/url_request/url_request_redirect_job.h"
  88 #include "net/url_request/url_request_test_job.h"
  89 #include "net/url_request/url_request_test_util.h"
  90 #include "testing/gtest/include/gtest/gtest.h"
  91 #include "testing/platform_test.h"
  92
  93 #if !defined(DISABLE_FILE_SUPPORT)
  94 #include "net/base/filename_util.h"
  95 #include "net/url_request/file_protocol_handler.h"
  96 #include "net/url_request/url_request_file_dir_job.h"
  97 #endif
  98
  99 #if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
 100 #include "net/ftp/ftp_network_layer.h"
 101 #include "net/url_request/ftp_protocol_handler.h"
 102 #endif
 103
 104 #if defined(OS_WIN)
 105 #include "base/win/scoped_com_initializer.h"
 106 #include "base/win/scoped_comptr.h"
 107 #include "base/win/windows_version.h"
 108 #endif
 109
 110 using base::ASCIIToUTF16;
 111 using base::Time;
 112 using std::string;
 113
 114 namespace net {
 115
 116 namespace {
 117
 118 const base::string16 kChrome(ASCIIToUTF16("chrome"));
 119 const base::string16 kSecret(ASCIIToUTF16("secret"));
 120 const base::string16 kUser(ASCIIToUTF16("user"));
 121
 122 const base::FilePath::CharType kTestFilePath[] =
 123     FILE_PATH_LITERAL("net/data/url_request_unittest");
 124
 125 #if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
 126 // Test file used in most FTP tests.
 127 const char kFtpTestFile[] = "BullRunSpeech.txt";
 128 #endif
 129
 130 // Tests load timing information in the case a fresh connection was used, with
 131 // no proxy.
 132 void TestLoadTimingNotReused(const LoadTimingInfo& load_timing_info,
 133                              int connect_timing_flags) {
 134   EXPECT_FALSE(load_timing_info.socket_reused);
 135   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 136
 137   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
 138   EXPECT_FALSE(load_timing_info.request_start.is_null());
 139
 140   EXPECT_LE(load_timing_info.request_start,
 141             load_timing_info.connect_timing.connect_start);
 142   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
 143                               connect_timing_flags);
 144   EXPECT_LE(load_timing_info.connect_timing.connect_end,
 145             load_timing_info.send_start);
 146   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
 147   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 148
 149   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
 150   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 151 }
 152
 153 // Same as above, but with proxy times.
 154 void TestLoadTimingNotReusedWithProxy(
 155     const LoadTimingInfo& load_timing_info,
 156     int connect_timing_flags) {
 157   EXPECT_FALSE(load_timing_info.socket_reused);
 158   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 159
 160   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
 161   EXPECT_FALSE(load_timing_info.request_start.is_null());
 162
 163   EXPECT_LE(load_timing_info.request_start,
 164             load_timing_info.proxy_resolve_start);
 165   EXPECT_LE(load_timing_info.proxy_resolve_start,
 166             load_timing_info.proxy_resolve_end);
 167   EXPECT_LE(load_timing_info.proxy_resolve_end,
 168             load_timing_info.connect_timing.connect_start);
 169   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
 170                               connect_timing_flags);
 171   EXPECT_LE(load_timing_info.connect_timing.connect_end,
 172             load_timing_info.send_start);
 173   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
 174   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 175 }
 176
 177 // Same as above, but with a reused socket and proxy times.
 178 void TestLoadTimingReusedWithProxy(
 179     const LoadTimingInfo& load_timing_info) {
 180   EXPECT_TRUE(load_timing_info.socket_reused);
 181   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 182
 183   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
 184   EXPECT_FALSE(load_timing_info.request_start.is_null());
 185
 186   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 187
 188   EXPECT_LE(load_timing_info.request_start,
 189             load_timing_info.proxy_resolve_start);
 190   EXPECT_LE(load_timing_info.proxy_resolve_start,
 191             load_timing_info.proxy_resolve_end);
 192   EXPECT_LE(load_timing_info.proxy_resolve_end,
 193             load_timing_info.send_start);
 194   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
 195   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 196 }
 197
 198 #if !defined(DISABLE_FILE_SUPPORT)
 199 // Tests load timing information in the case of a cache hit, when no cache
 200 // validation request was sent over the wire.
 201 base::StringPiece TestNetResourceProvider(int key) {
 202   return "header";
 203 }
 204
 205 void FillBuffer(char* buffer, size_t len) {
 206   static bool called = false;
 207   if (!called) {
 208     called = true;
 209     int seed = static_cast<int>(Time::Now().ToInternalValue());
 210     srand(seed);
 211   }
 212
 213   for (size_t i = 0; i < len; i++) {
 214     buffer[i] = static_cast<char>(rand());
 215     if (!buffer[i])
 216       buffer[i] = 'g';
 217   }
 218 }
 219 #endif
 220
 221 #if !defined(OS_IOS)
 222 void TestLoadTimingCacheHitNoNetwork(
 223     const LoadTimingInfo& load_timing_info) {
 224   EXPECT_FALSE(load_timing_info.socket_reused);
 225   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 226
 227   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
 228   EXPECT_FALSE(load_timing_info.request_start.is_null());
 229
 230   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 231   EXPECT_LE(load_timing_info.request_start, load_timing_info.send_start);
 232   EXPECT_LE(load_timing_info.send_start, load_timing_info.send_end);
 233   EXPECT_LE(load_timing_info.send_end, load_timing_info.receive_headers_end);
 234
 235   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
 236   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 237 }
 238
 239 #if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
 240 // Tests load timing in the case that there is no HTTP response.  This can be
 241 // used to test in the case of errors or non-HTTP requests.
 242 void TestLoadTimingNoHttpResponse(
 243     const LoadTimingInfo& load_timing_info) {
 244   EXPECT_FALSE(load_timing_info.socket_reused);
 245   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
 246
 247   // Only the request times should be non-null.
 248   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
 249   EXPECT_FALSE(load_timing_info.request_start.is_null());
 250
 251   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
 252
 253   EXPECT_TRUE(load_timing_info.proxy_resolve_start.is_null());
 254   EXPECT_TRUE(load_timing_info.proxy_resolve_end.is_null());
 255   EXPECT_TRUE(load_timing_info.send_start.is_null());
 256   EXPECT_TRUE(load_timing_info.send_end.is_null());
 257   EXPECT_TRUE(load_timing_info.receive_headers_end.is_null());
 258 }
 259 #endif
 260
 261 // Do a case-insensitive search through |haystack| for |needle|.
 262 bool ContainsString(const std::string& haystack, const char* needle) {
 263   std::string::const_iterator it = std::search(
 264       haystack.begin(), haystack.end(), needle, needle + strlen(needle),
 265       base::CaseInsensitiveCompareASCII<char>());
 266   return it != haystack.end();
 267 }
 268
 269 scoped_ptr<UploadDataStream> CreateSimpleUploadData(const char* data) {
 270   scoped_ptr<UploadElementReader> reader(
 271       new UploadBytesElementReader(data, strlen(data)));
 272   return ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0);
 273 }
 274
 275 // Verify that the SSLInfo of a successful SSL connection has valid values.
 276 void CheckSSLInfo(const SSLInfo& ssl_info) {
 277   // -1 means unknown.  0 means no encryption.
 278   EXPECT_GT(ssl_info.security_bits, 0);
 279
 280   // The cipher suite TLS_NULL_WITH_NULL_NULL (0) must not be negotiated.
 281   uint16 cipher_suite = SSLConnectionStatusToCipherSuite(
 282       ssl_info.connection_status);
 283   EXPECT_NE(0U, cipher_suite);
 284 }
 285
 286 void CheckFullRequestHeaders(const HttpRequestHeaders& headers,
 287                              const GURL& host_url) {
 288   std::string sent_value;
 289
 290   EXPECT_TRUE(headers.GetHeader("Host", &sent_value));
 291   EXPECT_EQ(GetHostAndOptionalPort(host_url), sent_value);
 292
 293   EXPECT_TRUE(headers.GetHeader("Connection", &sent_value));
 294   EXPECT_EQ("keep-alive", sent_value);
 295 }
 296
 297 bool FingerprintsEqual(const HashValueVector& a, const HashValueVector& b) {
 298   size_t size = a.size();
 299
 300   if (size != b.size())
 301     return false;
 302
 303   for (size_t i = 0; i < size; ++i) {
 304     if (!a[i].Equals(b[i]))
 305       return false;
 306   }
 307
 308   return true;
 309 }
 310 #endif  // !defined(OS_IOS)
 311
 312 // A network delegate that allows the user to choose a subset of request stages
 313 // to block in. When blocking, the delegate can do one of the following:
 314 //  * synchronously return a pre-specified error code, or
 315 //  * asynchronously return that value via an automatically called callback,
 316 //    or
 317 //  * block and wait for the user to do a callback.
 318 // Additionally, the user may also specify a redirect URL -- then each request
 319 // with the current URL different from the redirect target will be redirected
 320 // to that target, in the on-before-URL-request stage, independent of whether
 321 // the delegate blocks in ON_BEFORE_URL_REQUEST or not.
 322 class BlockingNetworkDelegate : public TestNetworkDelegate {
 323  public:
 324   // Stages in which the delegate can block.
 325   enum Stage {
 326     NOT_BLOCKED = 0,
 327     ON_BEFORE_URL_REQUEST = 1 << 0,
 328     ON_BEFORE_SEND_HEADERS = 1 << 1,
 329     ON_HEADERS_RECEIVED = 1 << 2,
 330     ON_AUTH_REQUIRED = 1 << 3
 331   };
 332
 333   // Behavior during blocked stages.  During other stages, just
 334   // returns OK or NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION.
 335   enum BlockMode {
 336     SYNCHRONOUS,    // No callback, returns specified return values.
 337     AUTO_CALLBACK,  // |this| posts a task to run the callback using the
 338                     // specified return codes.
 339     USER_CALLBACK,  // User takes care of doing a callback.  |retval_| and
 340                     // |auth_retval_| are ignored. In every blocking stage the
 341                     // message loop is quit.
 342   };
 343
 344   // Creates a delegate which does not block at all.
 345   explicit BlockingNetworkDelegate(BlockMode block_mode);
 346
 347   // For users to trigger a callback returning |response|.
 348   // Side-effects: resets |stage_blocked_for_callback_| and stored callbacks.
 349   // Only call if |block_mode_| == USER_CALLBACK.
 350   void DoCallback(int response);
 351   void DoAuthCallback(NetworkDelegate::AuthRequiredResponse response);
 352
 353   // Setters.
 354   void set_retval(int retval) {
 355     ASSERT_NE(USER_CALLBACK, block_mode_);
 356     ASSERT_NE(ERR_IO_PENDING, retval);
 357     ASSERT_NE(OK, retval);
 358     retval_ = retval;
 359   }
 360
 361   // If |auth_retval| == AUTH_REQUIRED_RESPONSE_SET_AUTH, then
 362   // |auth_credentials_| will be passed with the response.
 363   void set_auth_retval(AuthRequiredResponse auth_retval) {
 364     ASSERT_NE(USER_CALLBACK, block_mode_);
 365     ASSERT_NE(AUTH_REQUIRED_RESPONSE_IO_PENDING, auth_retval);
 366     auth_retval_ = auth_retval;
 367   }
 368   void set_auth_credentials(const AuthCredentials& auth_credentials) {
 369     auth_credentials_ = auth_credentials;
 370   }
 371
 372   void set_redirect_url(const GURL& url) {
 373     redirect_url_ = url;
 374   }
 375
 376   void set_block_on(int block_on) {
 377     block_on_ = block_on;
 378   }
 379
 380   // Allows the user to check in which state did we block.
 381   Stage stage_blocked_for_callback() const {
 382     EXPECT_EQ(USER_CALLBACK, block_mode_);
 383     return stage_blocked_for_callback_;
 384   }
 385
 386  private:
 387   void RunCallback(int response, const CompletionCallback& callback);
 388   void RunAuthCallback(AuthRequiredResponse response,
 389                        const AuthCallback& callback);
 390
 391   // TestNetworkDelegate implementation.
 392   int OnBeforeURLRequest(URLRequest* request,
 393                          const CompletionCallback& callback,
 394                          GURL* new_url) override;
 395
 396   int OnBeforeSendHeaders(URLRequest* request,
 397                           const CompletionCallback& callback,
 398                           HttpRequestHeaders* headers) override;
 399
 400   int OnHeadersReceived(
 401       URLRequest* request,
 402       const CompletionCallback& callback,
 403       const HttpResponseHeaders* original_response_headers,
 404       scoped_refptr<HttpResponseHeaders>* override_response_headers,
 405       GURL* allowed_unsafe_redirect_url) override;
 406
 407   NetworkDelegate::AuthRequiredResponse OnAuthRequired(
 408       URLRequest* request,
 409       const AuthChallengeInfo& auth_info,
 410       const AuthCallback& callback,
 411       AuthCredentials* credentials) override;
 412
 413   // Resets the callbacks and |stage_blocked_for_callback_|.
 414   void Reset();
 415
 416   // Checks whether we should block in |stage|. If yes, returns an error code
 417   // and optionally sets up callback based on |block_mode_|. If no, returns OK.
 418   int MaybeBlockStage(Stage stage, const CompletionCallback& callback);
 419
 420   // Configuration parameters, can be adjusted by public methods:
 421   const BlockMode block_mode_;
 422
 423   // Values returned on blocking stages when mode is SYNCHRONOUS or
 424   // AUTO_CALLBACK. For USER_CALLBACK these are set automatically to IO_PENDING.
 425   int retval_;  // To be returned in non-auth stages.
 426   AuthRequiredResponse auth_retval_;
 427
 428   GURL redirect_url_;  // Used if non-empty during OnBeforeURLRequest.
 429   int block_on_;  // Bit mask: in which stages to block.
 430
 431   // |auth_credentials_| will be copied to |*target_auth_credential_| on
 432   // callback.
 433   AuthCredentials auth_credentials_;
 434   AuthCredentials* target_auth_credentials_;
 435
 436   // Internal variables, not set by not the user:
 437   // Last blocked stage waiting for user callback (unused if |block_mode_| !=
 438   // USER_CALLBACK).
 439   Stage stage_blocked_for_callback_;
 440
 441   // Callback objects stored during blocking stages.
 442   CompletionCallback callback_;
 443   AuthCallback auth_callback_;
 444
 445   base::WeakPtrFactory<BlockingNetworkDelegate> weak_factory_;
 446
 447   DISALLOW_COPY_AND_ASSIGN(BlockingNetworkDelegate);
 448 };
 449
 450 BlockingNetworkDelegate::BlockingNetworkDelegate(BlockMode block_mode)
 451     : block_mode_(block_mode),
 452       retval_(OK),
 453       auth_retval_(AUTH_REQUIRED_RESPONSE_NO_ACTION),
 454       block_on_(0),
 455       target_auth_credentials_(NULL),
 456       stage_blocked_for_callback_(NOT_BLOCKED),
 457       weak_factory_(this) {
 458 }
 459
 460 void BlockingNetworkDelegate::DoCallback(int response) {
 461   ASSERT_EQ(USER_CALLBACK, block_mode_);
 462   ASSERT_NE(NOT_BLOCKED, stage_blocked_for_callback_);
 463   ASSERT_NE(ON_AUTH_REQUIRED, stage_blocked_for_callback_);
 464   CompletionCallback callback = callback_;
 465   Reset();
 466   RunCallback(response, callback);
 467 }
 468
 469 void BlockingNetworkDelegate::DoAuthCallback(
 470     NetworkDelegate::AuthRequiredResponse response) {
 471   ASSERT_EQ(USER_CALLBACK, block_mode_);
 472   ASSERT_EQ(ON_AUTH_REQUIRED, stage_blocked_for_callback_);
 473   AuthCallback auth_callback = auth_callback_;
 474   Reset();
 475   RunAuthCallback(response, auth_callback);
 476 }
 477
 478 void BlockingNetworkDelegate::RunCallback(int response,
 479                                           const CompletionCallback& callback) {
 480   callback.Run(response);
 481 }
 482
 483 void BlockingNetworkDelegate::RunAuthCallback(AuthRequiredResponse response,
 484                                               const AuthCallback& callback) {
 485   if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH) {
 486     ASSERT_TRUE(target_auth_credentials_ != NULL);
 487     *target_auth_credentials_ = auth_credentials_;
 488   }
 489   callback.Run(response);
 490 }
 491
 492 int BlockingNetworkDelegate::OnBeforeURLRequest(
 493     URLRequest* request,
 494     const CompletionCallback& callback,
 495     GURL* new_url) {
 496   if (redirect_url_ == request->url())
 497     return OK;  // We've already seen this request and redirected elsewhere.
 498
 499   TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
 500
 501   if (!redirect_url_.is_empty())
 502     *new_url = redirect_url_;
 503
 504   return MaybeBlockStage(ON_BEFORE_URL_REQUEST, callback);
 505 }
 506
 507 int BlockingNetworkDelegate::OnBeforeSendHeaders(
 508     URLRequest* request,
 509     const CompletionCallback& callback,
 510     HttpRequestHeaders* headers) {
 511   TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
 512
 513   return MaybeBlockStage(ON_BEFORE_SEND_HEADERS, callback);
 514 }
 515
 516 int BlockingNetworkDelegate::OnHeadersReceived(
 517     URLRequest* request,
 518     const CompletionCallback& callback,
 519     const HttpResponseHeaders* original_response_headers,
 520     scoped_refptr<HttpResponseHeaders>* override_response_headers,
 521     GURL* allowed_unsafe_redirect_url) {
 522   TestNetworkDelegate::OnHeadersReceived(request,
 523                                          callback,
 524                                          original_response_headers,
 525                                          override_response_headers,
 526                                          allowed_unsafe_redirect_url);
 527
 528   return MaybeBlockStage(ON_HEADERS_RECEIVED, callback);
 529 }
 530
 531 NetworkDelegate::AuthRequiredResponse BlockingNetworkDelegate::OnAuthRequired(
 532     URLRequest* request,
 533     const AuthChallengeInfo& auth_info,
 534     const AuthCallback& callback,
 535     AuthCredentials* credentials) {
 536   TestNetworkDelegate::OnAuthRequired(request, auth_info, callback,
 537                                       credentials);
 538   // Check that the user has provided callback for the previous blocked stage.
 539   EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_);
 540
 541   if ((block_on_ & ON_AUTH_REQUIRED) == 0) {
 542     return AUTH_REQUIRED_RESPONSE_NO_ACTION;
 543   }
 544
 545   target_auth_credentials_ = credentials;
 546
 547   switch (block_mode_) {
 548     case SYNCHRONOUS:
 549       if (auth_retval_ == AUTH_REQUIRED_RESPONSE_SET_AUTH)
 550         *target_auth_credentials_ = auth_credentials_;
 551       return auth_retval_;
 552
 553     case AUTO_CALLBACK:
 554       base::ThreadTaskRunnerHandle::Get()->PostTask(
 555           FROM_HERE,
 556           base::Bind(&BlockingNetworkDelegate::RunAuthCallback,
 557                      weak_factory_.GetWeakPtr(), auth_retval_, callback));
 558       return AUTH_REQUIRED_RESPONSE_IO_PENDING;
 559
 560     case USER_CALLBACK:
 561       auth_callback_ = callback;
 562       stage_blocked_for_callback_ = ON_AUTH_REQUIRED;
 563       base::ThreadTaskRunnerHandle::Get()->PostTask(
 564           FROM_HERE, base::MessageLoop::QuitClosure());
 565       return AUTH_REQUIRED_RESPONSE_IO_PENDING;
 566   }
 567   NOTREACHED();
 568   return AUTH_REQUIRED_RESPONSE_NO_ACTION;  // Dummy value.
 569 }
 570
 571 void BlockingNetworkDelegate::Reset() {
 572   EXPECT_NE(NOT_BLOCKED, stage_blocked_for_callback_);
 573   stage_blocked_for_callback_ = NOT_BLOCKED;
 574   callback_.Reset();
 575   auth_callback_.Reset();
 576 }
 577
 578 int BlockingNetworkDelegate::MaybeBlockStage(
 579     BlockingNetworkDelegate::Stage stage,
 580     const CompletionCallback& callback) {
 581   // Check that the user has provided callback for the previous blocked stage.
 582   EXPECT_EQ(NOT_BLOCKED, stage_blocked_for_callback_);
 583
 584   if ((block_on_ & stage) == 0) {
 585     return OK;
 586   }
 587
 588   switch (block_mode_) {
 589     case SYNCHRONOUS:
 590       EXPECT_NE(OK, retval_);
 591       return retval_;
 592
 593     case AUTO_CALLBACK:
 594       base::ThreadTaskRunnerHandle::Get()->PostTask(
 595           FROM_HERE, base::Bind(&BlockingNetworkDelegate::RunCallback,
 596                                 weak_factory_.GetWeakPtr(), retval_, callback));
 597       return ERR_IO_PENDING;
 598
 599     case USER_CALLBACK:
 600       callback_ = callback;
 601       stage_blocked_for_callback_ = stage;
 602       base::ThreadTaskRunnerHandle::Get()->PostTask(
 603           FROM_HERE, base::MessageLoop::QuitClosure());
 604       return ERR_IO_PENDING;
 605   }
 606   NOTREACHED();
 607   return 0;
 608 }
 609
 610 class TestURLRequestContextWithProxy : public TestURLRequestContext {
 611  public:
 612   // Does not own |delegate|.
 613   TestURLRequestContextWithProxy(const std::string& proxy,
 614                                  NetworkDelegate* delegate)
 615       : TestURLRequestContext(true) {
 616     context_storage_.set_proxy_service(ProxyService::CreateFixed(proxy));
 617     set_network_delegate(delegate);
 618     Init();
 619   }
 620   ~TestURLRequestContextWithProxy() override {}
 621 };
 622
 623 // A mock ReportSender that just remembers the latest report
 624 // URI and report to be sent.
 625 class MockCertificateReportSender
 626     : public TransportSecurityState::ReportSender {
 627  public:
 628   MockCertificateReportSender() {}
 629   ~MockCertificateReportSender() override {}
 630
 631   void Send(const GURL& report_uri, const std::string& report) override {
 632     latest_report_uri_ = report_uri;
 633     latest_report_ = report;
 634   }
 635
 636   const GURL& latest_report_uri() { return latest_report_uri_; }
 637   const std::string& latest_report() { return latest_report_; }
 638
 639  private:
 640   GURL latest_report_uri_;
 641   std::string latest_report_;
 642 };
 643
 644 }  // namespace
 645
 646 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.
 647 class URLRequestTest : public PlatformTest {
 648  public:
 649   URLRequestTest() : default_context_(true) {
 650     default_context_.set_network_delegate(&default_network_delegate_);
 651     default_context_.set_net_log(&net_log_);
 652     job_factory_impl_ = new URLRequestJobFactoryImpl();
 653     job_factory_.reset(job_factory_impl_);
 654   }
 655
 656   ~URLRequestTest() override {
 657     // URLRequestJobs may post clean-up tasks on destruction.
 658     base::RunLoop().RunUntilIdle();
 659   }
 660
 661   void SetUp() override {
 662     SetUpFactory();
 663     default_context_.set_job_factory(job_factory_.get());
 664     default_context_.Init();
 665     PlatformTest::SetUp();
 666   }
 667
 668   virtual void SetUpFactory() {
 669     job_factory_impl_->SetProtocolHandler(
 670         "data", make_scoped_ptr(new DataProtocolHandler));
 671 #if !defined(DISABLE_FILE_SUPPORT)
 672     job_factory_impl_->SetProtocolHandler(
 673         "file", make_scoped_ptr(new FileProtocolHandler(
 674                     base::ThreadTaskRunnerHandle::Get())));
 675 #endif
 676   }
 677
 678   TestNetworkDelegate* default_network_delegate() {
 679     return &default_network_delegate_;
 680   }
 681
 682   const TestURLRequestContext& default_context() const {
 683     return default_context_;
 684   }
 685
 686
 687   // Adds the TestJobInterceptor to the default context.
 688   TestJobInterceptor* AddTestInterceptor() {
 689     TestJobInterceptor* protocol_handler_ = new TestJobInterceptor();
 690     job_factory_impl_->SetProtocolHandler("http", nullptr);
 691     job_factory_impl_->SetProtocolHandler("http",
 692                                           make_scoped_ptr(protocol_handler_));
 693     return protocol_handler_;
 694   }
 695
 696  protected:
 697   TestNetLog net_log_;
 698   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
 699   URLRequestJobFactoryImpl* job_factory_impl_;
 700   scoped_ptr<URLRequestJobFactory> job_factory_;
 701   TestURLRequestContext default_context_;
 702 };
 703
 704 TEST_F(URLRequestTest, AboutBlankTest) {
 705   TestDelegate d;
 706   {
 707     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
 708         GURL("about:blank"), DEFAULT_PRIORITY, &d));
 709
 710     r->Start();
 711     EXPECT_TRUE(r->is_pending());
 712
 713     base::RunLoop().Run();
 714
 715     EXPECT_TRUE(!r->is_pending());
 716     EXPECT_FALSE(d.received_data_before_response());
 717     EXPECT_EQ(d.bytes_received(), 0);
 718     EXPECT_EQ("", r->GetSocketAddress().host());
 719     EXPECT_EQ(0, r->GetSocketAddress().port());
 720
 721     HttpRequestHeaders headers;
 722     EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
 723   }
 724 }
 725
 726 TEST_F(URLRequestTest, DataURLImageTest) {
 727   TestDelegate d;
 728   {
 729     // Use our nice little Chrome logo.
 730     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
 731         GURL(
 732             "data:image/png;base64,"
 733             "iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAADVklEQVQ4jX2TfUwUB"
 734             "BjG3w1y+HGcd9dxhXR8T4awOccJGgOSWclHImznLkTlSw0DDQXkrmgYgbUYnlQTqQ"
 735             "xIEVxitD5UMCATRA1CEEg+Qjw3bWDxIauJv/5oumqs39/P827vnucRmYN0gyF01GI"
 736             "5MpCVdW0gO7tvNC+vqSEtbZefk5NuLv1jdJ46p/zw0HeH4+PHr3h7c1mjoV2t5rKz"
 737             "Mx1+fg9bAgK6zHq9cU5z+LpA3xOtx34+vTeT21onRuzssC3zxbbSwC13d/pFuC7Ck"
 738             "IMDxQpF7r/MWq12UctI1dWWm99ypqSYmRUBdKem8MkrO/kgaTt1O7YzlpzE5GIVd0"
 739             "WYUqt57yWf2McHTObYPbVD+ZwbtlLTVMZ3BW+TnLyXLaWtmEq6WJVbT3HBh3Svj2H"
 740             "QQcm43XwmtoYM6vVKleh0uoWvnzW3v3MpidruPTQPf0bia7sJOtBM0ufTWNvus/nk"
 741             "DFHF9ZS+uYVjRUasMeHUmyLYtcklTvzWGFZnNOXczThvpKIzjcahSqIzkvDLayDq6"
 742             "D3eOjtBbNUEIZYyqsvj4V4wY92eNJ4IoyhTbxXX1T5xsV9tm9r4TQwHLiZw/pdDZJ"
 743             "ea8TKmsmR/K0uLh/GwnCHghTja6lPhphezPfO5/5MrVvMzNaI3+ERHfrFzPKQukrQ"
 744             "GI4d/3EFD/3E2mVNYvi4at7CXWREaxZGD+3hg28zD3gVMd6q5c8GdosynKmSeRuGz"
 745             "pjyl1/9UDGtPR5HeaKT8Wjo17WXk579BXVUhN64ehF9fhRtq/uxxZKzNiZFGD0wRC"
 746             "3NFROZ5mwIPL/96K/rKMMLrIzF9uhHr+/sYH7DAbwlgC4J+R2Z7FUx1qLnV7MGF40"
 747             "smVSoJ/jvHRfYhQeUJd/SnYtGWhPHR0Sz+GE2F2yth0B36Vcz2KpnufBJbsysjjW4"
 748             "kblBUiIjiURUWqJY65zxbnTy57GQyH58zgy0QBtTQv5gH15XMdKkYu+TGaJMnlm2O"
 749             "34uI4b9tflqp1+QEFGzoW/ulmcofcpkZCYJhDfSpme7QcrHa+Xfji8paEQkTkSfmm"
 750             "oRWRNZr/F1KfVMjW+IKEnv2FwZfKdzt0BQR6lClcZR0EfEXEfv/G6W9iLiIyCoReV"
 751             "5EnhORIBHx+ufPj/gLB/zGI/G4Bk0AAAAASUVORK5CYII="),
 752         DEFAULT_PRIORITY, &d));
 753
 754     r->Start();
 755     EXPECT_TRUE(r->is_pending());
 756
 757     base::RunLoop().Run();
 758
 759     EXPECT_TRUE(!r->is_pending());
 760     EXPECT_FALSE(d.received_data_before_response());
 761     EXPECT_EQ(d.bytes_received(), 911);
 762     EXPECT_EQ("", r->GetSocketAddress().host());
 763     EXPECT_EQ(0, r->GetSocketAddress().port());
 764
 765     HttpRequestHeaders headers;
 766     EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
 767   }
 768 }
 769
 770 #if !defined(DISABLE_FILE_SUPPORT)
 771 TEST_F(URLRequestTest, FileTest) {
 772   base::FilePath app_path;
 773   PathService::Get(base::FILE_EXE, &app_path);
 774   GURL app_url = FilePathToFileURL(app_path);
 775
 776   TestDelegate d;
 777   {
 778     scoped_ptr<URLRequest> r(
 779         default_context_.CreateRequest(app_url, DEFAULT_PRIORITY, &d));
 780
 781     r->Start();
 782     EXPECT_TRUE(r->is_pending());
 783
 784     base::RunLoop().Run();
 785
 786     int64 file_size = -1;
 787     EXPECT_TRUE(base::GetFileSize(app_path, &file_size));
 788
 789     EXPECT_TRUE(!r->is_pending());
 790     EXPECT_EQ(1, d.response_started_count());
 791     EXPECT_FALSE(d.received_data_before_response());
 792     EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
 793     EXPECT_EQ("", r->GetSocketAddress().host());
 794     EXPECT_EQ(0, r->GetSocketAddress().port());
 795
 796     HttpRequestHeaders headers;
 797     EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
 798   }
 799 }
 800
 801 TEST_F(URLRequestTest, FileTestCancel) {
 802   base::FilePath app_path;
 803   PathService::Get(base::FILE_EXE, &app_path);
 804   GURL app_url = FilePathToFileURL(app_path);
 805
 806   TestDelegate d;
 807   {
 808     scoped_ptr<URLRequest> r(
 809         default_context_.CreateRequest(app_url, DEFAULT_PRIORITY, &d));
 810
 811     r->Start();
 812     EXPECT_TRUE(r->is_pending());
 813     r->Cancel();
 814   }
 815   // Async cancellation should be safe even when URLRequest has been already
 816   // destroyed.
 817   base::RunLoop().RunUntilIdle();
 818 }
 819
 820 TEST_F(URLRequestTest, FileTestFullSpecifiedRange) {
 821   const size_t buffer_size = 4000;
 822   scoped_ptr<char[]> buffer(new char[buffer_size]);
 823   FillBuffer(buffer.get(), buffer_size);
 824
 825   base::FilePath temp_path;
 826   EXPECT_TRUE(base::CreateTemporaryFile(&temp_path));
 827   GURL temp_url = FilePathToFileURL(temp_path);
 828   EXPECT_TRUE(base::WriteFile(temp_path, buffer.get(), buffer_size));
 829
 830   int64 file_size;
 831   EXPECT_TRUE(base::GetFileSize(temp_path, &file_size));
 832
 833   const size_t first_byte_position = 500;
 834   const size_t last_byte_position = buffer_size - first_byte_position;
 835   const size_t content_length = last_byte_position - first_byte_position + 1;
 836   std::string partial_buffer_string(buffer.get() + first_byte_position,
 837                                     buffer.get() + last_byte_position + 1);
 838
 839   TestDelegate d;
 840   {
 841     scoped_ptr<URLRequest> r(
 842         default_context_.CreateRequest(temp_url, DEFAULT_PRIORITY, &d));
 843
 844     HttpRequestHeaders headers;
 845     headers.SetHeader(
 846         HttpRequestHeaders::kRange,
 847         HttpByteRange::Bounded(
 848             first_byte_position, last_byte_position).GetHeaderValue());
 849     r->SetExtraRequestHeaders(headers);
 850     r->Start();
 851     EXPECT_TRUE(r->is_pending());
 852
 853     base::RunLoop().Run();
 854     EXPECT_TRUE(!r->is_pending());
 855     EXPECT_EQ(1, d.response_started_count());
 856     EXPECT_FALSE(d.received_data_before_response());
 857     EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
 858     // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed.
 859     EXPECT_TRUE(partial_buffer_string == d.data_received());
 860   }
 861
 862   EXPECT_TRUE(base::DeleteFile(temp_path, false));
 863 }
 864
 865 TEST_F(URLRequestTest, FileTestHalfSpecifiedRange) {
 866   const size_t buffer_size = 4000;
 867   scoped_ptr<char[]> buffer(new char[buffer_size]);
 868   FillBuffer(buffer.get(), buffer_size);
 869
 870   base::FilePath temp_path;
 871   EXPECT_TRUE(base::CreateTemporaryFile(&temp_path));
 872   GURL temp_url = FilePathToFileURL(temp_path);
 873   EXPECT_TRUE(base::WriteFile(temp_path, buffer.get(), buffer_size));
 874
 875   int64 file_size;
 876   EXPECT_TRUE(base::GetFileSize(temp_path, &file_size));
 877
 878   const size_t first_byte_position = 500;
 879   const size_t last_byte_position = buffer_size - 1;
 880   const size_t content_length = last_byte_position - first_byte_position + 1;
 881   std::string partial_buffer_string(buffer.get() + first_byte_position,
 882                                     buffer.get() + last_byte_position + 1);
 883
 884   TestDelegate d;
 885   {
 886     scoped_ptr<URLRequest> r(
 887         default_context_.CreateRequest(temp_url, DEFAULT_PRIORITY, &d));
 888
 889     HttpRequestHeaders headers;
 890     headers.SetHeader(HttpRequestHeaders::kRange,
 891                       HttpByteRange::RightUnbounded(
 892                           first_byte_position).GetHeaderValue());
 893     r->SetExtraRequestHeaders(headers);
 894     r->Start();
 895     EXPECT_TRUE(r->is_pending());
 896
 897     base::RunLoop().Run();
 898     EXPECT_TRUE(!r->is_pending());
 899     EXPECT_EQ(1, d.response_started_count());
 900     EXPECT_FALSE(d.received_data_before_response());
 901     EXPECT_EQ(static_cast<int>(content_length), d.bytes_received());
 902     // Don't use EXPECT_EQ, it will print out a lot of garbage if check failed.
 903     EXPECT_TRUE(partial_buffer_string == d.data_received());
 904   }
 905
 906   EXPECT_TRUE(base::DeleteFile(temp_path, false));
 907 }
 908
 909 TEST_F(URLRequestTest, FileTestMultipleRanges) {
 910   const size_t buffer_size = 400000;
 911   scoped_ptr<char[]> buffer(new char[buffer_size]);
 912   FillBuffer(buffer.get(), buffer_size);
 913
 914   base::FilePath temp_path;
 915   EXPECT_TRUE(base::CreateTemporaryFile(&temp_path));
 916   GURL temp_url = FilePathToFileURL(temp_path);
 917   EXPECT_TRUE(base::WriteFile(temp_path, buffer.get(), buffer_size));
 918
 919   int64 file_size;
 920   EXPECT_TRUE(base::GetFileSize(temp_path, &file_size));
 921
 922   TestDelegate d;
 923   {
 924     scoped_ptr<URLRequest> r(
 925         default_context_.CreateRequest(temp_url, DEFAULT_PRIORITY, &d));
 926
 927     HttpRequestHeaders headers;
 928     headers.SetHeader(HttpRequestHeaders::kRange, "bytes=0-0,10-200,200-300");
 929     r->SetExtraRequestHeaders(headers);
 930     r->Start();
 931     EXPECT_TRUE(r->is_pending());
 932
 933     base::RunLoop().Run();
 934     EXPECT_TRUE(d.request_failed());
 935   }
 936
 937   EXPECT_TRUE(base::DeleteFile(temp_path, false));
 938 }
 939
 940 TEST_F(URLRequestTest, AllowFileURLs) {
 941   base::ScopedTempDir temp_dir;
 942   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 943   base::FilePath test_file;
 944   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &test_file));
 945   std::string test_data("monkey");
 946   base::WriteFile(test_file, test_data.data(), test_data.size());
 947   GURL test_file_url = FilePathToFileURL(test_file);
 948
 949   {
 950     TestDelegate d;
 951     TestNetworkDelegate network_delegate;
 952     network_delegate.set_can_access_files(true);
 953     default_context_.set_network_delegate(&network_delegate);
 954     scoped_ptr<URLRequest> r(
 955         default_context_.CreateRequest(test_file_url, DEFAULT_PRIORITY, &d));
 956     r->Start();
 957     base::RunLoop().Run();
 958     EXPECT_FALSE(d.request_failed());
 959     EXPECT_EQ(test_data, d.data_received());
 960   }
 961
 962   {
 963     TestDelegate d;
 964     TestNetworkDelegate network_delegate;
 965     network_delegate.set_can_access_files(false);
 966     default_context_.set_network_delegate(&network_delegate);
 967     scoped_ptr<URLRequest> r(
 968         default_context_.CreateRequest(test_file_url, DEFAULT_PRIORITY, &d));
 969     r->Start();
 970     base::RunLoop().Run();
 971     EXPECT_TRUE(d.request_failed());
 972     EXPECT_EQ("", d.data_received());
 973   }
 974 }
 975
 976
 977 TEST_F(URLRequestTest, FileDirCancelTest) {
 978   // Put in mock resource provider.
 979   NetModule::SetResourceProvider(TestNetResourceProvider);
 980
 981   TestDelegate d;
 982   {
 983     base::FilePath file_path;
 984     PathService::Get(base::DIR_SOURCE_ROOT, &file_path);
 985     file_path = file_path.Append(FILE_PATH_LITERAL("net"));
 986     file_path = file_path.Append(FILE_PATH_LITERAL("data"));
 987
 988     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
 989         FilePathToFileURL(file_path), DEFAULT_PRIORITY, &d));
 990     req->Start();
 991     EXPECT_TRUE(req->is_pending());
 992
 993     d.set_cancel_in_received_data_pending(true);
 994
 995     base::RunLoop().Run();
 996   }
 997
 998   // Take out mock resource provider.
 999   NetModule::SetResourceProvider(NULL);
1000 }
1001
1002 TEST_F(URLRequestTest, FileDirOutputSanity) {
1003   // Verify the general sanity of the the output of the file:
1004   // directory lister by checking for the output of a known existing
1005   // file.
1006   const char sentinel_name[] = "filedir-sentinel";
1007
1008   base::FilePath path;
1009   PathService::Get(base::DIR_SOURCE_ROOT, &path);
1010   path = path.Append(kTestFilePath);
1011
1012   TestDelegate d;
1013   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
1014       FilePathToFileURL(path), DEFAULT_PRIORITY, &d));
1015   req->Start();
1016   base::RunLoop().Run();
1017
1018   // Generate entry for the sentinel file.
1019   base::FilePath sentinel_path = path.AppendASCII(sentinel_name);
1020   base::File::Info info;
1021   EXPECT_TRUE(base::GetFileInfo(sentinel_path, &info));
1022   EXPECT_GT(info.size, 0);
1023   std::string sentinel_output = GetDirectoryListingEntry(
1024       base::string16(sentinel_name, sentinel_name + strlen(sentinel_name)),
1025       std::string(sentinel_name),
1026       false /* is_dir */,
1027       info.size,
1028       info.last_modified);
1029
1030   ASSERT_LT(0, d.bytes_received());
1031   ASSERT_FALSE(d.request_failed());
1032   ASSERT_TRUE(req->status().is_success());
1033   // Check for the entry generated for the "sentinel" file.
1034   const std::string& data = d.data_received();
1035   ASSERT_NE(data.find(sentinel_output), std::string::npos);
1036 }
1037
1038 TEST_F(URLRequestTest, FileDirRedirectNoCrash) {
1039   // There is an implicit redirect when loading a file path that matches a
1040   // directory and does not end with a slash.  Ensure that following such
1041   // redirects does not crash.  See http://crbug.com/18686.
1042
1043   base::FilePath path;
1044   PathService::Get(base::DIR_SOURCE_ROOT, &path);
1045   path = path.Append(kTestFilePath);
1046
1047   TestDelegate d;
1048   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
1049       FilePathToFileURL(path), DEFAULT_PRIORITY, &d));
1050   req->Start();
1051   base::RunLoop().Run();
1052
1053   ASSERT_EQ(1, d.received_redirect_count());
1054   ASSERT_LT(0, d.bytes_received());
1055   ASSERT_FALSE(d.request_failed());
1056   ASSERT_TRUE(req->status().is_success());
1057 }
1058
1059 #if defined(OS_WIN)
1060 // Don't accept the url "file:///" on windows. See http://crbug.com/1474.
1061 TEST_F(URLRequestTest, FileDirRedirectSingleSlash) {
1062   TestDelegate d;
1063   scoped_ptr<URLRequest> req(
1064       default_context_.CreateRequest(GURL("file:///"), DEFAULT_PRIORITY, &d));
1065   req->Start();
1066   base::RunLoop().Run();
1067
1068   ASSERT_EQ(1, d.received_redirect_count());
1069   ASSERT_FALSE(req->status().is_success());
1070 }
1071 #endif  // defined(OS_WIN)
1072
1073 #endif  // !defined(DISABLE_FILE_SUPPORT)
1074
1075 TEST_F(URLRequestTest, InvalidUrlTest) {
1076   TestDelegate d;
1077   {
1078     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
1079         GURL("invalid url"), DEFAULT_PRIORITY, &d));
1080
1081     r->Start();
1082     EXPECT_TRUE(r->is_pending());
1083
1084     base::RunLoop().Run();
1085     EXPECT_TRUE(d.request_failed());
1086   }
1087 }
1088
1089 TEST_F(URLRequestTest, InvalidReferrerTest) {
1090   TestURLRequestContext context;
1091   TestNetworkDelegate network_delegate;
1092   network_delegate.set_cancel_request_with_policy_violating_referrer(true);
1093   context.set_network_delegate(&network_delegate);
1094   TestDelegate d;
1095   scoped_ptr<URLRequest> req(
1096       context.CreateRequest(GURL("http://localhost/"), DEFAULT_PRIORITY, &d));
1097   req->SetReferrer("https://somewhere.com/");
1098
1099   req->Start();
1100   base::RunLoop().Run();
1101   EXPECT_TRUE(d.request_failed());
1102 }
1103
1104 #if defined(OS_WIN)
1105 TEST_F(URLRequestTest, ResolveShortcutTest) {
1106   base::FilePath app_path;
1107   PathService::Get(base::DIR_SOURCE_ROOT, &app_path);
1108   app_path = app_path.Append(kTestFilePath);
1109   app_path = app_path.AppendASCII("with-headers.html");
1110
1111   std::wstring lnk_path = app_path.value() + L".lnk";
1112
1113   base::win::ScopedCOMInitializer com_initializer;
1114
1115   // Temporarily create a shortcut for test
1116   {
1117     base::win::ScopedComPtr<IShellLink> shell;
1118     ASSERT_TRUE(SUCCEEDED(shell.CreateInstance(CLSID_ShellLink, NULL,
1119                                                CLSCTX_INPROC_SERVER)));
1120     base::win::ScopedComPtr<IPersistFile> persist;
1121     ASSERT_TRUE(SUCCEEDED(shell.QueryInterface(persist.Receive())));
1122     EXPECT_TRUE(SUCCEEDED(shell->SetPath(app_path.value().c_str())));
1123     EXPECT_TRUE(SUCCEEDED(shell->SetDescription(L"ResolveShortcutTest")));
1124     EXPECT_TRUE(SUCCEEDED(persist->Save(lnk_path.c_str(), TRUE)));
1125   }
1126
1127   TestDelegate d;
1128   {
1129     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
1130         FilePathToFileURL(base::FilePath(lnk_path)), DEFAULT_PRIORITY, &d));
1131
1132     r->Start();
1133     EXPECT_TRUE(r->is_pending());
1134
1135     base::RunLoop().Run();
1136
1137     WIN32_FILE_ATTRIBUTE_DATA data;
1138     GetFileAttributesEx(app_path.value().c_str(),
1139                         GetFileExInfoStandard, &data);
1140     HANDLE file = CreateFile(app_path.value().c_str(), GENERIC_READ,
1141                              FILE_SHARE_READ, NULL, OPEN_EXISTING,
1142                              FILE_ATTRIBUTE_NORMAL, NULL);
1143     EXPECT_NE(INVALID_HANDLE_VALUE, file);
1144     scoped_ptr<char[]> buffer(new char[data.nFileSizeLow]);
1145     DWORD read_size;
1146     BOOL result;
1147     result = ReadFile(file, buffer.get(), data.nFileSizeLow,
1148                       &read_size, NULL);
1149     std::string content(buffer.get(), read_size);
1150     CloseHandle(file);
1151
1152     EXPECT_TRUE(!r->is_pending());
1153     EXPECT_EQ(1, d.received_redirect_count());
1154     EXPECT_EQ(content, d.data_received());
1155   }
1156
1157   // Clean the shortcut
1158   DeleteFile(lnk_path.c_str());
1159 }
1160 #endif  // defined(OS_WIN)
1161
1162 // Custom URLRequestJobs for use with interceptor tests
1163 class RestartTestJob : public URLRequestTestJob {
1164  public:
1165   RestartTestJob(URLRequest* request, NetworkDelegate* network_delegate)
1166     : URLRequestTestJob(request, network_delegate, true) {}
1167  protected:
1168   void StartAsync() override { this->NotifyRestartRequired(); }
1169  private:
1170   ~RestartTestJob() override {}
1171 };
1172
1173 class CancelTestJob : public URLRequestTestJob {
1174  public:
1175   explicit CancelTestJob(URLRequest* request, NetworkDelegate* network_delegate)
1176     : URLRequestTestJob(request, network_delegate, true) {}
1177  protected:
1178   void StartAsync() override { request_->Cancel(); }
1179  private:
1180   ~CancelTestJob() override {}
1181 };
1182
1183 class CancelThenRestartTestJob : public URLRequestTestJob {
1184  public:
1185   explicit CancelThenRestartTestJob(URLRequest* request,
1186                                     NetworkDelegate* network_delegate)
1187       : URLRequestTestJob(request, network_delegate, true) {
1188   }
1189  protected:
1190   void StartAsync() override {
1191     request_->Cancel();
1192     this->NotifyRestartRequired();
1193   }
1194  private:
1195   ~CancelThenRestartTestJob() override {}
1196 };
1197
1198 // An Interceptor for use with interceptor tests.
1199 class MockURLRequestInterceptor : public URLRequestInterceptor {
1200  public:
1201   // Static getters for canned response header and data strings.
1202   static std::string ok_data() {
1203     return URLRequestTestJob::test_data_1();
1204   }
1205
1206   static std::string ok_headers() {
1207     return URLRequestTestJob::test_headers();
1208   }
1209
1210   static std::string redirect_data() {
1211     return std::string();
1212   }
1213
1214   static std::string redirect_headers() {
1215     return URLRequestTestJob::test_redirect_headers();
1216   }
1217
1218   static std::string error_data() {
1219     return std::string("ohhh nooooo mr. bill!");
1220   }
1221
1222   static std::string error_headers() {
1223     return URLRequestTestJob::test_error_headers();
1224   }
1225
1226   MockURLRequestInterceptor()
1227       : intercept_main_request_(false), restart_main_request_(false),
1228         cancel_main_request_(false), cancel_then_restart_main_request_(false),
1229         simulate_main_network_error_(false),
1230         intercept_redirect_(false), cancel_redirect_request_(false),
1231         intercept_final_response_(false), cancel_final_request_(false),
1232         use_url_request_http_job_(false),
1233         did_intercept_main_(false), did_restart_main_(false),
1234         did_cancel_main_(false), did_cancel_then_restart_main_(false),
1235         did_simulate_error_main_(false),
1236         did_intercept_redirect_(false), did_cancel_redirect_(false),
1237         did_intercept_final_(false), did_cancel_final_(false) {
1238   }
1239
1240   ~MockURLRequestInterceptor() override {
1241   }
1242
1243   // URLRequestInterceptor implementation:
1244   URLRequestJob* MaybeInterceptRequest(
1245       URLRequest* request,
1246       NetworkDelegate* network_delegate) const override {
1247     if (restart_main_request_) {
1248       restart_main_request_ = false;
1249       did_restart_main_ = true;
1250       return new RestartTestJob(request, network_delegate);
1251     }
1252     if (cancel_main_request_) {
1253       cancel_main_request_ = false;
1254       did_cancel_main_ = true;
1255       return new CancelTestJob(request, network_delegate);
1256     }
1257     if (cancel_then_restart_main_request_) {
1258       cancel_then_restart_main_request_ = false;
1259       did_cancel_then_restart_main_ = true;
1260       return new CancelThenRestartTestJob(request, network_delegate);
1261     }
1262     if (simulate_main_network_error_) {
1263       simulate_main_network_error_ = false;
1264       did_simulate_error_main_ = true;
1265       if (use_url_request_http_job_) {
1266         return URLRequestHttpJob::Factory(request, network_delegate, "http");
1267       }
1268       // This job will result in error since the requested URL is not one of the
1269       // URLs supported by these tests.
1270       return new URLRequestTestJob(request, network_delegate, true);
1271     }
1272     if (!intercept_main_request_)
1273       return nullptr;
1274     intercept_main_request_ = false;
1275     did_intercept_main_ = true;
1276     URLRequestTestJob* job =  new URLRequestTestJob(request,
1277                                                     network_delegate,
1278                                                     main_headers_,
1279                                                     main_data_,
1280                                                     true);
1281     job->set_load_timing_info(main_request_load_timing_info_);
1282     return job;
1283   }
1284
1285   URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
1286                                         NetworkDelegate* network_delegate,
1287                                         const GURL& location) const override {
1288     if (cancel_redirect_request_) {
1289       cancel_redirect_request_ = false;
1290       did_cancel_redirect_ = true;
1291       return new CancelTestJob(request, network_delegate);
1292     }
1293     if (!intercept_redirect_)
1294       return nullptr;
1295     intercept_redirect_ = false;
1296     did_intercept_redirect_ = true;
1297     if (use_url_request_http_job_) {
1298       return URLRequestHttpJob::Factory(request, network_delegate, "http");
1299     }
1300     return new URLRequestTestJob(request,
1301                                  network_delegate,
1302                                  redirect_headers_,
1303                                  redirect_data_,
1304                                  true);
1305   }
1306
1307   URLRequestJob* MaybeInterceptResponse(
1308       URLRequest* request,
1309       NetworkDelegate* network_delegate) const override {
1310     if (cancel_final_request_) {
1311       cancel_final_request_ = false;
1312       did_cancel_final_ = true;
1313       return new CancelTestJob(request, network_delegate);
1314     }
1315     if (!intercept_final_response_)
1316       return nullptr;
1317     intercept_final_response_ = false;
1318     did_intercept_final_ = true;
1319     if (use_url_request_http_job_) {
1320       return URLRequestHttpJob::Factory(request, network_delegate, "http");
1321     }
1322     return new URLRequestTestJob(request,
1323                                  network_delegate,
1324                                  final_headers_,
1325                                  final_data_,
1326                                  true);
1327   }
1328
1329   void set_intercept_main_request(bool intercept_main_request) {
1330     intercept_main_request_ = intercept_main_request;
1331   }
1332
1333   void set_main_headers(const std::string& main_headers) {
1334     main_headers_ = main_headers;
1335   }
1336
1337   void set_main_data(const std::string& main_data) {
1338     main_data_ = main_data;
1339   }
1340
1341   void set_main_request_load_timing_info(
1342       const LoadTimingInfo& main_request_load_timing_info) {
1343     main_request_load_timing_info_ = main_request_load_timing_info;
1344   }
1345
1346   void set_restart_main_request(bool restart_main_request) {
1347     restart_main_request_ = restart_main_request;
1348   }
1349
1350   void set_cancel_main_request(bool cancel_main_request) {
1351     cancel_main_request_ = cancel_main_request;
1352   }
1353
1354   void set_cancel_then_restart_main_request(
1355       bool cancel_then_restart_main_request) {
1356     cancel_then_restart_main_request_ = cancel_then_restart_main_request;
1357   }
1358
1359   void set_simulate_main_network_error(bool simulate_main_network_error) {
1360     simulate_main_network_error_ = simulate_main_network_error;
1361   }
1362
1363   void set_intercept_redirect(bool intercept_redirect) {
1364     intercept_redirect_ = intercept_redirect;
1365   }
1366
1367   void set_redirect_headers(const std::string& redirect_headers) {
1368     redirect_headers_ = redirect_headers;
1369   }
1370
1371   void set_redirect_data(const std::string& redirect_data) {
1372     redirect_data_ = redirect_data;
1373   }
1374
1375   void set_cancel_redirect_request(bool cancel_redirect_request) {
1376     cancel_redirect_request_ = cancel_redirect_request;
1377   }
1378
1379   void set_intercept_final_response(bool intercept_final_response) {
1380     intercept_final_response_ = intercept_final_response;
1381   }
1382
1383   void set_final_headers(const std::string& final_headers) {
1384     final_headers_ = final_headers;
1385   }
1386
1387   void set_final_data(const std::string& final_data) {
1388     final_data_ = final_data;
1389   }
1390
1391   void set_cancel_final_request(bool cancel_final_request) {
1392     cancel_final_request_ = cancel_final_request;
1393   }
1394
1395   void set_use_url_request_http_job(bool use_url_request_http_job) {
1396     use_url_request_http_job_ = use_url_request_http_job;
1397   }
1398
1399   bool did_intercept_main() const {
1400     return did_intercept_main_;
1401   }
1402
1403   bool did_restart_main() const {
1404     return did_restart_main_;
1405   }
1406
1407   bool did_cancel_main() const {
1408     return did_cancel_main_;
1409   }
1410
1411   bool did_cancel_then_restart_main() const {
1412     return did_cancel_then_restart_main_;
1413   }
1414
1415   bool did_simulate_error_main() const {
1416     return did_simulate_error_main_;
1417   }
1418
1419   bool did_intercept_redirect() const {
1420     return did_intercept_redirect_;
1421   }
1422
1423   bool did_cancel_redirect() const {
1424     return did_cancel_redirect_;
1425   }
1426
1427   bool did_intercept_final() const {
1428     return did_intercept_final_;
1429   }
1430
1431   bool did_cancel_final() const {
1432     return did_cancel_final_;
1433   }
1434
1435  private:
1436   // Indicate whether to intercept the main request, and if so specify the
1437   // response to return and the LoadTimingInfo to use.
1438   mutable bool intercept_main_request_;
1439   mutable std::string main_headers_;
1440   mutable std::string main_data_;
1441   mutable LoadTimingInfo main_request_load_timing_info_;
1442
1443   // These indicate actions that can be taken within MaybeInterceptRequest.
1444   mutable bool restart_main_request_;
1445   mutable bool cancel_main_request_;
1446   mutable bool cancel_then_restart_main_request_;
1447   mutable bool simulate_main_network_error_;
1448
1449   // Indicate whether to intercept redirects, and if so specify the response to
1450   // return.
1451   mutable bool intercept_redirect_;
1452   mutable std::string redirect_headers_;
1453   mutable std::string redirect_data_;
1454
1455   // Cancel the request within MaybeInterceptRedirect.
1456   mutable bool cancel_redirect_request_;
1457
1458   // Indicate whether to intercept the final response, and if so specify the
1459   // response to return.
1460   mutable bool intercept_final_response_;
1461   mutable std::string final_headers_;
1462   mutable std::string final_data_;
1463
1464   // Cancel the final request within MaybeInterceptResponse.
1465   mutable bool cancel_final_request_;
1466
1467   // Instruct the interceptor to use a real URLRequestHTTPJob.
1468   mutable bool use_url_request_http_job_;
1469
1470   // These indicate if the interceptor did something or not.
1471   mutable bool did_intercept_main_;
1472   mutable bool did_restart_main_;
1473   mutable bool did_cancel_main_;
1474   mutable bool did_cancel_then_restart_main_;
1475   mutable bool did_simulate_error_main_;
1476   mutable bool did_intercept_redirect_;
1477   mutable bool did_cancel_redirect_;
1478   mutable bool did_intercept_final_;
1479   mutable bool did_cancel_final_;
1480 };
1481
1482 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.
1483 class URLRequestInterceptorTest : public URLRequestTest {
1484  public:
1485   URLRequestInterceptorTest() : URLRequestTest(), interceptor_(NULL) {
1486   }
1487
1488   ~URLRequestInterceptorTest() override {
1489     // URLRequestJobs may post clean-up tasks on destruction.
1490     base::RunLoop().RunUntilIdle();
1491   }
1492
1493   void SetUpFactory() override {
1494     interceptor_ = new MockURLRequestInterceptor();
1495     job_factory_.reset(new URLRequestInterceptingJobFactory(
1496         job_factory_.Pass(), make_scoped_ptr(interceptor_)));
1497   }
1498
1499   MockURLRequestInterceptor* interceptor() const {
1500     return interceptor_;
1501   }
1502
1503  private:
1504   MockURLRequestInterceptor* interceptor_;
1505 };
1506
1507 TEST_F(URLRequestInterceptorTest, Intercept) {
1508   // Intercept the main request and respond with a simple response.
1509   interceptor()->set_intercept_main_request(true);
1510   interceptor()->set_main_headers(MockURLRequestInterceptor::ok_headers());
1511   interceptor()->set_main_data(MockURLRequestInterceptor::ok_data());
1512   TestDelegate d;
1513   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1514       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1515   base::SupportsUserData::Data* user_data0 = new base::SupportsUserData::Data();
1516   base::SupportsUserData::Data* user_data1 = new base::SupportsUserData::Data();
1517   base::SupportsUserData::Data* user_data2 = new base::SupportsUserData::Data();
1518   req->SetUserData(nullptr, user_data0);
1519   req->SetUserData(&user_data1, user_data1);
1520   req->SetUserData(&user_data2, user_data2);
1521   req->set_method("GET");
1522   req->Start();
1523   base::RunLoop().Run();
1524
1525   // Make sure we can retrieve our specific user data.
1526   EXPECT_EQ(user_data0, req->GetUserData(nullptr));
1527   EXPECT_EQ(user_data1, req->GetUserData(&user_data1));
1528   EXPECT_EQ(user_data2, req->GetUserData(&user_data2));
1529
1530   // Check that we got one good response.
1531   EXPECT_TRUE(req->status().is_success());
1532   EXPECT_EQ(200, req->response_headers()->response_code());
1533   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
1534   EXPECT_EQ(1, d.response_started_count());
1535   EXPECT_EQ(0, d.received_redirect_count());
1536 }
1537
1538 TEST_F(URLRequestInterceptorTest, InterceptRedirect) {
1539   // Intercept the main request and respond with a redirect.
1540   interceptor()->set_intercept_main_request(true);
1541   interceptor()->set_main_headers(
1542       MockURLRequestInterceptor::redirect_headers());
1543   interceptor()->set_main_data(MockURLRequestInterceptor::redirect_data());
1544
1545   // Intercept that redirect and respond with a final OK response.
1546   interceptor()->set_intercept_redirect(true);
1547   interceptor()->set_redirect_headers(MockURLRequestInterceptor::ok_headers());
1548   interceptor()->set_redirect_data(MockURLRequestInterceptor::ok_data());
1549
1550   TestDelegate d;
1551   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1552       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1553   req->set_method("GET");
1554   req->Start();
1555   base::RunLoop().Run();
1556
1557   // Check that the interceptor got called as expected.
1558   EXPECT_TRUE(interceptor()->did_intercept_main());
1559   EXPECT_TRUE(interceptor()->did_intercept_redirect());
1560
1561   // Check that we got one good response.
1562   EXPECT_TRUE(req->status().is_success());
1563   if (req->status().is_success())
1564     EXPECT_EQ(200, req->response_headers()->response_code());
1565
1566   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
1567   EXPECT_EQ(1, d.response_started_count());
1568   EXPECT_EQ(0, d.received_redirect_count());
1569 }
1570
1571 TEST_F(URLRequestInterceptorTest, InterceptServerError) {
1572   // Intercept the main request to generate a server error response.
1573   interceptor()->set_intercept_main_request(true);
1574   interceptor()->set_main_headers(MockURLRequestInterceptor::error_headers());
1575   interceptor()->set_main_data(MockURLRequestInterceptor::error_data());
1576
1577   // Intercept that error and respond with an OK response.
1578   interceptor()->set_intercept_final_response(true);
1579   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
1580   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
1581
1582   TestDelegate d;
1583   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1584       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1585   req->set_method("GET");
1586   req->Start();
1587   base::RunLoop().Run();
1588
1589   // Check that the interceptor got called as expected.
1590   EXPECT_TRUE(interceptor()->did_intercept_main());
1591   EXPECT_TRUE(interceptor()->did_intercept_final());
1592
1593   // Check that we got one good response.
1594   EXPECT_TRUE(req->status().is_success());
1595   EXPECT_EQ(200, req->response_headers()->response_code());
1596   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
1597   EXPECT_EQ(1, d.response_started_count());
1598   EXPECT_EQ(0, d.received_redirect_count());
1599 }
1600
1601 TEST_F(URLRequestInterceptorTest, InterceptNetworkError) {
1602   // Intercept the main request to simulate a network error.
1603   interceptor()->set_simulate_main_network_error(true);
1604
1605   // Intercept that error and respond with an OK response.
1606   interceptor()->set_intercept_final_response(true);
1607   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
1608   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
1609
1610   TestDelegate d;
1611   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1612       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1613   req->set_method("GET");
1614   req->Start();
1615   base::RunLoop().Run();
1616
1617   // Check that the interceptor got called as expected.
1618   EXPECT_TRUE(interceptor()->did_simulate_error_main());
1619   EXPECT_TRUE(interceptor()->did_intercept_final());
1620
1621   // Check that we received one good response.
1622   EXPECT_TRUE(req->status().is_success());
1623   EXPECT_EQ(200, req->response_headers()->response_code());
1624   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
1625   EXPECT_EQ(1, d.response_started_count());
1626   EXPECT_EQ(0, d.received_redirect_count());
1627 }
1628
1629 TEST_F(URLRequestInterceptorTest, InterceptRestartRequired) {
1630   // Restart the main request.
1631   interceptor()->set_restart_main_request(true);
1632
1633   // then intercept the new main request and respond with an OK response
1634   interceptor()->set_intercept_main_request(true);
1635   interceptor()->set_main_headers(MockURLRequestInterceptor::ok_headers());
1636   interceptor()->set_main_data(MockURLRequestInterceptor::ok_data());
1637
1638   TestDelegate d;
1639   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1640       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1641   req->set_method("GET");
1642   req->Start();
1643   base::RunLoop().Run();
1644
1645   // Check that the interceptor got called as expected.
1646   EXPECT_TRUE(interceptor()->did_restart_main());
1647   EXPECT_TRUE(interceptor()->did_intercept_main());
1648
1649   // Check that we received one good response.
1650   EXPECT_TRUE(req->status().is_success());
1651   if (req->status().is_success())
1652     EXPECT_EQ(200, req->response_headers()->response_code());
1653
1654   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
1655   EXPECT_EQ(1, d.response_started_count());
1656   EXPECT_EQ(0, d.received_redirect_count());
1657 }
1658
1659 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelMain) {
1660   // Intercept the main request and cancel from within the restarted job.
1661   interceptor()->set_cancel_main_request(true);
1662
1663   // Set up to intercept the final response and override it with an OK response.
1664   interceptor()->set_intercept_final_response(true);
1665   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
1666   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
1667
1668   TestDelegate d;
1669   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1670       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1671   req->set_method("GET");
1672   req->Start();
1673   base::RunLoop().Run();
1674
1675   // Check that the interceptor got called as expected.
1676   EXPECT_TRUE(interceptor()->did_cancel_main());
1677   EXPECT_FALSE(interceptor()->did_intercept_final());
1678
1679   // Check that we see a canceled request.
1680   EXPECT_FALSE(req->status().is_success());
1681   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
1682 }
1683
1684 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelRedirect) {
1685   // Intercept the main request and respond with a redirect.
1686   interceptor()->set_intercept_main_request(true);
1687   interceptor()->set_main_headers(
1688       MockURLRequestInterceptor::redirect_headers());
1689   interceptor()->set_main_data(MockURLRequestInterceptor::redirect_data());
1690
1691   // Intercept the redirect and cancel from within that job.
1692   interceptor()->set_cancel_redirect_request(true);
1693
1694   // Set up to intercept the final response and override it with an OK response.
1695   interceptor()->set_intercept_final_response(true);
1696   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
1697   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
1698
1699   TestDelegate d;
1700   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1701       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1702   req->set_method("GET");
1703   req->Start();
1704   base::RunLoop().Run();
1705
1706   // Check that the interceptor got called as expected.
1707   EXPECT_TRUE(interceptor()->did_intercept_main());
1708   EXPECT_TRUE(interceptor()->did_cancel_redirect());
1709   EXPECT_FALSE(interceptor()->did_intercept_final());
1710
1711   // Check that we see a canceled request.
1712   EXPECT_FALSE(req->status().is_success());
1713   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
1714 }
1715
1716 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelFinal) {
1717   // Intercept the main request to simulate a network error.
1718   interceptor()->set_simulate_main_network_error(true);
1719
1720   // Set up to intercept final the response and cancel from within that job.
1721   interceptor()->set_cancel_final_request(true);
1722
1723   TestDelegate d;
1724   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1725       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1726   req->set_method("GET");
1727   req->Start();
1728   base::RunLoop().Run();
1729
1730   // Check that the interceptor got called as expected.
1731   EXPECT_TRUE(interceptor()->did_simulate_error_main());
1732   EXPECT_TRUE(interceptor()->did_cancel_final());
1733
1734   // Check that we see a canceled request.
1735   EXPECT_FALSE(req->status().is_success());
1736   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
1737 }
1738
1739 TEST_F(URLRequestInterceptorTest, InterceptRespectsCancelInRestart) {
1740   // Intercept the main request and cancel then restart from within that job.
1741   interceptor()->set_cancel_then_restart_main_request(true);
1742
1743   // Set up to intercept the final response and override it with an OK response.
1744   interceptor()->set_intercept_final_response(true);
1745   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
1746   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
1747
1748   TestDelegate d;
1749   scoped_ptr<URLRequest> req(default_context().CreateRequest(
1750       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1751   req->set_method("GET");
1752   req->Start();
1753   base::RunLoop().Run();
1754
1755   // Check that the interceptor got called as expected.
1756   EXPECT_TRUE(interceptor()->did_cancel_then_restart_main());
1757   EXPECT_FALSE(interceptor()->did_intercept_final());
1758
1759   // Check that we see a canceled request.
1760   EXPECT_FALSE(req->status().is_success());
1761   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
1762 }
1763
1764 // "Normal" LoadTimingInfo as returned by a job.  Everything is in order, not
1765 // reused.  |connect_time_flags| is used to indicate if there should be dns
1766 // or SSL times, and |used_proxy| is used for proxy times.
1767 LoadTimingInfo NormalLoadTimingInfo(base::TimeTicks now,
1768                                     int connect_time_flags,
1769                                     bool used_proxy) {
1770   LoadTimingInfo load_timing;
1771   load_timing.socket_log_id = 1;
1772
1773   if (used_proxy) {
1774     load_timing.proxy_resolve_start = now + base::TimeDelta::FromDays(1);
1775     load_timing.proxy_resolve_end = now + base::TimeDelta::FromDays(2);
1776   }
1777
1778   LoadTimingInfo::ConnectTiming& connect_timing = load_timing.connect_timing;
1779   if (connect_time_flags & CONNECT_TIMING_HAS_DNS_TIMES) {
1780     connect_timing.dns_start = now + base::TimeDelta::FromDays(3);
1781     connect_timing.dns_end = now + base::TimeDelta::FromDays(4);
1782   }
1783   connect_timing.connect_start = now + base::TimeDelta::FromDays(5);
1784   if (connect_time_flags & CONNECT_TIMING_HAS_SSL_TIMES) {
1785     connect_timing.ssl_start = now + base::TimeDelta::FromDays(6);
1786     connect_timing.ssl_end = now + base::TimeDelta::FromDays(7);
1787   }
1788   connect_timing.connect_end = now + base::TimeDelta::FromDays(8);
1789
1790   load_timing.send_start = now + base::TimeDelta::FromDays(9);
1791   load_timing.send_end = now + base::TimeDelta::FromDays(10);
1792   load_timing.receive_headers_end = now + base::TimeDelta::FromDays(11);
1793   return load_timing;
1794 }
1795
1796 // Same as above, but in the case of a reused socket.
1797 LoadTimingInfo NormalLoadTimingInfoReused(base::TimeTicks now,
1798                                           bool used_proxy) {
1799   LoadTimingInfo load_timing;
1800   load_timing.socket_log_id = 1;
1801   load_timing.socket_reused = true;
1802
1803   if (used_proxy) {
1804     load_timing.proxy_resolve_start = now + base::TimeDelta::FromDays(1);
1805     load_timing.proxy_resolve_end = now + base::TimeDelta::FromDays(2);
1806   }
1807
1808   load_timing.send_start = now + base::TimeDelta::FromDays(9);
1809   load_timing.send_end = now + base::TimeDelta::FromDays(10);
1810   load_timing.receive_headers_end = now + base::TimeDelta::FromDays(11);
1811   return load_timing;
1812 }
1813
1814 LoadTimingInfo RunURLRequestInterceptorLoadTimingTest(
1815     const LoadTimingInfo& job_load_timing,
1816     const URLRequestContext& context,
1817     MockURLRequestInterceptor* interceptor) {
1818   interceptor->set_intercept_main_request(true);
1819   interceptor->set_main_request_load_timing_info(job_load_timing);
1820   TestDelegate d;
1821   scoped_ptr<URLRequest> req(context.CreateRequest(
1822       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
1823   req->Start();
1824   base::RunLoop().Run();
1825
1826   LoadTimingInfo resulting_load_timing;
1827   req->GetLoadTimingInfo(&resulting_load_timing);
1828
1829   // None of these should be modified by the URLRequest.
1830   EXPECT_EQ(job_load_timing.socket_reused, resulting_load_timing.socket_reused);
1831   EXPECT_EQ(job_load_timing.socket_log_id, resulting_load_timing.socket_log_id);
1832   EXPECT_EQ(job_load_timing.send_start, resulting_load_timing.send_start);
1833   EXPECT_EQ(job_load_timing.send_end, resulting_load_timing.send_end);
1834   EXPECT_EQ(job_load_timing.receive_headers_end,
1835             resulting_load_timing.receive_headers_end);
1836
1837   return resulting_load_timing;
1838 }
1839
1840 // Basic test that the intercept + load timing tests work.
1841 TEST_F(URLRequestInterceptorTest, InterceptLoadTiming) {
1842   base::TimeTicks now = base::TimeTicks::Now();
1843   LoadTimingInfo job_load_timing =
1844       NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_DNS_TIMES, false);
1845
1846   LoadTimingInfo load_timing_result =
1847       RunURLRequestInterceptorLoadTimingTest(
1848           job_load_timing, default_context(), interceptor());
1849
1850   // Nothing should have been changed by the URLRequest.
1851   EXPECT_EQ(job_load_timing.proxy_resolve_start,
1852             load_timing_result.proxy_resolve_start);
1853   EXPECT_EQ(job_load_timing.proxy_resolve_end,
1854             load_timing_result.proxy_resolve_end);
1855   EXPECT_EQ(job_load_timing.connect_timing.dns_start,
1856             load_timing_result.connect_timing.dns_start);
1857   EXPECT_EQ(job_load_timing.connect_timing.dns_end,
1858             load_timing_result.connect_timing.dns_end);
1859   EXPECT_EQ(job_load_timing.connect_timing.connect_start,
1860             load_timing_result.connect_timing.connect_start);
1861   EXPECT_EQ(job_load_timing.connect_timing.connect_end,
1862             load_timing_result.connect_timing.connect_end);
1863   EXPECT_EQ(job_load_timing.connect_timing.ssl_start,
1864             load_timing_result.connect_timing.ssl_start);
1865   EXPECT_EQ(job_load_timing.connect_timing.ssl_end,
1866             load_timing_result.connect_timing.ssl_end);
1867
1868   // Redundant sanity check.
1869   TestLoadTimingNotReused(load_timing_result, CONNECT_TIMING_HAS_DNS_TIMES);
1870 }
1871
1872 // Another basic test, with proxy and SSL times, but no DNS times.
1873 TEST_F(URLRequestInterceptorTest, InterceptLoadTimingProxy) {
1874   base::TimeTicks now = base::TimeTicks::Now();
1875   LoadTimingInfo job_load_timing =
1876       NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_SSL_TIMES, true);
1877
1878   LoadTimingInfo load_timing_result =
1879       RunURLRequestInterceptorLoadTimingTest(
1880           job_load_timing, default_context(), interceptor());
1881
1882   // Nothing should have been changed by the URLRequest.
1883   EXPECT_EQ(job_load_timing.proxy_resolve_start,
1884             load_timing_result.proxy_resolve_start);
1885   EXPECT_EQ(job_load_timing.proxy_resolve_end,
1886             load_timing_result.proxy_resolve_end);
1887   EXPECT_EQ(job_load_timing.connect_timing.dns_start,
1888             load_timing_result.connect_timing.dns_start);
1889   EXPECT_EQ(job_load_timing.connect_timing.dns_end,
1890             load_timing_result.connect_timing.dns_end);
1891   EXPECT_EQ(job_load_timing.connect_timing.connect_start,
1892             load_timing_result.connect_timing.connect_start);
1893   EXPECT_EQ(job_load_timing.connect_timing.connect_end,
1894             load_timing_result.connect_timing.connect_end);
1895   EXPECT_EQ(job_load_timing.connect_timing.ssl_start,
1896             load_timing_result.connect_timing.ssl_start);
1897   EXPECT_EQ(job_load_timing.connect_timing.ssl_end,
1898             load_timing_result.connect_timing.ssl_end);
1899
1900   // Redundant sanity check.
1901   TestLoadTimingNotReusedWithProxy(load_timing_result,
1902                                    CONNECT_TIMING_HAS_SSL_TIMES);
1903 }
1904
1905 // Make sure that URLRequest correctly adjusts proxy times when they're before
1906 // |request_start|, due to already having a connected socket.  This happens in
1907 // the case of reusing a SPDY session.  The connected socket is not considered
1908 // reused in this test (May be a preconnect).
1909 //
1910 // To mix things up from the test above, assumes DNS times but no SSL times.
1911 TEST_F(URLRequestInterceptorTest, InterceptLoadTimingEarlyProxyResolution) {
1912   base::TimeTicks now = base::TimeTicks::Now();
1913   LoadTimingInfo job_load_timing =
1914       NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_DNS_TIMES, true);
1915   job_load_timing.proxy_resolve_start = now - base::TimeDelta::FromDays(6);
1916   job_load_timing.proxy_resolve_end = now - base::TimeDelta::FromDays(5);
1917   job_load_timing.connect_timing.dns_start = now - base::TimeDelta::FromDays(4);
1918   job_load_timing.connect_timing.dns_end = now - base::TimeDelta::FromDays(3);
1919   job_load_timing.connect_timing.connect_start =
1920       now - base::TimeDelta::FromDays(2);
1921   job_load_timing.connect_timing.connect_end =
1922       now - base::TimeDelta::FromDays(1);
1923
1924   LoadTimingInfo load_timing_result =
1925       RunURLRequestInterceptorLoadTimingTest(
1926           job_load_timing, default_context(), interceptor());
1927
1928   // Proxy times, connect times, and DNS times should all be replaced with
1929   // request_start.
1930   EXPECT_EQ(load_timing_result.request_start,
1931             load_timing_result.proxy_resolve_start);
1932   EXPECT_EQ(load_timing_result.request_start,
1933             load_timing_result.proxy_resolve_end);
1934   EXPECT_EQ(load_timing_result.request_start,
1935             load_timing_result.connect_timing.dns_start);
1936   EXPECT_EQ(load_timing_result.request_start,
1937             load_timing_result.connect_timing.dns_end);
1938   EXPECT_EQ(load_timing_result.request_start,
1939             load_timing_result.connect_timing.connect_start);
1940   EXPECT_EQ(load_timing_result.request_start,
1941             load_timing_result.connect_timing.connect_end);
1942
1943   // Other times should have been left null.
1944   TestLoadTimingNotReusedWithProxy(load_timing_result,
1945                                    CONNECT_TIMING_HAS_DNS_TIMES);
1946 }
1947
1948 // Same as above, but in the reused case.
1949 TEST_F(URLRequestInterceptorTest,
1950        InterceptLoadTimingEarlyProxyResolutionReused) {
1951   base::TimeTicks now = base::TimeTicks::Now();
1952   LoadTimingInfo job_load_timing = NormalLoadTimingInfoReused(now, true);
1953   job_load_timing.proxy_resolve_start = now - base::TimeDelta::FromDays(4);
1954   job_load_timing.proxy_resolve_end = now - base::TimeDelta::FromDays(3);
1955
1956   LoadTimingInfo load_timing_result =
1957       RunURLRequestInterceptorLoadTimingTest(
1958           job_load_timing, default_context(), interceptor());
1959
1960   // Proxy times and connect times should all be replaced with request_start.
1961   EXPECT_EQ(load_timing_result.request_start,
1962             load_timing_result.proxy_resolve_start);
1963   EXPECT_EQ(load_timing_result.request_start,
1964             load_timing_result.proxy_resolve_end);
1965
1966   // Other times should have been left null.
1967   TestLoadTimingReusedWithProxy(load_timing_result);
1968 }
1969
1970 // Make sure that URLRequest correctly adjusts connect times when they're before
1971 // |request_start|, due to reusing a connected socket.  The connected socket is
1972 // not considered reused in this test (May be a preconnect).
1973 //
1974 // To mix things up, the request has SSL times, but no DNS times.
1975 TEST_F(URLRequestInterceptorTest, InterceptLoadTimingEarlyConnect) {
1976   base::TimeTicks now = base::TimeTicks::Now();
1977   LoadTimingInfo job_load_timing =
1978       NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_SSL_TIMES, false);
1979   job_load_timing.connect_timing.connect_start =
1980       now - base::TimeDelta::FromDays(1);
1981   job_load_timing.connect_timing.ssl_start = now - base::TimeDelta::FromDays(2);
1982   job_load_timing.connect_timing.ssl_end = now - base::TimeDelta::FromDays(3);
1983   job_load_timing.connect_timing.connect_end =
1984       now - base::TimeDelta::FromDays(4);
1985
1986   LoadTimingInfo load_timing_result =
1987       RunURLRequestInterceptorLoadTimingTest(
1988           job_load_timing, default_context(), interceptor());
1989
1990   // Connect times, and SSL times should be replaced with request_start.
1991   EXPECT_EQ(load_timing_result.request_start,
1992             load_timing_result.connect_timing.connect_start);
1993   EXPECT_EQ(load_timing_result.request_start,
1994             load_timing_result.connect_timing.ssl_start);
1995   EXPECT_EQ(load_timing_result.request_start,
1996             load_timing_result.connect_timing.ssl_end);
1997   EXPECT_EQ(load_timing_result.request_start,
1998             load_timing_result.connect_timing.connect_end);
1999
2000   // Other times should have been left null.
2001   TestLoadTimingNotReused(load_timing_result, CONNECT_TIMING_HAS_SSL_TIMES);
2002 }
2003
2004 // Make sure that URLRequest correctly adjusts connect times when they're before
2005 // |request_start|, due to reusing a connected socket in the case that there
2006 // are also proxy times.  The connected socket is not considered reused in this
2007 // test (May be a preconnect).
2008 //
2009 // In this test, there are no SSL or DNS times.
2010 TEST_F(URLRequestInterceptorTest, InterceptLoadTimingEarlyConnectWithProxy) {
2011   base::TimeTicks now = base::TimeTicks::Now();
2012   LoadTimingInfo job_load_timing =
2013       NormalLoadTimingInfo(now, CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY, true);
2014   job_load_timing.connect_timing.connect_start =
2015       now - base::TimeDelta::FromDays(1);
2016   job_load_timing.connect_timing.connect_end =
2017       now - base::TimeDelta::FromDays(2);
2018
2019   LoadTimingInfo load_timing_result =
2020       RunURLRequestInterceptorLoadTimingTest(
2021           job_load_timing, default_context(), interceptor());
2022
2023   // Connect times should be replaced with proxy_resolve_end.
2024   EXPECT_EQ(load_timing_result.proxy_resolve_end,
2025             load_timing_result.connect_timing.connect_start);
2026   EXPECT_EQ(load_timing_result.proxy_resolve_end,
2027             load_timing_result.connect_timing.connect_end);
2028
2029   // Other times should have been left null.
2030   TestLoadTimingNotReusedWithProxy(load_timing_result,
2031                                    CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
2032 }
2033
2034 // Check that two different URL requests have different identifiers.
2035 TEST_F(URLRequestTest, Identifiers) {
2036   TestDelegate d;
2037   TestURLRequestContext context;
2038   scoped_ptr<URLRequest> req(
2039       context.CreateRequest(GURL("http://example.com"), DEFAULT_PRIORITY, &d));
2040   scoped_ptr<URLRequest> other_req(
2041       context.CreateRequest(GURL("http://example.com"), DEFAULT_PRIORITY, &d));
2042
2043   ASSERT_NE(req->identifier(), other_req->identifier());
2044 }
2045
2046 // Check that a failure to connect to the proxy is reported to the network
2047 // delegate.
2048 TEST_F(URLRequestTest, NetworkDelegateProxyError) {
2049   MockHostResolver host_resolver;
2050   host_resolver.rules()->AddSimulatedFailure("*");
2051
2052   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
2053   TestURLRequestContextWithProxy context("myproxy:70", &network_delegate);
2054
2055   TestDelegate d;
2056   scoped_ptr<URLRequest> req(
2057       context.CreateRequest(GURL("http://example.com"), DEFAULT_PRIORITY, &d));
2058   req->set_method("GET");
2059
2060   req->Start();
2061   base::RunLoop().Run();
2062
2063   // Check we see a failed request.
2064   EXPECT_FALSE(req->status().is_success());
2065   // The proxy server is not set before failure.
2066   EXPECT_TRUE(req->proxy_server().IsEmpty());
2067   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
2068   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, req->status().error());
2069
2070   EXPECT_EQ(1, network_delegate.error_count());
2071   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, network_delegate.last_error());
2072   EXPECT_EQ(1, network_delegate.completed_requests());
2073 }
2074
2075 // Make sure that NetworkDelegate::NotifyCompleted is called if
2076 // content is empty.
2077 TEST_F(URLRequestTest, RequestCompletionForEmptyResponse) {
2078   TestDelegate d;
2079   scoped_ptr<URLRequest> req(
2080       default_context_.CreateRequest(GURL("data:,"), DEFAULT_PRIORITY, &d));
2081   req->Start();
2082   base::RunLoop().Run();
2083   EXPECT_EQ("", d.data_received());
2084   EXPECT_EQ(1, default_network_delegate_.completed_requests());
2085 }
2086
2087 // Make sure that SetPriority actually sets the URLRequest's priority
2088 // correctly, both before and after start.
2089 TEST_F(URLRequestTest, SetPriorityBasic) {
2090   TestDelegate d;
2091   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2092       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
2093   EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
2094
2095   req->SetPriority(LOW);
2096   EXPECT_EQ(LOW, req->priority());
2097
2098   req->Start();
2099   EXPECT_EQ(LOW, req->priority());
2100
2101   req->SetPriority(MEDIUM);
2102   EXPECT_EQ(MEDIUM, req->priority());
2103 }
2104
2105 // Make sure that URLRequest calls SetPriority on a job before calling
2106 // Start on it.
2107 TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) {
2108   TestDelegate d;
2109   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2110       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
2111   EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
2112
2113   scoped_refptr<URLRequestTestJob> job =
2114       new URLRequestTestJob(req.get(), &default_network_delegate_);
2115   AddTestInterceptor()->set_main_intercept_job(job.get());
2116   EXPECT_EQ(DEFAULT_PRIORITY, job->priority());
2117
2118   req->SetPriority(LOW);
2119
2120   req->Start();
2121   EXPECT_EQ(LOW, job->priority());
2122 }
2123
2124 // Make sure that URLRequest passes on its priority updates to its
2125 // job.
2126 TEST_F(URLRequestTest, SetJobPriority) {
2127   TestDelegate d;
2128   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2129       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
2130
2131   scoped_refptr<URLRequestTestJob> job =
2132       new URLRequestTestJob(req.get(), &default_network_delegate_);
2133   AddTestInterceptor()->set_main_intercept_job(job.get());
2134
2135   req->SetPriority(LOW);
2136   req->Start();
2137   EXPECT_EQ(LOW, job->priority());
2138
2139   req->SetPriority(MEDIUM);
2140   EXPECT_EQ(MEDIUM, req->priority());
2141   EXPECT_EQ(MEDIUM, job->priority());
2142 }
2143
2144 // Setting the IGNORE_LIMITS load flag should be okay if the priority
2145 // is MAXIMUM_PRIORITY.
2146 TEST_F(URLRequestTest, PriorityIgnoreLimits) {
2147   TestDelegate d;
2148   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2149       GURL("http://test_intercept/foo"), MAXIMUM_PRIORITY, &d));
2150   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
2151
2152   scoped_refptr<URLRequestTestJob> job =
2153       new URLRequestTestJob(req.get(), &default_network_delegate_);
2154   AddTestInterceptor()->set_main_intercept_job(job.get());
2155
2156   req->SetLoadFlags(LOAD_IGNORE_LIMITS);
2157   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
2158
2159   req->SetPriority(MAXIMUM_PRIORITY);
2160   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
2161
2162   req->Start();
2163   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
2164   EXPECT_EQ(MAXIMUM_PRIORITY, job->priority());
2165 }
2166
2167 // TODO(droger): Support SpawnedTestServer on iOS (see http://crbug.com/148666).
2168 #if !defined(OS_IOS)
2169 namespace {
2170
2171 // Less verbose way of running a simple testserver for the tests below.
2172 class LocalHttpTestServer : public SpawnedTestServer {
2173  public:
2174   explicit LocalHttpTestServer(const base::FilePath& document_root)
2175       : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
2176                           SpawnedTestServer::kLocalhost,
2177                           document_root) {}
2178   LocalHttpTestServer()
2179       : SpawnedTestServer(SpawnedTestServer::TYPE_HTTP,
2180                           SpawnedTestServer::kLocalhost,
2181                           base::FilePath()) {}
2182 };
2183
2184 }  // namespace
2185
2186 TEST_F(URLRequestTest, DelayedCookieCallback) {
2187   LocalHttpTestServer test_server;
2188   ASSERT_TRUE(test_server.Start());
2189
2190   TestURLRequestContext context;
2191   scoped_refptr<DelayedCookieMonster> delayed_cm =
2192       new DelayedCookieMonster();
2193   scoped_refptr<CookieStore> cookie_store = delayed_cm;
2194   context.set_cookie_store(delayed_cm.get());
2195
2196   // Set up a cookie.
2197   {
2198     TestNetworkDelegate network_delegate;
2199     context.set_network_delegate(&network_delegate);
2200     TestDelegate d;
2201     scoped_ptr<URLRequest> req(context.CreateRequest(
2202         test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
2203         &d));
2204     req->Start();
2205     base::RunLoop().Run();
2206     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2207     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2208     EXPECT_EQ(1, network_delegate.set_cookie_count());
2209   }
2210
2211   // Verify that the cookie is set.
2212   {
2213     TestNetworkDelegate network_delegate;
2214     context.set_network_delegate(&network_delegate);
2215     TestDelegate d;
2216     scoped_ptr<URLRequest> req(context.CreateRequest(
2217         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2218     req->Start();
2219     base::RunLoop().Run();
2220
2221     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
2222                 != std::string::npos);
2223     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2224     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2225   }
2226 }
2227
2228 TEST_F(URLRequestTest, DoNotSendCookies) {
2229   LocalHttpTestServer test_server;
2230   ASSERT_TRUE(test_server.Start());
2231
2232   // Set up a cookie.
2233   {
2234     TestNetworkDelegate network_delegate;
2235     default_context_.set_network_delegate(&network_delegate);
2236     TestDelegate d;
2237     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2238         test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
2239         &d));
2240     req->Start();
2241     base::RunLoop().Run();
2242     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2243     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2244   }
2245
2246   // Verify that the cookie is set.
2247   {
2248     TestNetworkDelegate network_delegate;
2249     default_context_.set_network_delegate(&network_delegate);
2250     TestDelegate d;
2251     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2252         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2253     req->Start();
2254     base::RunLoop().Run();
2255
2256     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
2257                 != std::string::npos);
2258     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2259     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2260   }
2261
2262   // Verify that the cookie isn't sent when LOAD_DO_NOT_SEND_COOKIES is set.
2263   {
2264     TestNetworkDelegate network_delegate;
2265     default_context_.set_network_delegate(&network_delegate);
2266     TestDelegate d;
2267     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2268         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2269     req->SetLoadFlags(LOAD_DO_NOT_SEND_COOKIES);
2270     req->Start();
2271     base::RunLoop().Run();
2272
2273     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
2274                 == std::string::npos);
2275
2276     // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
2277     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2278     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2279   }
2280 }
2281
2282 TEST_F(URLRequestTest, DoNotSaveCookies) {
2283   LocalHttpTestServer test_server;
2284   ASSERT_TRUE(test_server.Start());
2285
2286   // Set up a cookie.
2287   {
2288     TestNetworkDelegate network_delegate;
2289     default_context_.set_network_delegate(&network_delegate);
2290     TestDelegate d;
2291     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2292         test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
2293         &d));
2294     req->Start();
2295     base::RunLoop().Run();
2296
2297     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2298     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2299     EXPECT_EQ(1, network_delegate.set_cookie_count());
2300   }
2301
2302   // Try to set-up another cookie and update the previous cookie.
2303   {
2304     TestNetworkDelegate network_delegate;
2305     default_context_.set_network_delegate(&network_delegate);
2306     TestDelegate d;
2307     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2308         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
2309         DEFAULT_PRIORITY, &d));
2310     req->SetLoadFlags(LOAD_DO_NOT_SAVE_COOKIES);
2311     req->Start();
2312
2313     base::RunLoop().Run();
2314
2315     // LOAD_DO_NOT_SAVE_COOKIES does not trigger OnSetCookie.
2316     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2317     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2318     EXPECT_EQ(0, network_delegate.set_cookie_count());
2319   }
2320
2321   // Verify the cookies weren't saved or updated.
2322   {
2323     TestNetworkDelegate network_delegate;
2324     default_context_.set_network_delegate(&network_delegate);
2325     TestDelegate d;
2326     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2327         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2328     req->Start();
2329     base::RunLoop().Run();
2330
2331     EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
2332                 == std::string::npos);
2333     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
2334                 != std::string::npos);
2335
2336     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2337     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2338     EXPECT_EQ(0, network_delegate.set_cookie_count());
2339   }
2340 }
2341
2342 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
2343   LocalHttpTestServer test_server;
2344   ASSERT_TRUE(test_server.Start());
2345
2346   // Set up a cookie.
2347   {
2348     TestNetworkDelegate network_delegate;
2349     default_context_.set_network_delegate(&network_delegate);
2350     TestDelegate d;
2351     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2352         test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
2353         &d));
2354     req->Start();
2355     base::RunLoop().Run();
2356
2357     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2358     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2359   }
2360
2361   // Verify that the cookie is set.
2362   {
2363     TestNetworkDelegate network_delegate;
2364     default_context_.set_network_delegate(&network_delegate);
2365     TestDelegate d;
2366     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2367         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2368     req->Start();
2369     base::RunLoop().Run();
2370
2371     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
2372                 != std::string::npos);
2373
2374     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2375     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2376   }
2377
2378   // Verify that the cookie isn't sent.
2379   {
2380     TestNetworkDelegate network_delegate;
2381     default_context_.set_network_delegate(&network_delegate);
2382     TestDelegate d;
2383     network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
2384     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2385         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2386     req->Start();
2387     base::RunLoop().Run();
2388
2389     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
2390                 == std::string::npos);
2391
2392     EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
2393     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2394   }
2395 }
2396
2397 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
2398   LocalHttpTestServer test_server;
2399   ASSERT_TRUE(test_server.Start());
2400
2401   // Set up a cookie.
2402   {
2403     TestNetworkDelegate network_delegate;
2404     default_context_.set_network_delegate(&network_delegate);
2405     TestDelegate d;
2406     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2407         test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
2408         &d));
2409     req->Start();
2410     base::RunLoop().Run();
2411
2412     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2413     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2414   }
2415
2416   // Try to set-up another cookie and update the previous cookie.
2417   {
2418     TestNetworkDelegate network_delegate;
2419     default_context_.set_network_delegate(&network_delegate);
2420     TestDelegate d;
2421     network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE);
2422     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2423         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
2424         DEFAULT_PRIORITY, &d));
2425     req->Start();
2426
2427     base::RunLoop().Run();
2428
2429     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2430     EXPECT_EQ(2, network_delegate.blocked_set_cookie_count());
2431   }
2432
2433   // Verify the cookies weren't saved or updated.
2434   {
2435     TestNetworkDelegate network_delegate;
2436     default_context_.set_network_delegate(&network_delegate);
2437     TestDelegate d;
2438     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2439         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2440     req->Start();
2441     base::RunLoop().Run();
2442
2443     EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
2444                 == std::string::npos);
2445     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
2446                 != std::string::npos);
2447
2448     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2449     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2450   }
2451 }
2452
2453 TEST_F(URLRequestTest, DoNotSaveEmptyCookies) {
2454   LocalHttpTestServer test_server;
2455   ASSERT_TRUE(test_server.Start());
2456
2457   // Set up an empty cookie.
2458   {
2459     TestNetworkDelegate network_delegate;
2460     default_context_.set_network_delegate(&network_delegate);
2461     TestDelegate d;
2462     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2463         test_server.GetURL("set-cookie"), DEFAULT_PRIORITY, &d));
2464     req->Start();
2465     base::RunLoop().Run();
2466
2467     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2468     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2469     EXPECT_EQ(0, network_delegate.set_cookie_count());
2470   }
2471 }
2472
2473 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) {
2474   LocalHttpTestServer test_server;
2475   ASSERT_TRUE(test_server.Start());
2476
2477   // Set up a cookie.
2478   {
2479     TestNetworkDelegate network_delegate;
2480     default_context_.set_network_delegate(&network_delegate);
2481     TestDelegate d;
2482     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2483         test_server.GetURL("set-cookie?CookieToNotSend=1"), DEFAULT_PRIORITY,
2484         &d));
2485     req->Start();
2486     base::RunLoop().Run();
2487
2488     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2489     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2490   }
2491
2492   // Verify that the cookie is set.
2493   {
2494     TestNetworkDelegate network_delegate;
2495     default_context_.set_network_delegate(&network_delegate);
2496     TestDelegate d;
2497     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2498         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2499     req->Start();
2500     base::RunLoop().Run();
2501
2502     EXPECT_TRUE(d.data_received().find("CookieToNotSend=1")
2503                 != std::string::npos);
2504
2505     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2506     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2507   }
2508
2509   // Verify that the cookie isn't sent.
2510   {
2511     TestNetworkDelegate network_delegate;
2512     default_context_.set_network_delegate(&network_delegate);
2513     TestDelegate d;
2514     network_delegate.set_cookie_options(TestNetworkDelegate::NO_GET_COOKIES);
2515     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2516         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2517     req->Start();
2518     base::RunLoop().Run();
2519
2520     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
2521                 == std::string::npos);
2522
2523     EXPECT_EQ(1, network_delegate.blocked_get_cookies_count());
2524     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2525   }
2526 }
2527
2528 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
2529   LocalHttpTestServer test_server;
2530   ASSERT_TRUE(test_server.Start());
2531
2532   // Set up a cookie.
2533   {
2534     TestNetworkDelegate network_delegate;
2535     default_context_.set_network_delegate(&network_delegate);
2536     TestDelegate d;
2537     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2538         test_server.GetURL("set-cookie?CookieToNotUpdate=2"), DEFAULT_PRIORITY,
2539         &d));
2540     req->Start();
2541     base::RunLoop().Run();
2542
2543     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2544     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2545   }
2546
2547   // Try to set-up another cookie and update the previous cookie.
2548   {
2549     TestNetworkDelegate network_delegate;
2550     default_context_.set_network_delegate(&network_delegate);
2551     TestDelegate d;
2552     network_delegate.set_cookie_options(TestNetworkDelegate::NO_SET_COOKIE);
2553     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2554         test_server.GetURL("set-cookie?CookieToNotSave=1&CookieToNotUpdate=1"),
2555         DEFAULT_PRIORITY, &d));
2556     req->Start();
2557
2558     base::RunLoop().Run();
2559
2560     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2561     EXPECT_EQ(2, network_delegate.blocked_set_cookie_count());
2562   }
2563
2564   // Verify the cookies weren't saved or updated.
2565   {
2566     TestNetworkDelegate network_delegate;
2567     default_context_.set_network_delegate(&network_delegate);
2568     TestDelegate d;
2569     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2570         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2571     req->Start();
2572     base::RunLoop().Run();
2573
2574     EXPECT_TRUE(d.data_received().find("CookieToNotSave=1")
2575                 == std::string::npos);
2576     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
2577                 != std::string::npos);
2578
2579     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2580     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2581   }
2582 }
2583
2584 TEST_F(URLRequestTest, FirstPartyOnlyCookiesEnabled) {
2585   LocalHttpTestServer test_server;
2586   ASSERT_TRUE(test_server.Start());
2587
2588   // Set up a 'First-Party-Only' cookie (on '127.0.0.1', as that's where
2589   // LocalHttpTestServer points).
2590   {
2591     TestNetworkDelegate network_delegate;
2592     network_delegate.set_first_party_only_cookies_enabled(true);
2593     default_context_.set_network_delegate(&network_delegate);
2594
2595     TestDelegate d;
2596     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2597         test_server.GetURL(
2598             "set-cookie?FirstPartyCookieToSet=1;First-Party-Only"),
2599         DEFAULT_PRIORITY, &d));
2600     req->Start();
2601     base::RunLoop().Run();
2602     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2603     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2604     EXPECT_EQ(1, network_delegate.set_cookie_count());
2605   }
2606
2607   // Verify that the cookie is sent for first-party requests.
2608   {
2609     TestNetworkDelegate network_delegate;
2610     network_delegate.set_first_party_only_cookies_enabled(true);
2611     default_context_.set_network_delegate(&network_delegate);
2612     TestDelegate d;
2613     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2614         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2615     req->set_first_party_for_cookies(test_server.GetURL(""));
2616     req->Start();
2617     base::RunLoop().Run();
2618
2619     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") !=
2620                 std::string::npos);
2621     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2622     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2623   }
2624
2625   // Verify that the cookie is not-sent for non-first-party requests.
2626   {
2627     TestNetworkDelegate network_delegate;
2628     network_delegate.set_first_party_only_cookies_enabled(true);
2629     default_context_.set_network_delegate(&network_delegate);
2630     TestDelegate d;
2631     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2632         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2633     req->set_first_party_for_cookies(GURL("http://third-party.test/"));
2634     req->Start();
2635     base::RunLoop().Run();
2636
2637     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") ==
2638                 std::string::npos);
2639     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2640     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2641   }
2642 }
2643
2644 TEST_F(URLRequestTest, FirstPartyOnlyCookiesDisabled) {
2645   LocalHttpTestServer test_server;
2646   ASSERT_TRUE(test_server.Start());
2647
2648   // Set up a 'First-Party-Only' cookie (on '127.0.0.1', as that's where
2649   // LocalHttpTestServer points).
2650   {
2651     TestNetworkDelegate network_delegate;
2652     network_delegate.set_first_party_only_cookies_enabled(false);
2653     default_context_.set_network_delegate(&network_delegate);
2654
2655     TestDelegate d;
2656     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2657         test_server.GetURL(
2658             "set-cookie?FirstPartyCookieToSet=1;First-Party-Only"),
2659         DEFAULT_PRIORITY, &d));
2660     req->Start();
2661     base::RunLoop().Run();
2662     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2663     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2664     EXPECT_EQ(1, network_delegate.set_cookie_count());
2665   }
2666
2667   // Verify that the cookie is sent for first-party requests.
2668   {
2669     TestNetworkDelegate network_delegate;
2670     network_delegate.set_first_party_only_cookies_enabled(false);
2671     default_context_.set_network_delegate(&network_delegate);
2672     TestDelegate d;
2673     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2674         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2675     req->set_first_party_for_cookies(test_server.GetURL(""));
2676     req->Start();
2677     base::RunLoop().Run();
2678
2679     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") !=
2680                 std::string::npos);
2681     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2682     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2683   }
2684
2685   // Verify that the cookie is also sent for non-first-party requests.
2686   {
2687     TestNetworkDelegate network_delegate;
2688     network_delegate.set_first_party_only_cookies_enabled(false);
2689     default_context_.set_network_delegate(&network_delegate);
2690     TestDelegate d;
2691     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2692         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2693     req->set_first_party_for_cookies(GURL("http://third-party.test/"));
2694     req->Start();
2695     base::RunLoop().Run();
2696
2697     EXPECT_TRUE(d.data_received().find("FirstPartyCookieToSet=1") !=
2698                 std::string::npos);
2699     EXPECT_EQ(0, network_delegate.blocked_get_cookies_count());
2700     EXPECT_EQ(0, network_delegate.blocked_set_cookie_count());
2701   }
2702 }
2703
2704 // FixedDateNetworkDelegate swaps out the server's HTTP Date response header
2705 // value for the |fixed_date| argument given to the constructor.
2706 class FixedDateNetworkDelegate : public TestNetworkDelegate {
2707  public:
2708   explicit FixedDateNetworkDelegate(const std::string& fixed_date)
2709       : fixed_date_(fixed_date) {}
2710   ~FixedDateNetworkDelegate() override {}
2711
2712   // NetworkDelegate implementation
2713   int OnHeadersReceived(
2714       URLRequest* request,
2715       const CompletionCallback& callback,
2716       const HttpResponseHeaders* original_response_headers,
2717       scoped_refptr<HttpResponseHeaders>* override_response_headers,
2718       GURL* allowed_unsafe_redirect_url) override;
2719
2720  private:
2721   std::string fixed_date_;
2722
2723   DISALLOW_COPY_AND_ASSIGN(FixedDateNetworkDelegate);
2724 };
2725
2726 int FixedDateNetworkDelegate::OnHeadersReceived(
2727     URLRequest* request,
2728     const CompletionCallback& callback,
2729     const HttpResponseHeaders* original_response_headers,
2730     scoped_refptr<HttpResponseHeaders>* override_response_headers,
2731     GURL* allowed_unsafe_redirect_url) {
2732   HttpResponseHeaders* new_response_headers =
2733       new HttpResponseHeaders(original_response_headers->raw_headers());
2734
2735   new_response_headers->RemoveHeader("Date");
2736   new_response_headers->AddHeader("Date: " + fixed_date_);
2737
2738   *override_response_headers = new_response_headers;
2739   return TestNetworkDelegate::OnHeadersReceived(request,
2740                                                 callback,
2741                                                 original_response_headers,
2742                                                 override_response_headers,
2743                                                 allowed_unsafe_redirect_url);
2744 }
2745
2746 // Test that cookie expiration times are adjusted for server/client clock
2747 // skew and that we handle incorrect timezone specifier "UTC" in HTTP Date
2748 // headers by defaulting to GMT. (crbug.com/135131)
2749 TEST_F(URLRequestTest, AcceptClockSkewCookieWithWrongDateTimezone) {
2750   LocalHttpTestServer test_server;
2751   ASSERT_TRUE(test_server.Start());
2752
2753   // Set up an expired cookie.
2754   {
2755     TestNetworkDelegate network_delegate;
2756     default_context_.set_network_delegate(&network_delegate);
2757     TestDelegate d;
2758     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2759         test_server.GetURL(
2760             "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
2761         DEFAULT_PRIORITY, &d));
2762     req->Start();
2763     base::RunLoop().Run();
2764   }
2765   // Verify that the cookie is not set.
2766   {
2767     TestNetworkDelegate network_delegate;
2768     default_context_.set_network_delegate(&network_delegate);
2769     TestDelegate d;
2770     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2771         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2772     req->Start();
2773     base::RunLoop().Run();
2774
2775     EXPECT_TRUE(d.data_received().find("StillGood=1") == std::string::npos);
2776   }
2777   // Set up a cookie with clock skew and "UTC" HTTP Date timezone specifier.
2778   {
2779     FixedDateNetworkDelegate network_delegate("18-Apr-1977 22:49:13 UTC");
2780     default_context_.set_network_delegate(&network_delegate);
2781     TestDelegate d;
2782     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2783         test_server.GetURL(
2784             "set-cookie?StillGood=1;expires=Mon,18-Apr-1977,22:50:13,GMT"),
2785         DEFAULT_PRIORITY, &d));
2786     req->Start();
2787     base::RunLoop().Run();
2788   }
2789   // Verify that the cookie is set.
2790   {
2791     TestNetworkDelegate network_delegate;
2792     default_context_.set_network_delegate(&network_delegate);
2793     TestDelegate d;
2794     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2795         test_server.GetURL("echoheader?Cookie"), DEFAULT_PRIORITY, &d));
2796     req->Start();
2797     base::RunLoop().Run();
2798
2799     EXPECT_TRUE(d.data_received().find("StillGood=1") != std::string::npos);
2800   }
2801 }
2802
2803
2804 // Check that it is impossible to change the referrer in the extra headers of
2805 // an URLRequest.
2806 TEST_F(URLRequestTest, DoNotOverrideReferrer) {
2807   LocalHttpTestServer test_server;
2808   ASSERT_TRUE(test_server.Start());
2809
2810   // If extra headers contain referer and the request contains a referer,
2811   // only the latter shall be respected.
2812   {
2813     TestDelegate d;
2814     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2815         test_server.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
2816     req->SetReferrer("http://foo.com/");
2817
2818     HttpRequestHeaders headers;
2819     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
2820     req->SetExtraRequestHeaders(headers);
2821
2822     req->Start();
2823     base::RunLoop().Run();
2824
2825     EXPECT_EQ("http://foo.com/", d.data_received());
2826   }
2827
2828   // If extra headers contain a referer but the request does not, no referer
2829   // shall be sent in the header.
2830   {
2831     TestDelegate d;
2832     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
2833         test_server.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
2834
2835     HttpRequestHeaders headers;
2836     headers.SetHeader(HttpRequestHeaders::kReferer, "http://bar.com/");
2837     req->SetExtraRequestHeaders(headers);
2838     req->SetLoadFlags(LOAD_VALIDATE_CACHE);
2839
2840     req->Start();
2841     base::RunLoop().Run();
2842
2843     EXPECT_EQ("None", d.data_received());
2844   }
2845 }
2846
2847 class URLRequestTestHTTP : public URLRequestTest {
2848  public:
2849   URLRequestTestHTTP() : test_server_(base::FilePath(kTestFilePath)) {}
2850
2851  protected:
2852   // Requests |redirect_url|, which must return a HTTP 3xx redirect.
2853   // |request_method| is the method to use for the initial request.
2854   // |redirect_method| is the method that is expected to be used for the second
2855   // request, after redirection.
2856   // If |include_data| is true, data is uploaded with the request.  The
2857   // response body is expected to match it exactly, if and only if
2858   // |request_method| == |redirect_method|.
2859   void HTTPRedirectMethodTest(const GURL& redirect_url,
2860                               const std::string& request_method,
2861                               const std::string& redirect_method,
2862                               bool include_data) {
2863     static const char kData[] = "hello world";
2864     TestDelegate d;
2865     scoped_ptr<URLRequest> req(
2866         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
2867     req->set_method(request_method);
2868     if (include_data) {
2869       req->set_upload(CreateSimpleUploadData(kData));
2870       HttpRequestHeaders headers;
2871       headers.SetHeader(HttpRequestHeaders::kContentLength,
2872                         base::SizeTToString(arraysize(kData) - 1));
2873       req->SetExtraRequestHeaders(headers);
2874     }
2875     req->Start();
2876     base::RunLoop().Run();
2877     EXPECT_EQ(redirect_method, req->method());
2878     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
2879     EXPECT_EQ(OK, req->status().error());
2880     if (include_data) {
2881       if (request_method == redirect_method) {
2882         EXPECT_EQ(kData, d.data_received());
2883       } else {
2884         EXPECT_NE(kData, d.data_received());
2885       }
2886     }
2887     if (HasFailure())
2888       LOG(WARNING) << "Request method was: " << request_method;
2889   }
2890
2891   // Requests |redirect_url|, which must return a HTTP 3xx redirect.
2892   // |request_method| is the method to use for the initial request.
2893   // |redirect_method| is the method that is expected to be used for the second
2894   // request, after redirection.
2895   // |origin_value| is the expected value for the Origin header after
2896   // redirection. If empty, expects that there will be no Origin header.
2897   void HTTPRedirectOriginHeaderTest(const GURL& redirect_url,
2898                                     const std::string& request_method,
2899                                     const std::string& redirect_method,
2900                                     const std::string& origin_value) {
2901     TestDelegate d;
2902     scoped_ptr<URLRequest> req(
2903         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
2904     req->set_method(request_method);
2905     req->SetExtraRequestHeaderByName(HttpRequestHeaders::kOrigin,
2906                                      redirect_url.GetOrigin().spec(), false);
2907     req->Start();
2908
2909     base::RunLoop().Run();
2910
2911     EXPECT_EQ(redirect_method, req->method());
2912     // Note that there is no check for request success here because, for
2913     // purposes of testing, the request very well may fail. For example, if the
2914     // test redirects to an HTTPS server from an HTTP origin, thus it is cross
2915     // origin, there is not an HTTPS server in this unit test framework, so the
2916     // request would fail. However, that's fine, as long as the request headers
2917     // are in order and pass the checks below.
2918     if (origin_value.empty()) {
2919       EXPECT_FALSE(
2920           req->extra_request_headers().HasHeader(HttpRequestHeaders::kOrigin));
2921     } else {
2922       std::string origin_header;
2923       EXPECT_TRUE(req->extra_request_headers().GetHeader(
2924           HttpRequestHeaders::kOrigin, &origin_header));
2925       EXPECT_EQ(origin_value, origin_header);
2926     }
2927   }
2928
2929   void HTTPUploadDataOperationTest(const std::string& method) {
2930     const int kMsgSize = 20000;  // multiple of 10
2931     const int kIterations = 50;
2932     char* uploadBytes = new char[kMsgSize+1];
2933     char* ptr = uploadBytes;
2934     char marker = 'a';
2935     for (int idx = 0; idx < kMsgSize/10; idx++) {
2936       memcpy(ptr, "----------", 10);
2937       ptr += 10;
2938       if (idx % 100 == 0) {
2939         ptr--;
2940         *ptr++ = marker;
2941         if (++marker > 'z')
2942           marker = 'a';
2943       }
2944     }
2945     uploadBytes[kMsgSize] = '\0';
2946
2947     for (int i = 0; i < kIterations; ++i) {
2948       TestDelegate d;
2949       scoped_ptr<URLRequest> r(default_context_.CreateRequest(
2950           test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
2951       r->set_method(method.c_str());
2952
2953       r->set_upload(CreateSimpleUploadData(uploadBytes));
2954
2955       r->Start();
2956       EXPECT_TRUE(r->is_pending());
2957
2958       base::RunLoop().Run();
2959
2960       ASSERT_EQ(1, d.response_started_count())
2961           << "request failed: " << r->status().status()
2962           << ", os error: " << r->status().error();
2963
2964       EXPECT_FALSE(d.received_data_before_response());
2965       EXPECT_EQ(uploadBytes, d.data_received());
2966     }
2967     delete[] uploadBytes;
2968   }
2969
2970   void AddChunksToUpload(URLRequest* r) {
2971     r->AppendChunkToUpload("a", 1, false);
2972     r->AppendChunkToUpload("bcd", 3, false);
2973     r->AppendChunkToUpload("this is a longer chunk than before.", 35, false);
2974     r->AppendChunkToUpload("\r\n\r\n", 4, false);
2975     r->AppendChunkToUpload("0", 1, false);
2976     r->AppendChunkToUpload("2323", 4, true);
2977   }
2978
2979   void VerifyReceivedDataMatchesChunks(URLRequest* r, TestDelegate* d) {
2980     // This should match the chunks sent by AddChunksToUpload().
2981     const std::string expected_data =
2982         "abcdthis is a longer chunk than before.\r\n\r\n02323";
2983
2984     ASSERT_EQ(1, d->response_started_count())
2985         << "request failed: " << r->status().status()
2986         << ", os error: " << r->status().error();
2987
2988     EXPECT_FALSE(d->received_data_before_response());
2989
2990     EXPECT_EQ(expected_data.size(), static_cast<size_t>(d->bytes_received()));
2991     EXPECT_EQ(expected_data, d->data_received());
2992   }
2993
2994   bool DoManyCookiesRequest(int num_cookies) {
2995     TestDelegate d;
2996     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
2997         test_server_.GetURL("set-many-cookies?" +
2998                             base::IntToString(num_cookies)),
2999         DEFAULT_PRIORITY, &d));
3000
3001     r->Start();
3002     EXPECT_TRUE(r->is_pending());
3003
3004     base::RunLoop().Run();
3005
3006     bool is_success = r->status().is_success();
3007
3008     if (!is_success) {
3009       EXPECT_TRUE(r->status().error() == ERR_RESPONSE_HEADERS_TOO_BIG);
3010       // The test server appears to be unable to handle subsequent requests
3011       // after this error is triggered. Force it to restart.
3012       EXPECT_TRUE(test_server_.Stop());
3013       EXPECT_TRUE(test_server_.Start());
3014     }
3015
3016     return is_success;
3017   }
3018
3019   LocalHttpTestServer* test_server() {
3020     return &test_server_;
3021   }
3022
3023  protected:
3024   LocalHttpTestServer test_server_;
3025 };
3026
3027 // In this unit test, we're using the HTTPTestServer as a proxy server and
3028 // issuing a CONNECT request with the magic host name "www.redirect.com".
3029 // The HTTPTestServer will return a 302 response, which we should not
3030 // follow.
3031 TEST_F(URLRequestTestHTTP, ProxyTunnelRedirectTest) {
3032   ASSERT_TRUE(test_server_.Start());
3033
3034   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
3035   TestURLRequestContextWithProxy context(
3036       test_server_.host_port_pair().ToString(), &network_delegate);
3037
3038   TestDelegate d;
3039   {
3040     scoped_ptr<URLRequest> r(context.CreateRequest(
3041         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
3042     r->Start();
3043     EXPECT_TRUE(r->is_pending());
3044
3045     base::RunLoop().Run();
3046
3047     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
3048     // The proxy server is not set before failure.
3049     EXPECT_TRUE(r->proxy_server().IsEmpty());
3050     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r->status().error());
3051     EXPECT_EQ(1, d.response_started_count());
3052     // We should not have followed the redirect.
3053     EXPECT_EQ(0, d.received_redirect_count());
3054   }
3055 }
3056
3057 // This is the same as the previous test, but checks that the network delegate
3058 // registers the error.
3059 TEST_F(URLRequestTestHTTP, NetworkDelegateTunnelConnectionFailed) {
3060   ASSERT_TRUE(test_server_.Start());
3061
3062   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
3063   TestURLRequestContextWithProxy context(
3064       test_server_.host_port_pair().ToString(), &network_delegate);
3065
3066   TestDelegate d;
3067   {
3068     scoped_ptr<URLRequest> r(context.CreateRequest(
3069         GURL("https://www.redirect.com/"), DEFAULT_PRIORITY, &d));
3070     r->Start();
3071     EXPECT_TRUE(r->is_pending());
3072
3073     base::RunLoop().Run();
3074
3075     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
3076     // The proxy server is not set before failure.
3077     EXPECT_TRUE(r->proxy_server().IsEmpty());
3078     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r->status().error());
3079     EXPECT_EQ(1, d.response_started_count());
3080     // We should not have followed the redirect.
3081     EXPECT_EQ(0, d.received_redirect_count());
3082
3083     EXPECT_EQ(1, network_delegate.error_count());
3084     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, network_delegate.last_error());
3085   }
3086 }
3087
3088 // Tests that we can block and asynchronously return OK in various stages.
3089 TEST_F(URLRequestTestHTTP, NetworkDelegateBlockAsynchronously) {
3090   static const BlockingNetworkDelegate::Stage blocking_stages[] = {
3091     BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
3092     BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
3093     BlockingNetworkDelegate::ON_HEADERS_RECEIVED
3094   };
3095   static const size_t blocking_stages_length = arraysize(blocking_stages);
3096
3097   ASSERT_TRUE(test_server_.Start());
3098
3099   TestDelegate d;
3100   BlockingNetworkDelegate network_delegate(
3101       BlockingNetworkDelegate::USER_CALLBACK);
3102   network_delegate.set_block_on(
3103       BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST |
3104       BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS |
3105       BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
3106
3107   TestURLRequestContext context(true);
3108   context.set_network_delegate(&network_delegate);
3109   context.Init();
3110
3111   {
3112     scoped_ptr<URLRequest> r(context.CreateRequest(
3113         test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
3114
3115     r->Start();
3116     for (size_t i = 0; i < blocking_stages_length; ++i) {
3117       base::RunLoop().Run();
3118       EXPECT_EQ(blocking_stages[i],
3119                 network_delegate.stage_blocked_for_callback());
3120       network_delegate.DoCallback(OK);
3121     }
3122     base::RunLoop().Run();
3123     EXPECT_EQ(200, r->GetResponseCode());
3124     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3125     EXPECT_EQ(1, network_delegate.created_requests());
3126     EXPECT_EQ(0, network_delegate.destroyed_requests());
3127   }
3128   EXPECT_EQ(1, network_delegate.destroyed_requests());
3129 }
3130
3131 // Tests that the network delegate can block and cancel a request.
3132 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) {
3133   ASSERT_TRUE(test_server_.Start());
3134
3135   TestDelegate d;
3136   BlockingNetworkDelegate network_delegate(
3137       BlockingNetworkDelegate::AUTO_CALLBACK);
3138   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
3139   network_delegate.set_retval(ERR_EMPTY_RESPONSE);
3140
3141   TestURLRequestContextWithProxy context(
3142       test_server_.host_port_pair().ToString(), &network_delegate);
3143
3144   {
3145     scoped_ptr<URLRequest> r(context.CreateRequest(
3146         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
3147
3148     r->Start();
3149     base::RunLoop().Run();
3150
3151     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
3152     // The proxy server is not set before cancellation.
3153     EXPECT_TRUE(r->proxy_server().IsEmpty());
3154     EXPECT_EQ(ERR_EMPTY_RESPONSE, r->status().error());
3155     EXPECT_EQ(1, network_delegate.created_requests());
3156     EXPECT_EQ(0, network_delegate.destroyed_requests());
3157   }
3158   EXPECT_EQ(1, network_delegate.destroyed_requests());
3159 }
3160
3161 // Helper function for NetworkDelegateCancelRequestAsynchronously and
3162 // NetworkDelegateCancelRequestSynchronously. Sets up a blocking network
3163 // delegate operating in |block_mode| and a request for |url|. It blocks the
3164 // request in |stage| and cancels it with ERR_BLOCKED_BY_CLIENT.
3165 void NetworkDelegateCancelRequest(BlockingNetworkDelegate::BlockMode block_mode,
3166                                   BlockingNetworkDelegate::Stage stage,
3167                                   const GURL& url) {
3168   TestDelegate d;
3169   BlockingNetworkDelegate network_delegate(block_mode);
3170   network_delegate.set_retval(ERR_BLOCKED_BY_CLIENT);
3171   network_delegate.set_block_on(stage);
3172
3173   TestURLRequestContext context(true);
3174   context.set_network_delegate(&network_delegate);
3175   context.Init();
3176
3177   {
3178     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3179
3180     r->Start();
3181     base::RunLoop().Run();
3182
3183     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
3184     // The proxy server is not set before cancellation.
3185     EXPECT_TRUE(r->proxy_server().IsEmpty());
3186     EXPECT_EQ(ERR_BLOCKED_BY_CLIENT, r->status().error());
3187     EXPECT_EQ(1, network_delegate.created_requests());
3188     EXPECT_EQ(0, network_delegate.destroyed_requests());
3189   }
3190   EXPECT_EQ(1, network_delegate.destroyed_requests());
3191 }
3192
3193 // The following 3 tests check that the network delegate can cancel a request
3194 // synchronously in various stages of the request.
3195 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) {
3196   ASSERT_TRUE(test_server_.Start());
3197   NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
3198                                BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
3199                                test_server_.GetURL(std::string()));
3200 }
3201
3202 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously2) {
3203   ASSERT_TRUE(test_server_.Start());
3204   NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
3205                                BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
3206                                test_server_.GetURL(std::string()));
3207 }
3208
3209 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously3) {
3210   ASSERT_TRUE(test_server_.Start());
3211   NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS,
3212                                BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
3213                                test_server_.GetURL(std::string()));
3214 }
3215
3216 // The following 3 tests check that the network delegate can cancel a request
3217 // asynchronously in various stages of the request.
3218 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously1) {
3219   ASSERT_TRUE(test_server_.Start());
3220   NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
3221                                BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
3222                                test_server_.GetURL(std::string()));
3223 }
3224
3225 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously2) {
3226   ASSERT_TRUE(test_server_.Start());
3227   NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
3228                                BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
3229                                test_server_.GetURL(std::string()));
3230 }
3231
3232 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously3) {
3233   ASSERT_TRUE(test_server_.Start());
3234   NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK,
3235                                BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
3236                                test_server_.GetURL(std::string()));
3237 }
3238
3239 // Tests that the network delegate can block and redirect a request to a new
3240 // URL.
3241 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequest) {
3242   ASSERT_TRUE(test_server_.Start());
3243
3244   TestDelegate d;
3245   BlockingNetworkDelegate network_delegate(
3246       BlockingNetworkDelegate::AUTO_CALLBACK);
3247   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
3248   GURL redirect_url(test_server_.GetURL("simple.html"));
3249   network_delegate.set_redirect_url(redirect_url);
3250
3251   TestURLRequestContextWithProxy context(
3252       test_server_.host_port_pair().ToString(), &network_delegate);
3253
3254   {
3255     GURL original_url(test_server_.GetURL("empty.html"));
3256     scoped_ptr<URLRequest> r(
3257         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
3258
3259     // Quit after hitting the redirect, so can check the headers.
3260     d.set_quit_on_redirect(true);
3261     r->Start();
3262     base::RunLoop().Run();
3263
3264     // Check headers from URLRequestJob.
3265     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3266     EXPECT_EQ(307, r->GetResponseCode());
3267     EXPECT_EQ(307, r->response_headers()->response_code());
3268     std::string location;
3269     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
3270                                                        &location));
3271     EXPECT_EQ(redirect_url, GURL(location));
3272
3273     // Let the request finish.
3274     r->FollowDeferredRedirect();
3275     base::RunLoop().Run();
3276     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3277     EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
3278     EXPECT_EQ(
3279         1, network_delegate.observed_before_proxy_headers_sent_callbacks());
3280     EXPECT_TRUE(
3281         network_delegate.last_observed_proxy().Equals(
3282             test_server_.host_port_pair()));
3283
3284     EXPECT_EQ(0, r->status().error());
3285     EXPECT_EQ(redirect_url, r->url());
3286     EXPECT_EQ(original_url, r->original_url());
3287     EXPECT_EQ(2U, r->url_chain().size());
3288     EXPECT_EQ(1, network_delegate.created_requests());
3289     EXPECT_EQ(0, network_delegate.destroyed_requests());
3290   }
3291   EXPECT_EQ(1, network_delegate.destroyed_requests());
3292 }
3293
3294 // Tests that the network delegate can block and redirect a request to a new
3295 // URL by setting a redirect_url and returning in OnBeforeURLRequest directly.
3296 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestSynchronously) {
3297   ASSERT_TRUE(test_server_.Start());
3298
3299   TestDelegate d;
3300   BlockingNetworkDelegate network_delegate(
3301       BlockingNetworkDelegate::SYNCHRONOUS);
3302   GURL redirect_url(test_server_.GetURL("simple.html"));
3303   network_delegate.set_redirect_url(redirect_url);
3304
3305   TestURLRequestContextWithProxy context(
3306       test_server_.host_port_pair().ToString(), &network_delegate);
3307
3308   {
3309     GURL original_url(test_server_.GetURL("empty.html"));
3310     scoped_ptr<URLRequest> r(
3311         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
3312
3313     // Quit after hitting the redirect, so can check the headers.
3314     d.set_quit_on_redirect(true);
3315     r->Start();
3316     base::RunLoop().Run();
3317
3318     // Check headers from URLRequestJob.
3319     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3320     EXPECT_EQ(307, r->GetResponseCode());
3321     EXPECT_EQ(307, r->response_headers()->response_code());
3322     std::string location;
3323     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
3324                                                        &location));
3325     EXPECT_EQ(redirect_url, GURL(location));
3326
3327     // Let the request finish.
3328     r->FollowDeferredRedirect();
3329     base::RunLoop().Run();
3330
3331     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3332     EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
3333     EXPECT_EQ(
3334         1, network_delegate.observed_before_proxy_headers_sent_callbacks());
3335     EXPECT_TRUE(
3336         network_delegate.last_observed_proxy().Equals(
3337             test_server_.host_port_pair()));
3338     EXPECT_EQ(0, r->status().error());
3339     EXPECT_EQ(redirect_url, r->url());
3340     EXPECT_EQ(original_url, r->original_url());
3341     EXPECT_EQ(2U, r->url_chain().size());
3342     EXPECT_EQ(1, network_delegate.created_requests());
3343     EXPECT_EQ(0, network_delegate.destroyed_requests());
3344   }
3345   EXPECT_EQ(1, network_delegate.destroyed_requests());
3346 }
3347
3348 // Tests that redirects caused by the network delegate preserve POST data.
3349 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestPost) {
3350   ASSERT_TRUE(test_server_.Start());
3351
3352   const char kData[] = "hello world";
3353
3354   TestDelegate d;
3355   BlockingNetworkDelegate network_delegate(
3356       BlockingNetworkDelegate::AUTO_CALLBACK);
3357   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
3358   GURL redirect_url(test_server_.GetURL("echo"));
3359   network_delegate.set_redirect_url(redirect_url);
3360
3361   TestURLRequestContext context(true);
3362   context.set_network_delegate(&network_delegate);
3363   context.Init();
3364
3365   {
3366     GURL original_url(test_server_.GetURL("empty.html"));
3367     scoped_ptr<URLRequest> r(
3368         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
3369     r->set_method("POST");
3370     r->set_upload(CreateSimpleUploadData(kData));
3371     HttpRequestHeaders headers;
3372     headers.SetHeader(HttpRequestHeaders::kContentLength,
3373                       base::SizeTToString(arraysize(kData) - 1));
3374     r->SetExtraRequestHeaders(headers);
3375
3376     // Quit after hitting the redirect, so can check the headers.
3377     d.set_quit_on_redirect(true);
3378     r->Start();
3379     base::RunLoop().Run();
3380
3381     // Check headers from URLRequestJob.
3382     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3383     EXPECT_EQ(307, r->GetResponseCode());
3384     EXPECT_EQ(307, r->response_headers()->response_code());
3385     std::string location;
3386     ASSERT_TRUE(r->response_headers()->EnumerateHeader(NULL, "Location",
3387                                                        &location));
3388     EXPECT_EQ(redirect_url, GURL(location));
3389
3390     // Let the request finish.
3391     r->FollowDeferredRedirect();
3392     base::RunLoop().Run();
3393
3394     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3395     EXPECT_EQ(0, r->status().error());
3396     EXPECT_EQ(redirect_url, r->url());
3397     EXPECT_EQ(original_url, r->original_url());
3398     EXPECT_EQ(2U, r->url_chain().size());
3399     EXPECT_EQ(1, network_delegate.created_requests());
3400     EXPECT_EQ(0, network_delegate.destroyed_requests());
3401     EXPECT_EQ("POST", r->method());
3402     EXPECT_EQ(kData, d.data_received());
3403   }
3404   EXPECT_EQ(1, network_delegate.destroyed_requests());
3405 }
3406
3407 // Tests that the network delegate can block and redirect a request to a new
3408 // URL during OnHeadersReceived.
3409 TEST_F(URLRequestTestHTTP, NetworkDelegateRedirectRequestOnHeadersReceived) {
3410   ASSERT_TRUE(test_server_.Start());
3411
3412   TestDelegate d;
3413   BlockingNetworkDelegate network_delegate(
3414       BlockingNetworkDelegate::AUTO_CALLBACK);
3415   network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
3416   GURL redirect_url(test_server_.GetURL("simple.html"));
3417   network_delegate.set_redirect_on_headers_received_url(redirect_url);
3418
3419   TestURLRequestContextWithProxy context(
3420       test_server_.host_port_pair().ToString(), &network_delegate);
3421
3422   {
3423     GURL original_url(test_server_.GetURL("empty.html"));
3424     scoped_ptr<URLRequest> r(
3425         context.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
3426
3427     r->Start();
3428     base::RunLoop().Run();
3429
3430     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3431     EXPECT_TRUE(r->proxy_server().Equals(test_server_.host_port_pair()));
3432     EXPECT_EQ(
3433         2, network_delegate.observed_before_proxy_headers_sent_callbacks());
3434     EXPECT_TRUE(
3435         network_delegate.last_observed_proxy().Equals(
3436             test_server_.host_port_pair()));
3437
3438     EXPECT_EQ(OK, r->status().error());
3439     EXPECT_EQ(redirect_url, r->url());
3440     EXPECT_EQ(original_url, r->original_url());
3441     EXPECT_EQ(2U, r->url_chain().size());
3442     EXPECT_EQ(2, network_delegate.created_requests());
3443     EXPECT_EQ(0, network_delegate.destroyed_requests());
3444   }
3445   EXPECT_EQ(1, network_delegate.destroyed_requests());
3446 }
3447
3448 // Tests that the network delegate can synchronously complete OnAuthRequired
3449 // by taking no action. This indicates that the NetworkDelegate does not want to
3450 // handle the challenge, and is passing the buck along to the
3451 // URLRequest::Delegate.
3452 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncNoAction) {
3453   ASSERT_TRUE(test_server_.Start());
3454
3455   TestDelegate d;
3456   BlockingNetworkDelegate network_delegate(
3457       BlockingNetworkDelegate::SYNCHRONOUS);
3458
3459   TestURLRequestContext context(true);
3460   context.set_network_delegate(&network_delegate);
3461   context.Init();
3462
3463   d.set_credentials(AuthCredentials(kUser, kSecret));
3464
3465   {
3466     GURL url(test_server_.GetURL("auth-basic"));
3467     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3468     r->Start();
3469
3470     base::RunLoop().Run();
3471
3472     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3473     EXPECT_EQ(0, r->status().error());
3474     EXPECT_EQ(200, r->GetResponseCode());
3475     EXPECT_TRUE(d.auth_required_called());
3476     EXPECT_EQ(1, network_delegate.created_requests());
3477     EXPECT_EQ(0, network_delegate.destroyed_requests());
3478   }
3479   EXPECT_EQ(1, network_delegate.destroyed_requests());
3480 }
3481
3482 TEST_F(URLRequestTestHTTP,
3483     NetworkDelegateOnAuthRequiredSyncNoAction_GetFullRequestHeaders) {
3484   ASSERT_TRUE(test_server_.Start());
3485
3486   TestDelegate d;
3487   BlockingNetworkDelegate network_delegate(
3488       BlockingNetworkDelegate::SYNCHRONOUS);
3489
3490   TestURLRequestContext context(true);
3491   context.set_network_delegate(&network_delegate);
3492   context.Init();
3493
3494   d.set_credentials(AuthCredentials(kUser, kSecret));
3495
3496   {
3497     GURL url(test_server_.GetURL("auth-basic"));
3498     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3499     r->Start();
3500
3501     {
3502       HttpRequestHeaders headers;
3503       EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
3504       EXPECT_FALSE(headers.HasHeader("Authorization"));
3505     }
3506
3507     base::RunLoop().Run();
3508
3509     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3510     EXPECT_EQ(0, r->status().error());
3511     EXPECT_EQ(200, r->GetResponseCode());
3512     EXPECT_TRUE(d.auth_required_called());
3513     EXPECT_EQ(1, network_delegate.created_requests());
3514     EXPECT_EQ(0, network_delegate.destroyed_requests());
3515   }
3516   EXPECT_EQ(1, network_delegate.destroyed_requests());
3517 }
3518
3519 // Tests that the network delegate can synchronously complete OnAuthRequired
3520 // by setting credentials.
3521 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncSetAuth) {
3522   ASSERT_TRUE(test_server_.Start());
3523
3524   TestDelegate d;
3525   BlockingNetworkDelegate network_delegate(
3526       BlockingNetworkDelegate::SYNCHRONOUS);
3527   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3528   network_delegate.set_auth_retval(
3529       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
3530
3531   network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
3532
3533   TestURLRequestContext context(true);
3534   context.set_network_delegate(&network_delegate);
3535   context.Init();
3536
3537   {
3538     GURL url(test_server_.GetURL("auth-basic"));
3539     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3540     r->Start();
3541     base::RunLoop().Run();
3542
3543     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3544     EXPECT_EQ(0, r->status().error());
3545     EXPECT_EQ(200, r->GetResponseCode());
3546     EXPECT_FALSE(d.auth_required_called());
3547     EXPECT_EQ(1, network_delegate.created_requests());
3548     EXPECT_EQ(0, network_delegate.destroyed_requests());
3549   }
3550   EXPECT_EQ(1, network_delegate.destroyed_requests());
3551 }
3552
3553 // Same as above, but also tests that GetFullRequestHeaders returns the proper
3554 // headers (for the first or second request) when called at the proper times.
3555 TEST_F(URLRequestTestHTTP,
3556     NetworkDelegateOnAuthRequiredSyncSetAuth_GetFullRequestHeaders) {
3557   ASSERT_TRUE(test_server_.Start());
3558
3559   TestDelegate d;
3560   BlockingNetworkDelegate network_delegate(
3561       BlockingNetworkDelegate::SYNCHRONOUS);
3562   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3563   network_delegate.set_auth_retval(
3564       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
3565
3566   network_delegate.set_auth_credentials(AuthCredentials(kUser, kSecret));
3567
3568   TestURLRequestContext context(true);
3569   context.set_network_delegate(&network_delegate);
3570   context.Init();
3571
3572   {
3573     GURL url(test_server_.GetURL("auth-basic"));
3574     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3575     r->Start();
3576     base::RunLoop().Run();
3577
3578     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3579     EXPECT_EQ(0, r->status().error());
3580     EXPECT_EQ(200, r->GetResponseCode());
3581     EXPECT_FALSE(d.auth_required_called());
3582     EXPECT_EQ(1, network_delegate.created_requests());
3583     EXPECT_EQ(0, network_delegate.destroyed_requests());
3584
3585     {
3586       HttpRequestHeaders headers;
3587       EXPECT_TRUE(r->GetFullRequestHeaders(&headers));
3588       EXPECT_TRUE(headers.HasHeader("Authorization"));
3589     }
3590   }
3591   EXPECT_EQ(1, network_delegate.destroyed_requests());
3592 }
3593
3594 // Tests that the network delegate can synchronously complete OnAuthRequired
3595 // by cancelling authentication.
3596 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredSyncCancel) {
3597   ASSERT_TRUE(test_server_.Start());
3598
3599   TestDelegate d;
3600   BlockingNetworkDelegate network_delegate(
3601       BlockingNetworkDelegate::SYNCHRONOUS);
3602   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3603   network_delegate.set_auth_retval(
3604       NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
3605
3606   TestURLRequestContext context(true);
3607   context.set_network_delegate(&network_delegate);
3608   context.Init();
3609
3610   {
3611     GURL url(test_server_.GetURL("auth-basic"));
3612     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3613     r->Start();
3614     base::RunLoop().Run();
3615
3616     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3617     EXPECT_EQ(OK, r->status().error());
3618     EXPECT_EQ(401, r->GetResponseCode());
3619     EXPECT_FALSE(d.auth_required_called());
3620     EXPECT_EQ(1, network_delegate.created_requests());
3621     EXPECT_EQ(0, network_delegate.destroyed_requests());
3622   }
3623   EXPECT_EQ(1, network_delegate.destroyed_requests());
3624 }
3625
3626 // Tests that the network delegate can asynchronously complete OnAuthRequired
3627 // by taking no action. This indicates that the NetworkDelegate does not want
3628 // to handle the challenge, and is passing the buck along to the
3629 // URLRequest::Delegate.
3630 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncNoAction) {
3631   ASSERT_TRUE(test_server_.Start());
3632
3633   TestDelegate d;
3634   BlockingNetworkDelegate network_delegate(
3635       BlockingNetworkDelegate::AUTO_CALLBACK);
3636   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3637
3638   TestURLRequestContext context(true);
3639   context.set_network_delegate(&network_delegate);
3640   context.Init();
3641
3642   d.set_credentials(AuthCredentials(kUser, kSecret));
3643
3644   {
3645     GURL url(test_server_.GetURL("auth-basic"));
3646     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3647     r->Start();
3648     base::RunLoop().Run();
3649
3650     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3651     EXPECT_EQ(0, r->status().error());
3652     EXPECT_EQ(200, r->GetResponseCode());
3653     EXPECT_TRUE(d.auth_required_called());
3654     EXPECT_EQ(1, network_delegate.created_requests());
3655     EXPECT_EQ(0, network_delegate.destroyed_requests());
3656   }
3657   EXPECT_EQ(1, network_delegate.destroyed_requests());
3658 }
3659
3660 // Tests that the network delegate can asynchronously complete OnAuthRequired
3661 // by setting credentials.
3662 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncSetAuth) {
3663   ASSERT_TRUE(test_server_.Start());
3664
3665   TestDelegate d;
3666   BlockingNetworkDelegate network_delegate(
3667       BlockingNetworkDelegate::AUTO_CALLBACK);
3668   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3669   network_delegate.set_auth_retval(
3670       NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
3671
3672   AuthCredentials auth_credentials(kUser, kSecret);
3673   network_delegate.set_auth_credentials(auth_credentials);
3674
3675   TestURLRequestContext context(true);
3676   context.set_network_delegate(&network_delegate);
3677   context.Init();
3678
3679   {
3680     GURL url(test_server_.GetURL("auth-basic"));
3681     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3682     r->Start();
3683     base::RunLoop().Run();
3684
3685     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3686     EXPECT_EQ(0, r->status().error());
3687
3688     EXPECT_EQ(200, r->GetResponseCode());
3689     EXPECT_FALSE(d.auth_required_called());
3690     EXPECT_EQ(1, network_delegate.created_requests());
3691     EXPECT_EQ(0, network_delegate.destroyed_requests());
3692   }
3693   EXPECT_EQ(1, network_delegate.destroyed_requests());
3694 }
3695
3696 // Tests that the network delegate can asynchronously complete OnAuthRequired
3697 // by cancelling authentication.
3698 TEST_F(URLRequestTestHTTP, NetworkDelegateOnAuthRequiredAsyncCancel) {
3699   ASSERT_TRUE(test_server_.Start());
3700
3701   TestDelegate d;
3702   BlockingNetworkDelegate network_delegate(
3703       BlockingNetworkDelegate::AUTO_CALLBACK);
3704   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3705   network_delegate.set_auth_retval(
3706       NetworkDelegate::AUTH_REQUIRED_RESPONSE_CANCEL_AUTH);
3707
3708   TestURLRequestContext context(true);
3709   context.set_network_delegate(&network_delegate);
3710   context.Init();
3711
3712   {
3713     GURL url(test_server_.GetURL("auth-basic"));
3714     scoped_ptr<URLRequest> r(context.CreateRequest(url, DEFAULT_PRIORITY, &d));
3715     r->Start();
3716     base::RunLoop().Run();
3717
3718     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
3719     EXPECT_EQ(OK, r->status().error());
3720     EXPECT_EQ(401, r->GetResponseCode());
3721     EXPECT_FALSE(d.auth_required_called());
3722     EXPECT_EQ(1, network_delegate.created_requests());
3723     EXPECT_EQ(0, network_delegate.destroyed_requests());
3724   }
3725   EXPECT_EQ(1, network_delegate.destroyed_requests());
3726 }
3727
3728 // Tests that we can handle when a network request was canceled while we were
3729 // waiting for the network delegate.
3730 // Part 1: Request is cancelled while waiting for OnBeforeURLRequest callback.
3731 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) {
3732   ASSERT_TRUE(test_server_.Start());
3733
3734   TestDelegate d;
3735   BlockingNetworkDelegate network_delegate(
3736       BlockingNetworkDelegate::USER_CALLBACK);
3737   network_delegate.set_block_on(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST);
3738
3739   TestURLRequestContext context(true);
3740   context.set_network_delegate(&network_delegate);
3741   context.Init();
3742
3743   {
3744     scoped_ptr<URLRequest> r(context.CreateRequest(
3745         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
3746
3747     r->Start();
3748     base::RunLoop().Run();
3749     EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST,
3750               network_delegate.stage_blocked_for_callback());
3751     EXPECT_EQ(0, network_delegate.completed_requests());
3752     // Cancel before callback.
3753     r->Cancel();
3754     // Ensure that network delegate is notified.
3755     EXPECT_EQ(1, network_delegate.completed_requests());
3756     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
3757     EXPECT_EQ(ERR_ABORTED, r->status().error());
3758     EXPECT_EQ(1, network_delegate.created_requests());
3759     EXPECT_EQ(0, network_delegate.destroyed_requests());
3760   }
3761   EXPECT_EQ(1, network_delegate.destroyed_requests());
3762 }
3763
3764 // Tests that we can handle when a network request was canceled while we were
3765 // waiting for the network delegate.
3766 // Part 2: Request is cancelled while waiting for OnBeforeSendHeaders callback.
3767 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) {
3768   ASSERT_TRUE(test_server_.Start());
3769
3770   TestDelegate d;
3771   BlockingNetworkDelegate network_delegate(
3772       BlockingNetworkDelegate::USER_CALLBACK);
3773   network_delegate.set_block_on(
3774       BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS);
3775
3776   TestURLRequestContext context(true);
3777   context.set_network_delegate(&network_delegate);
3778   context.Init();
3779
3780   {
3781     scoped_ptr<URLRequest> r(context.CreateRequest(
3782         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
3783
3784     r->Start();
3785     base::RunLoop().Run();
3786     EXPECT_EQ(BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS,
3787               network_delegate.stage_blocked_for_callback());
3788     EXPECT_EQ(0, network_delegate.completed_requests());
3789     // Cancel before callback.
3790     r->Cancel();
3791     // Ensure that network delegate is notified.
3792     EXPECT_EQ(1, network_delegate.completed_requests());
3793     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
3794     EXPECT_EQ(ERR_ABORTED, r->status().error());
3795     EXPECT_EQ(1, network_delegate.created_requests());
3796     EXPECT_EQ(0, network_delegate.destroyed_requests());
3797   }
3798   EXPECT_EQ(1, network_delegate.destroyed_requests());
3799 }
3800
3801 // Tests that we can handle when a network request was canceled while we were
3802 // waiting for the network delegate.
3803 // Part 3: Request is cancelled while waiting for OnHeadersReceived callback.
3804 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) {
3805   ASSERT_TRUE(test_server_.Start());
3806
3807   TestDelegate d;
3808   BlockingNetworkDelegate network_delegate(
3809       BlockingNetworkDelegate::USER_CALLBACK);
3810   network_delegate.set_block_on(BlockingNetworkDelegate::ON_HEADERS_RECEIVED);
3811
3812   TestURLRequestContext context(true);
3813   context.set_network_delegate(&network_delegate);
3814   context.Init();
3815
3816   {
3817     scoped_ptr<URLRequest> r(context.CreateRequest(
3818         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
3819
3820     r->Start();
3821     base::RunLoop().Run();
3822     EXPECT_EQ(BlockingNetworkDelegate::ON_HEADERS_RECEIVED,
3823               network_delegate.stage_blocked_for_callback());
3824     EXPECT_EQ(0, network_delegate.completed_requests());
3825     // Cancel before callback.
3826     r->Cancel();
3827     // Ensure that network delegate is notified.
3828     EXPECT_EQ(1, network_delegate.completed_requests());
3829     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
3830     EXPECT_EQ(ERR_ABORTED, r->status().error());
3831     EXPECT_EQ(1, network_delegate.created_requests());
3832     EXPECT_EQ(0, network_delegate.destroyed_requests());
3833   }
3834   EXPECT_EQ(1, network_delegate.destroyed_requests());
3835 }
3836
3837 // Tests that we can handle when a network request was canceled while we were
3838 // waiting for the network delegate.
3839 // Part 4: Request is cancelled while waiting for OnAuthRequired callback.
3840 TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting4) {
3841   ASSERT_TRUE(test_server_.Start());
3842
3843   TestDelegate d;
3844   BlockingNetworkDelegate network_delegate(
3845       BlockingNetworkDelegate::USER_CALLBACK);
3846   network_delegate.set_block_on(BlockingNetworkDelegate::ON_AUTH_REQUIRED);
3847
3848   TestURLRequestContext context(true);
3849   context.set_network_delegate(&network_delegate);
3850   context.Init();
3851
3852   {
3853     scoped_ptr<URLRequest> r(context.CreateRequest(
3854         test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
3855
3856     r->Start();
3857     base::RunLoop().Run();
3858     EXPECT_EQ(BlockingNetworkDelegate::ON_AUTH_REQUIRED,
3859               network_delegate.stage_blocked_for_callback());
3860     EXPECT_EQ(0, network_delegate.completed_requests());
3861     // Cancel before callback.
3862     r->Cancel();
3863     // Ensure that network delegate is notified.
3864     EXPECT_EQ(1, network_delegate.completed_requests());
3865     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
3866     EXPECT_EQ(ERR_ABORTED, r->status().error());
3867     EXPECT_EQ(1, network_delegate.created_requests());
3868     EXPECT_EQ(0, network_delegate.destroyed_requests());
3869   }
3870   EXPECT_EQ(1, network_delegate.destroyed_requests());
3871 }
3872
3873 // In this unit test, we're using the HTTPTestServer as a proxy server and
3874 // issuing a CONNECT request with the magic host name "www.server-auth.com".
3875 // The HTTPTestServer will return a 401 response, which we should balk at.
3876 TEST_F(URLRequestTestHTTP, UnexpectedServerAuthTest) {
3877   ASSERT_TRUE(test_server_.Start());
3878
3879   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
3880   TestURLRequestContextWithProxy context(
3881       test_server_.host_port_pair().ToString(), &network_delegate);
3882
3883   TestDelegate d;
3884   {
3885     scoped_ptr<URLRequest> r(context.CreateRequest(
3886         GURL("https://www.server-auth.com/"), DEFAULT_PRIORITY, &d));
3887
3888     r->Start();
3889     EXPECT_TRUE(r->is_pending());
3890
3891     base::RunLoop().Run();
3892
3893     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
3894     // The proxy server is not set before failure.
3895     EXPECT_TRUE(r->proxy_server().IsEmpty());
3896     EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, r->status().error());
3897   }
3898 }
3899
3900 TEST_F(URLRequestTestHTTP, GetTest_NoCache) {
3901   ASSERT_TRUE(test_server_.Start());
3902
3903   TestDelegate d;
3904   {
3905     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
3906         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
3907
3908     r->Start();
3909     EXPECT_TRUE(r->is_pending());
3910
3911     base::RunLoop().Run();
3912
3913     EXPECT_EQ(1, d.response_started_count());
3914     EXPECT_FALSE(d.received_data_before_response());
3915     EXPECT_NE(0, d.bytes_received());
3916     EXPECT_EQ(test_server_.host_port_pair().host(),
3917               r->GetSocketAddress().host());
3918     EXPECT_EQ(test_server_.host_port_pair().port(),
3919               r->GetSocketAddress().port());
3920
3921     // TODO(eroman): Add back the NetLog tests...
3922   }
3923 }
3924
3925 // This test has the server send a large number of cookies to the client.
3926 // To ensure that no number of cookies causes a crash, a galloping binary
3927 // search is used to estimate that maximum number of cookies that are accepted
3928 // by the browser. Beyond the maximum number, the request will fail with
3929 // ERR_RESPONSE_HEADERS_TOO_BIG.
3930 #if defined(OS_WIN)
3931 // http://crbug.com/177916
3932 #define MAYBE_GetTest_ManyCookies DISABLED_GetTest_ManyCookies
3933 #else
3934 #define MAYBE_GetTest_ManyCookies GetTest_ManyCookies
3935 #endif  // defined(OS_WIN)
3936 TEST_F(URLRequestTestHTTP, MAYBE_GetTest_ManyCookies) {
3937   ASSERT_TRUE(test_server_.Start());
3938
3939   int lower_bound = 0;
3940   int upper_bound = 1;
3941
3942   // Double the number of cookies until the response header limits are
3943   // exceeded.
3944   while (DoManyCookiesRequest(upper_bound)) {
3945     lower_bound = upper_bound;
3946     upper_bound *= 2;
3947     ASSERT_LT(upper_bound, 1000000);
3948   }
3949
3950   int tolerance = static_cast<int>(upper_bound * 0.005);
3951   if (tolerance < 2)
3952     tolerance = 2;
3953
3954   // Perform a binary search to find the highest possible number of cookies,
3955   // within the desired tolerance.
3956   while (upper_bound - lower_bound >= tolerance) {
3957     int num_cookies = (lower_bound + upper_bound) / 2;
3958
3959     if (DoManyCookiesRequest(num_cookies))
3960       lower_bound = num_cookies;
3961     else
3962       upper_bound = num_cookies;
3963   }
3964   // Success: the test did not crash.
3965 }
3966
3967 TEST_F(URLRequestTestHTTP, GetTest) {
3968   ASSERT_TRUE(test_server_.Start());
3969
3970   TestDelegate d;
3971   {
3972     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
3973         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
3974
3975     r->Start();
3976     EXPECT_TRUE(r->is_pending());
3977
3978     base::RunLoop().Run();
3979
3980     EXPECT_EQ(1, d.response_started_count());
3981     EXPECT_FALSE(d.received_data_before_response());
3982     EXPECT_NE(0, d.bytes_received());
3983     EXPECT_EQ(test_server_.host_port_pair().host(),
3984               r->GetSocketAddress().host());
3985     EXPECT_EQ(test_server_.host_port_pair().port(),
3986               r->GetSocketAddress().port());
3987   }
3988 }
3989
3990 TEST_F(URLRequestTestHTTP, GetTest_GetFullRequestHeaders) {
3991   ASSERT_TRUE(test_server_.Start());
3992
3993   TestDelegate d;
3994   {
3995     GURL test_url(test_server_.GetURL(std::string()));
3996     scoped_ptr<URLRequest> r(
3997         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
3998
3999     HttpRequestHeaders headers;
4000     EXPECT_FALSE(r->GetFullRequestHeaders(&headers));
4001
4002     r->Start();
4003     EXPECT_TRUE(r->is_pending());
4004
4005     base::RunLoop().Run();
4006
4007     EXPECT_EQ(1, d.response_started_count());
4008     EXPECT_FALSE(d.received_data_before_response());
4009     EXPECT_NE(0, d.bytes_received());
4010     EXPECT_EQ(test_server_.host_port_pair().host(),
4011               r->GetSocketAddress().host());
4012     EXPECT_EQ(test_server_.host_port_pair().port(),
4013               r->GetSocketAddress().port());
4014
4015     EXPECT_TRUE(d.have_full_request_headers());
4016     CheckFullRequestHeaders(d.full_request_headers(), test_url);
4017   }
4018 }
4019
4020 TEST_F(URLRequestTestHTTP, GetTestLoadTiming) {
4021   ASSERT_TRUE(test_server_.Start());
4022
4023   TestDelegate d;
4024   {
4025     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
4026         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
4027
4028     r->Start();
4029     EXPECT_TRUE(r->is_pending());
4030
4031     base::RunLoop().Run();
4032
4033     LoadTimingInfo load_timing_info;
4034     r->GetLoadTimingInfo(&load_timing_info);
4035     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
4036
4037     EXPECT_EQ(1, d.response_started_count());
4038     EXPECT_FALSE(d.received_data_before_response());
4039     EXPECT_NE(0, d.bytes_received());
4040     EXPECT_EQ(test_server_.host_port_pair().host(),
4041               r->GetSocketAddress().host());
4042     EXPECT_EQ(test_server_.host_port_pair().port(),
4043               r->GetSocketAddress().port());
4044   }
4045 }
4046
4047 TEST_F(URLRequestTestHTTP, GetZippedTest) {
4048   ASSERT_TRUE(test_server_.Start());
4049
4050   // Parameter that specifies the Content-Length field in the response:
4051   // C - Compressed length.
4052   // U - Uncompressed length.
4053   // L - Large length (larger than both C & U).
4054   // M - Medium length (between C & U).
4055   // S - Small length (smaller than both C & U).
4056   const char test_parameters[] = "CULMS";
4057   const int num_tests = arraysize(test_parameters)- 1;  // Skip NULL.
4058   // C & U should be OK.
4059   // L & M are larger than the data sent, and show an error.
4060   // S has too little data, but we seem to accept it.
4061   const bool test_expect_success[num_tests] =
4062       { true, true, false, false, true };
4063
4064   for (int i = 0; i < num_tests ; i++) {
4065     TestDelegate d;
4066     {
4067       std::string test_file =
4068           base::StringPrintf("compressedfiles/BullRunSpeech.txt?%c",
4069                              test_parameters[i]);
4070
4071       TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
4072       TestURLRequestContext context(true);
4073       context.set_network_delegate(&network_delegate);
4074       context.Init();
4075
4076       scoped_ptr<URLRequest> r(context.CreateRequest(
4077           test_server_.GetURL(test_file), DEFAULT_PRIORITY, &d));
4078       r->Start();
4079       EXPECT_TRUE(r->is_pending());
4080
4081       base::RunLoop().Run();
4082
4083       EXPECT_EQ(1, d.response_started_count());
4084       EXPECT_FALSE(d.received_data_before_response());
4085       VLOG(1) << " Received " << d.bytes_received() << " bytes"
4086               << " status = " << r->status().status()
4087               << " error = " << r->status().error();
4088       if (test_expect_success[i]) {
4089         EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status())
4090             << " Parameter = \"" << test_file << "\"";
4091       } else {
4092         EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
4093         EXPECT_EQ(ERR_CONTENT_LENGTH_MISMATCH, r->status().error())
4094             << " Parameter = \"" << test_file << "\"";
4095       }
4096     }
4097   }
4098 }
4099
4100 TEST_F(URLRequestTestHTTP, NetworkQualityEstimator) {
4101   ASSERT_TRUE(test_server_.Start());
4102   // Enable requests to local host to be used for network quality estimation.
4103   std::map<std::string, std::string> variation_params;
4104   NetworkQualityEstimator estimator(scoped_ptr<net::ExternalEstimateProvider>(),
4105                                     variation_params, true, true);
4106
4107   TestDelegate d;
4108   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
4109   TestURLRequestContext context(true);
4110   context.set_network_quality_estimator(&estimator);
4111   context.set_network_delegate(&network_delegate);
4112   context.Init();
4113
4114   std::string url = "echo.html";
4115
4116   scoped_ptr<URLRequest> r(
4117       context.CreateRequest(test_server_.GetURL(url), DEFAULT_PRIORITY, &d));
4118   r->Start();
4119
4120   base::RunLoop().Run();
4121
4122   base::TimeDelta rtt;
4123   int32_t kbps;
4124   EXPECT_TRUE(estimator.GetRTTEstimate(&rtt));
4125   EXPECT_TRUE(estimator.GetDownlinkThroughputKbpsEstimate(&kbps));
4126   EXPECT_GE(rtt, base::TimeDelta());
4127   EXPECT_LT(rtt, base::TimeDelta::Max());
4128   EXPECT_GT(kbps, 0);
4129
4130   // Verify that histograms are not populated. They should populate only when
4131   // there is a change in ConnectionType.
4132   base::HistogramTester histogram_tester;
4133   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 0);
4134   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 0);
4135
4136   NetworkChangeNotifier::NotifyObserversOfConnectionTypeChangeForTests(
4137       NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI);
4138   base::MessageLoop::current()->RunUntilIdle();
4139   histogram_tester.ExpectTotalCount("NQE.PeakKbps.Unknown", 1);
4140   histogram_tester.ExpectTotalCount("NQE.FastestRTT.Unknown", 1);
4141 }
4142
4143 TEST_F(URLRequestTestHTTP, RedirectLoadTiming) {
4144   ASSERT_TRUE(test_server_.Start());
4145
4146   GURL destination_url = test_server_.GetURL(std::string());
4147   GURL original_url =
4148       test_server_.GetURL("server-redirect?" + destination_url.spec());
4149   TestDelegate d;
4150   scoped_ptr<URLRequest> req(
4151       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
4152   req->Start();
4153   base::RunLoop().Run();
4154
4155   EXPECT_EQ(1, d.response_started_count());
4156   EXPECT_EQ(1, d.received_redirect_count());
4157   EXPECT_EQ(destination_url, req->url());
4158   EXPECT_EQ(original_url, req->original_url());
4159   ASSERT_EQ(2U, req->url_chain().size());
4160   EXPECT_EQ(original_url, req->url_chain()[0]);
4161   EXPECT_EQ(destination_url, req->url_chain()[1]);
4162
4163   LoadTimingInfo load_timing_info_before_redirect;
4164   EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeRedirect(
4165       &load_timing_info_before_redirect));
4166   TestLoadTimingNotReused(load_timing_info_before_redirect,
4167                           CONNECT_TIMING_HAS_DNS_TIMES);
4168
4169   LoadTimingInfo load_timing_info;
4170   req->GetLoadTimingInfo(&load_timing_info);
4171   TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
4172
4173   // Check that a new socket was used on redirect, since the server does not
4174   // supposed keep-alive sockets, and that the times before the redirect are
4175   // before the ones recorded for the second request.
4176   EXPECT_NE(load_timing_info_before_redirect.socket_log_id,
4177             load_timing_info.socket_log_id);
4178   EXPECT_LE(load_timing_info_before_redirect.receive_headers_end,
4179             load_timing_info.connect_timing.connect_start);
4180 }
4181
4182 TEST_F(URLRequestTestHTTP, MultipleRedirectTest) {
4183   ASSERT_TRUE(test_server_.Start());
4184
4185   GURL destination_url = test_server_.GetURL(std::string());
4186   GURL middle_redirect_url =
4187       test_server_.GetURL("server-redirect?" + destination_url.spec());
4188   GURL original_url = test_server_.GetURL(
4189       "server-redirect?" + middle_redirect_url.spec());
4190   TestDelegate d;
4191   scoped_ptr<URLRequest> req(
4192       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
4193   req->Start();
4194   base::RunLoop().Run();
4195
4196   EXPECT_EQ(1, d.response_started_count());
4197   EXPECT_EQ(2, d.received_redirect_count());
4198   EXPECT_EQ(destination_url, req->url());
4199   EXPECT_EQ(original_url, req->original_url());
4200   ASSERT_EQ(3U, req->url_chain().size());
4201   EXPECT_EQ(original_url, req->url_chain()[0]);
4202   EXPECT_EQ(middle_redirect_url, req->url_chain()[1]);
4203   EXPECT_EQ(destination_url, req->url_chain()[2]);
4204 }
4205
4206 // First and second pieces of information logged by delegates to URLRequests.
4207 const char kFirstDelegateInfo[] = "Wonderful delegate";
4208 const char kSecondDelegateInfo[] = "Exciting delegate";
4209
4210 // Logs delegate information to a URLRequest.  The first string is logged
4211 // synchronously on Start(), using DELEGATE_INFO_DEBUG_ONLY.  The second is
4212 // logged asynchronously, using DELEGATE_INFO_DISPLAY_TO_USER.  Then
4213 // another asynchronous call is used to clear the delegate information
4214 // before calling a callback.  The object then deletes itself.
4215 class AsyncDelegateLogger : public base::RefCounted<AsyncDelegateLogger> {
4216  public:
4217   typedef base::Callback<void()> Callback;
4218
4219   // Each time delegate information is added to the URLRequest, the resulting
4220   // load state is checked.  The expected load state after each request is
4221   // passed in as an argument.
4222   static void Run(URLRequest* url_request,
4223                   LoadState expected_first_load_state,
4224                   LoadState expected_second_load_state,
4225                   LoadState expected_third_load_state,
4226                   const Callback& callback) {
4227     AsyncDelegateLogger* logger = new AsyncDelegateLogger(
4228         url_request,
4229         expected_first_load_state,
4230         expected_second_load_state,
4231         expected_third_load_state,
4232         callback);
4233     logger->Start();
4234   }
4235
4236   // Checks that the log entries, starting with log_position, contain the
4237   // DELEGATE_INFO NetLog events that an AsyncDelegateLogger should have
4238   // recorded.  Returns the index of entry after the expected number of
4239   // events this logged, or entries.size() if there aren't enough entries.
4240   static size_t CheckDelegateInfo(const TestNetLogEntry::List& entries,
4241                                   size_t log_position) {
4242     // There should be 4 DELEGATE_INFO events: Two begins and two ends.
4243     if (log_position + 3 >= entries.size()) {
4244       ADD_FAILURE() << "Not enough log entries";
4245       return entries.size();
4246     }
4247     std::string delegate_info;
4248     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
4249     EXPECT_EQ(NetLog::PHASE_BEGIN, entries[log_position].phase);
4250     EXPECT_TRUE(entries[log_position].GetStringValue("delegate_info",
4251                                                      &delegate_info));
4252     EXPECT_EQ(kFirstDelegateInfo, delegate_info);
4253
4254     ++log_position;
4255     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
4256     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4257
4258     ++log_position;
4259     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
4260     EXPECT_EQ(NetLog::PHASE_BEGIN, entries[log_position].phase);
4261     EXPECT_TRUE(entries[log_position].GetStringValue("delegate_info",
4262                                                      &delegate_info));
4263     EXPECT_EQ(kSecondDelegateInfo, delegate_info);
4264
4265     ++log_position;
4266     EXPECT_EQ(NetLog::TYPE_DELEGATE_INFO, entries[log_position].type);
4267     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4268
4269     return log_position + 1;
4270   }
4271
4272   // Find delegate request begin and end messages for OnBeforeNetworkStart.
4273   // Returns the position of the end message.
4274   static size_t ExpectBeforeNetworkEvents(const TestNetLogEntry::List& entries,
4275                                           size_t log_position) {
4276     log_position =
4277         ExpectLogContainsSomewhereAfter(entries,
4278                                         log_position,
4279                                         NetLog::TYPE_URL_REQUEST_DELEGATE,
4280                                         NetLog::PHASE_BEGIN);
4281     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE,
4282               entries[log_position + 1].type);
4283     EXPECT_EQ(NetLog::PHASE_END, entries[log_position + 1].phase);
4284     return log_position + 1;
4285   }
4286
4287  private:
4288   friend class base::RefCounted<AsyncDelegateLogger>;
4289
4290   AsyncDelegateLogger(URLRequest* url_request,
4291                       LoadState expected_first_load_state,
4292                       LoadState expected_second_load_state,
4293                       LoadState expected_third_load_state,
4294                       const Callback& callback)
4295       : url_request_(url_request),
4296         expected_first_load_state_(expected_first_load_state),
4297         expected_second_load_state_(expected_second_load_state),
4298         expected_third_load_state_(expected_third_load_state),
4299         callback_(callback) {
4300   }
4301
4302   ~AsyncDelegateLogger() {}
4303
4304   void Start() {
4305     url_request_->LogBlockedBy(kFirstDelegateInfo);
4306     LoadStateWithParam load_state = url_request_->GetLoadState();
4307     EXPECT_EQ(expected_first_load_state_, load_state.state);
4308     EXPECT_NE(ASCIIToUTF16(kFirstDelegateInfo), load_state.param);
4309     base::ThreadTaskRunnerHandle::Get()->PostTask(
4310         FROM_HERE, base::Bind(&AsyncDelegateLogger::LogSecondDelegate, this));
4311   }
4312
4313   void LogSecondDelegate() {
4314     url_request_->LogAndReportBlockedBy(kSecondDelegateInfo);
4315     LoadStateWithParam load_state = url_request_->GetLoadState();
4316     EXPECT_EQ(expected_second_load_state_, load_state.state);
4317     if (expected_second_load_state_ == LOAD_STATE_WAITING_FOR_DELEGATE) {
4318       EXPECT_EQ(ASCIIToUTF16(kSecondDelegateInfo), load_state.param);
4319     } else {
4320       EXPECT_NE(ASCIIToUTF16(kSecondDelegateInfo), load_state.param);
4321     }
4322     base::ThreadTaskRunnerHandle::Get()->PostTask(
4323         FROM_HERE, base::Bind(&AsyncDelegateLogger::LogComplete, this));
4324   }
4325
4326   void LogComplete() {
4327     url_request_->LogUnblocked();
4328     LoadStateWithParam load_state = url_request_->GetLoadState();
4329     EXPECT_EQ(expected_third_load_state_, load_state.state);
4330     if (expected_second_load_state_ == LOAD_STATE_WAITING_FOR_DELEGATE)
4331       EXPECT_EQ(base::string16(), load_state.param);
4332     callback_.Run();
4333   }
4334
4335   URLRequest* url_request_;
4336   const int expected_first_load_state_;
4337   const int expected_second_load_state_;
4338   const int expected_third_load_state_;
4339   const Callback callback_;
4340
4341   DISALLOW_COPY_AND_ASSIGN(AsyncDelegateLogger);
4342 };
4343
4344 // NetworkDelegate that logs delegate information before a request is started,
4345 // before headers are sent, when headers are read, and when auth information
4346 // is requested.  Uses AsyncDelegateLogger.
4347 class AsyncLoggingNetworkDelegate : public TestNetworkDelegate {
4348  public:
4349   AsyncLoggingNetworkDelegate() {}
4350   ~AsyncLoggingNetworkDelegate() override {}
4351
4352   // NetworkDelegate implementation.
4353   int OnBeforeURLRequest(URLRequest* request,
4354                          const CompletionCallback& callback,
4355                          GURL* new_url) override {
4356     TestNetworkDelegate::OnBeforeURLRequest(request, callback, new_url);
4357     return RunCallbackAsynchronously(request, callback);
4358   }
4359
4360   int OnBeforeSendHeaders(URLRequest* request,
4361                           const CompletionCallback& callback,
4362                           HttpRequestHeaders* headers) override {
4363     TestNetworkDelegate::OnBeforeSendHeaders(request, callback, headers);
4364     return RunCallbackAsynchronously(request, callback);
4365   }
4366
4367   int OnHeadersReceived(
4368       URLRequest* request,
4369       const CompletionCallback& callback,
4370       const HttpResponseHeaders* original_response_headers,
4371       scoped_refptr<HttpResponseHeaders>* override_response_headers,
4372       GURL* allowed_unsafe_redirect_url) override {
4373     TestNetworkDelegate::OnHeadersReceived(request,
4374                                            callback,
4375                                            original_response_headers,
4376                                            override_response_headers,
4377                                            allowed_unsafe_redirect_url);
4378     return RunCallbackAsynchronously(request, callback);
4379   }
4380
4381   NetworkDelegate::AuthRequiredResponse OnAuthRequired(
4382       URLRequest* request,
4383       const AuthChallengeInfo& auth_info,
4384       const AuthCallback& callback,
4385       AuthCredentials* credentials) override {
4386     AsyncDelegateLogger::Run(
4387         request,
4388         LOAD_STATE_WAITING_FOR_DELEGATE,
4389         LOAD_STATE_WAITING_FOR_DELEGATE,
4390         LOAD_STATE_WAITING_FOR_DELEGATE,
4391         base::Bind(&AsyncLoggingNetworkDelegate::SetAuthAndResume,
4392                    callback, credentials));
4393     return AUTH_REQUIRED_RESPONSE_IO_PENDING;
4394   }
4395
4396  private:
4397   static int RunCallbackAsynchronously(
4398       URLRequest* request,
4399       const CompletionCallback& callback) {
4400     AsyncDelegateLogger::Run(
4401         request,
4402         LOAD_STATE_WAITING_FOR_DELEGATE,
4403         LOAD_STATE_WAITING_FOR_DELEGATE,
4404         LOAD_STATE_WAITING_FOR_DELEGATE,
4405         base::Bind(callback, OK));
4406     return ERR_IO_PENDING;
4407   }
4408
4409   static void SetAuthAndResume(const AuthCallback& callback,
4410                                AuthCredentials* credentials) {
4411     *credentials = AuthCredentials(kUser, kSecret);
4412     callback.Run(NetworkDelegate::AUTH_REQUIRED_RESPONSE_SET_AUTH);
4413   }
4414
4415   DISALLOW_COPY_AND_ASSIGN(AsyncLoggingNetworkDelegate);
4416 };
4417
4418 // URLRequest::Delegate that logs delegate information when the headers
4419 // are received, when each read completes, and during redirects.  Uses
4420 // AsyncDelegateLogger.  Can optionally cancel a request in any phase.
4421 //
4422 // Inherits from TestDelegate to reuse the TestDelegate code to handle
4423 // advancing to the next step in most cases, as well as cancellation.
4424 class AsyncLoggingUrlRequestDelegate : public TestDelegate {
4425  public:
4426   enum CancelStage {
4427     NO_CANCEL = 0,
4428     CANCEL_ON_RECEIVED_REDIRECT,
4429     CANCEL_ON_RESPONSE_STARTED,
4430     CANCEL_ON_READ_COMPLETED
4431   };
4432
4433   explicit AsyncLoggingUrlRequestDelegate(CancelStage cancel_stage)
4434       : cancel_stage_(cancel_stage) {
4435     if (cancel_stage == CANCEL_ON_RECEIVED_REDIRECT)
4436       set_cancel_in_received_redirect(true);
4437     else if (cancel_stage == CANCEL_ON_RESPONSE_STARTED)
4438       set_cancel_in_response_started(true);
4439     else if (cancel_stage == CANCEL_ON_READ_COMPLETED)
4440       set_cancel_in_received_data(true);
4441   }
4442   ~AsyncLoggingUrlRequestDelegate() override {}
4443
4444   // URLRequest::Delegate implementation:
4445   void OnReceivedRedirect(URLRequest* request,
4446                           const RedirectInfo& redirect_info,
4447                           bool* defer_redirect) override {
4448     *defer_redirect = true;
4449     AsyncDelegateLogger::Run(
4450         request,
4451         LOAD_STATE_WAITING_FOR_DELEGATE,
4452         LOAD_STATE_WAITING_FOR_DELEGATE,
4453         LOAD_STATE_WAITING_FOR_DELEGATE,
4454         base::Bind(
4455             &AsyncLoggingUrlRequestDelegate::OnReceivedRedirectLoggingComplete,
4456             base::Unretained(this), request, redirect_info));
4457   }
4458
4459   void OnResponseStarted(URLRequest* request) override {
4460     AsyncDelegateLogger::Run(
4461       request,
4462       LOAD_STATE_WAITING_FOR_DELEGATE,
4463       LOAD_STATE_WAITING_FOR_DELEGATE,
4464       LOAD_STATE_WAITING_FOR_DELEGATE,
4465       base::Bind(
4466           &AsyncLoggingUrlRequestDelegate::OnResponseStartedLoggingComplete,
4467           base::Unretained(this), request));
4468   }
4469
4470   void OnReadCompleted(URLRequest* request, int bytes_read) override {
4471     AsyncDelegateLogger::Run(
4472         request,
4473         LOAD_STATE_IDLE,
4474         LOAD_STATE_IDLE,
4475         LOAD_STATE_IDLE,
4476         base::Bind(
4477             &AsyncLoggingUrlRequestDelegate::AfterReadCompletedLoggingComplete,
4478             base::Unretained(this), request, bytes_read));
4479   }
4480
4481  private:
4482   void OnReceivedRedirectLoggingComplete(URLRequest* request,
4483                                          const RedirectInfo& redirect_info) {
4484     bool defer_redirect = false;
4485     TestDelegate::OnReceivedRedirect(request, redirect_info, &defer_redirect);
4486     // FollowDeferredRedirect should not be called after cancellation.
4487     if (cancel_stage_ == CANCEL_ON_RECEIVED_REDIRECT)
4488       return;
4489     if (!defer_redirect)
4490       request->FollowDeferredRedirect();
4491   }
4492
4493   void OnResponseStartedLoggingComplete(URLRequest* request) {
4494     // The parent class continues the request.
4495     TestDelegate::OnResponseStarted(request);
4496   }
4497
4498   void AfterReadCompletedLoggingComplete(URLRequest* request, int bytes_read) {
4499     // The parent class continues the request.
4500     TestDelegate::OnReadCompleted(request, bytes_read);
4501   }
4502
4503   const CancelStage cancel_stage_;
4504
4505   DISALLOW_COPY_AND_ASSIGN(AsyncLoggingUrlRequestDelegate);
4506 };
4507
4508 // Tests handling of delegate info before a request starts.
4509 TEST_F(URLRequestTestHTTP, DelegateInfoBeforeStart) {
4510   ASSERT_TRUE(test_server_.Start());
4511
4512   TestDelegate request_delegate;
4513   TestURLRequestContext context(true);
4514   context.set_network_delegate(NULL);
4515   context.set_net_log(&net_log_);
4516   context.Init();
4517
4518   {
4519     scoped_ptr<URLRequest> r(
4520         context.CreateRequest(test_server_.GetURL("empty.html"),
4521                               DEFAULT_PRIORITY, &request_delegate));
4522     LoadStateWithParam load_state = r->GetLoadState();
4523     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
4524     EXPECT_EQ(base::string16(), load_state.param);
4525
4526     AsyncDelegateLogger::Run(
4527         r.get(),
4528         LOAD_STATE_WAITING_FOR_DELEGATE,
4529         LOAD_STATE_WAITING_FOR_DELEGATE,
4530         LOAD_STATE_IDLE,
4531         base::Bind(&URLRequest::Start, base::Unretained(r.get())));
4532
4533     base::RunLoop().Run();
4534
4535     EXPECT_EQ(200, r->GetResponseCode());
4536     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
4537   }
4538
4539   TestNetLogEntry::List entries;
4540   net_log_.GetEntries(&entries);
4541   size_t log_position = ExpectLogContainsSomewhereAfter(
4542       entries,
4543       0,
4544       NetLog::TYPE_DELEGATE_INFO,
4545       NetLog::PHASE_BEGIN);
4546
4547   log_position = AsyncDelegateLogger::CheckDelegateInfo(entries, log_position);
4548
4549   // Nothing else should add any delegate info to the request.
4550   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4551       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4552 }
4553
4554 // Tests handling of delegate info from a network delegate.
4555 TEST_F(URLRequestTestHTTP, NetworkDelegateInfo) {
4556   ASSERT_TRUE(test_server_.Start());
4557
4558   TestDelegate request_delegate;
4559   AsyncLoggingNetworkDelegate network_delegate;
4560   TestURLRequestContext context(true);
4561   context.set_network_delegate(&network_delegate);
4562   context.set_net_log(&net_log_);
4563   context.Init();
4564
4565   {
4566     scoped_ptr<URLRequest> r(
4567         context.CreateRequest(test_server_.GetURL("simple.html"),
4568                               DEFAULT_PRIORITY, &request_delegate));
4569     LoadStateWithParam load_state = r->GetLoadState();
4570     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
4571     EXPECT_EQ(base::string16(), load_state.param);
4572
4573     r->Start();
4574     base::RunLoop().Run();
4575
4576     EXPECT_EQ(200, r->GetResponseCode());
4577     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
4578     EXPECT_EQ(1, network_delegate.created_requests());
4579     EXPECT_EQ(0, network_delegate.destroyed_requests());
4580   }
4581   EXPECT_EQ(1, network_delegate.destroyed_requests());
4582
4583   size_t log_position = 0;
4584   TestNetLogEntry::List entries;
4585   net_log_.GetEntries(&entries);
4586   for (size_t i = 0; i < 3; ++i) {
4587     log_position = ExpectLogContainsSomewhereAfter(
4588         entries,
4589         log_position + 1,
4590         NetLog::TYPE_URL_REQUEST_DELEGATE,
4591         NetLog::PHASE_BEGIN);
4592
4593     log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4594                                                           log_position + 1);
4595
4596     ASSERT_LT(log_position, entries.size());
4597     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4598     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4599
4600     if (i == 1) {
4601       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
4602           entries, log_position + 1);
4603     }
4604   }
4605
4606   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4607       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4608 }
4609
4610 // Tests handling of delegate info from a network delegate in the case of an
4611 // HTTP redirect.
4612 TEST_F(URLRequestTestHTTP, NetworkDelegateInfoRedirect) {
4613   ASSERT_TRUE(test_server_.Start());
4614
4615   TestDelegate request_delegate;
4616   AsyncLoggingNetworkDelegate network_delegate;
4617   TestURLRequestContext context(true);
4618   context.set_network_delegate(&network_delegate);
4619   context.set_net_log(&net_log_);
4620   context.Init();
4621
4622   {
4623     scoped_ptr<URLRequest> r(context.CreateRequest(
4624         test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
4625         &request_delegate));
4626     LoadStateWithParam load_state = r->GetLoadState();
4627     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
4628     EXPECT_EQ(base::string16(), load_state.param);
4629
4630     r->Start();
4631     base::RunLoop().Run();
4632
4633     EXPECT_EQ(200, r->GetResponseCode());
4634     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
4635     EXPECT_EQ(2, network_delegate.created_requests());
4636     EXPECT_EQ(0, network_delegate.destroyed_requests());
4637   }
4638   EXPECT_EQ(1, network_delegate.destroyed_requests());
4639
4640   size_t log_position = 0;
4641   TestNetLogEntry::List entries;
4642   net_log_.GetEntries(&entries);
4643   // The NetworkDelegate logged information in OnBeforeURLRequest,
4644   // OnBeforeSendHeaders, and OnHeadersReceived.
4645   for (size_t i = 0; i < 3; ++i) {
4646     log_position = ExpectLogContainsSomewhereAfter(
4647         entries,
4648         log_position + 1,
4649         NetLog::TYPE_URL_REQUEST_DELEGATE,
4650         NetLog::PHASE_BEGIN);
4651
4652     log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4653                                                           log_position + 1);
4654
4655     ASSERT_LT(log_position, entries.size());
4656     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4657     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4658
4659     if (i == 1) {
4660       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
4661           entries, log_position + 1);
4662     }
4663   }
4664
4665   // The URLRequest::Delegate then gets informed about the redirect.
4666   log_position = ExpectLogContainsSomewhereAfter(
4667       entries,
4668       log_position + 1,
4669       NetLog::TYPE_URL_REQUEST_DELEGATE,
4670       NetLog::PHASE_BEGIN);
4671
4672   // The NetworkDelegate logged information in the same three events as before.
4673   for (size_t i = 0; i < 3; ++i) {
4674     log_position = ExpectLogContainsSomewhereAfter(
4675         entries,
4676         log_position + 1,
4677         NetLog::TYPE_URL_REQUEST_DELEGATE,
4678         NetLog::PHASE_BEGIN);
4679
4680     log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4681                                                           log_position + 1);
4682
4683     ASSERT_LT(log_position, entries.size());
4684     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4685     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4686   }
4687
4688   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4689       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4690 }
4691
4692 // Tests handling of delegate info from a network delegate in the case of HTTP
4693 // AUTH.
4694 TEST_F(URLRequestTestHTTP, NetworkDelegateInfoAuth) {
4695   ASSERT_TRUE(test_server_.Start());
4696
4697   TestDelegate request_delegate;
4698   AsyncLoggingNetworkDelegate network_delegate;
4699   TestURLRequestContext context(true);
4700   context.set_network_delegate(&network_delegate);
4701   context.set_net_log(&net_log_);
4702   context.Init();
4703
4704   {
4705     scoped_ptr<URLRequest> r(
4706         context.CreateRequest(test_server_.GetURL("auth-basic"),
4707                               DEFAULT_PRIORITY, &request_delegate));
4708     LoadStateWithParam load_state = r->GetLoadState();
4709     EXPECT_EQ(LOAD_STATE_IDLE, load_state.state);
4710     EXPECT_EQ(base::string16(), load_state.param);
4711
4712     r->Start();
4713     base::RunLoop().Run();
4714
4715     EXPECT_EQ(200, r->GetResponseCode());
4716     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
4717     EXPECT_EQ(1, network_delegate.created_requests());
4718     EXPECT_EQ(0, network_delegate.destroyed_requests());
4719   }
4720   EXPECT_EQ(1, network_delegate.destroyed_requests());
4721
4722   size_t log_position = 0;
4723   TestNetLogEntry::List entries;
4724   net_log_.GetEntries(&entries);
4725   // The NetworkDelegate should have logged information in OnBeforeURLRequest,
4726   // OnBeforeSendHeaders, OnHeadersReceived, OnAuthRequired, and then again in
4727   // OnBeforeURLRequest and OnBeforeSendHeaders.
4728   for (size_t i = 0; i < 6; ++i) {
4729     log_position = ExpectLogContainsSomewhereAfter(
4730         entries,
4731         log_position + 1,
4732         NetLog::TYPE_URL_REQUEST_DELEGATE,
4733         NetLog::PHASE_BEGIN);
4734
4735     log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4736                                                           log_position + 1);
4737
4738     ASSERT_LT(log_position, entries.size());
4739     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4740     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4741
4742     if (i == 1) {
4743       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
4744           entries, log_position + 1);
4745     }
4746   }
4747
4748   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4749       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4750 }
4751
4752 // Tests handling of delegate info from a URLRequest::Delegate.
4753 TEST_F(URLRequestTestHTTP, URLRequestDelegateInfo) {
4754   ASSERT_TRUE(test_server_.Start());
4755
4756   AsyncLoggingUrlRequestDelegate request_delegate(
4757       AsyncLoggingUrlRequestDelegate::NO_CANCEL);
4758   TestURLRequestContext context(true);
4759   context.set_network_delegate(NULL);
4760   context.set_net_log(&net_log_);
4761   context.Init();
4762
4763   {
4764     // A chunked response with delays between chunks is used to make sure that
4765     // attempts by the URLRequest delegate to log information while reading the
4766     // body are ignored.  Since they are ignored, this test is robust against
4767     // the possibility of multiple reads being combined in the unlikely event
4768     // that it occurs.
4769     scoped_ptr<URLRequest> r(context.CreateRequest(
4770         test_server_.GetURL("chunked?waitBetweenChunks=20"), DEFAULT_PRIORITY,
4771         &request_delegate));
4772     LoadStateWithParam load_state = r->GetLoadState();
4773     r->Start();
4774     base::RunLoop().Run();
4775
4776     EXPECT_EQ(200, r->GetResponseCode());
4777     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
4778   }
4779
4780   TestNetLogEntry::List entries;
4781   net_log_.GetEntries(&entries);
4782
4783   size_t log_position = 0;
4784
4785   log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
4786       entries, log_position);
4787
4788   // The delegate info should only have been logged on header complete.  Other
4789   // times it should silently be ignored.
4790   log_position =
4791       ExpectLogContainsSomewhereAfter(entries,
4792                                       log_position + 1,
4793                                       NetLog::TYPE_URL_REQUEST_DELEGATE,
4794                                       NetLog::PHASE_BEGIN);
4795
4796   log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4797                                                         log_position + 1);
4798
4799   ASSERT_LT(log_position, entries.size());
4800   EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4801   EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4802
4803   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4804       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4805   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4806       entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
4807 }
4808
4809 // Tests handling of delegate info from a URLRequest::Delegate in the case of
4810 // an HTTP redirect.
4811 TEST_F(URLRequestTestHTTP, URLRequestDelegateInfoOnRedirect) {
4812   ASSERT_TRUE(test_server_.Start());
4813
4814   AsyncLoggingUrlRequestDelegate request_delegate(
4815       AsyncLoggingUrlRequestDelegate::NO_CANCEL);
4816   TestURLRequestContext context(true);
4817   context.set_network_delegate(NULL);
4818   context.set_net_log(&net_log_);
4819   context.Init();
4820
4821   {
4822     scoped_ptr<URLRequest> r(context.CreateRequest(
4823         test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
4824         &request_delegate));
4825     LoadStateWithParam load_state = r->GetLoadState();
4826     r->Start();
4827     base::RunLoop().Run();
4828
4829     EXPECT_EQ(200, r->GetResponseCode());
4830     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
4831   }
4832
4833   TestNetLogEntry::List entries;
4834   net_log_.GetEntries(&entries);
4835
4836   // Delegate info should only have been logged in OnReceivedRedirect and
4837   // OnResponseStarted.
4838   size_t log_position = 0;
4839   for (int i = 0; i < 2; ++i) {
4840     if (i == 0) {
4841       log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
4842                          entries, log_position) + 1;
4843     }
4844
4845     log_position = ExpectLogContainsSomewhereAfter(
4846             entries,
4847             log_position,
4848             NetLog::TYPE_URL_REQUEST_DELEGATE,
4849             NetLog::PHASE_BEGIN);
4850
4851     log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4852                                                           log_position + 1);
4853
4854     ASSERT_LT(log_position, entries.size());
4855     EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4856     EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4857   }
4858
4859   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4860       entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4861   EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4862       entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
4863 }
4864
4865 // Tests handling of delegate info from a URLRequest::Delegate in the case of
4866 // an HTTP redirect, with cancellation at various points.
4867 TEST_F(URLRequestTestHTTP, URLRequestDelegateOnRedirectCancelled) {
4868   ASSERT_TRUE(test_server_.Start());
4869
4870   const AsyncLoggingUrlRequestDelegate::CancelStage kCancelStages[] = {
4871     AsyncLoggingUrlRequestDelegate::CANCEL_ON_RECEIVED_REDIRECT,
4872     AsyncLoggingUrlRequestDelegate::CANCEL_ON_RESPONSE_STARTED,
4873     AsyncLoggingUrlRequestDelegate::CANCEL_ON_READ_COMPLETED,
4874   };
4875
4876   for (size_t test_case = 0; test_case < arraysize(kCancelStages);
4877        ++test_case) {
4878     AsyncLoggingUrlRequestDelegate request_delegate(kCancelStages[test_case]);
4879     TestURLRequestContext context(true);
4880     TestNetLog net_log;
4881     context.set_network_delegate(NULL);
4882     context.set_net_log(&net_log);
4883     context.Init();
4884
4885     {
4886       scoped_ptr<URLRequest> r(context.CreateRequest(
4887           test_server_.GetURL("server-redirect?simple.html"), DEFAULT_PRIORITY,
4888           &request_delegate));
4889       LoadStateWithParam load_state = r->GetLoadState();
4890       r->Start();
4891       base::RunLoop().Run();
4892       EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
4893     }
4894
4895     TestNetLogEntry::List entries;
4896     net_log.GetEntries(&entries);
4897
4898     // Delegate info is always logged in both OnReceivedRedirect and
4899     // OnResponseStarted.  In the CANCEL_ON_RECEIVED_REDIRECT, the
4900     // OnResponseStarted delegate call is after cancellation, but logging is
4901     // still currently supported in that call.
4902     size_t log_position = 0;
4903     for (int i = 0; i < 2; ++i) {
4904       if (i == 0) {
4905         log_position = AsyncDelegateLogger::ExpectBeforeNetworkEvents(
4906                            entries, log_position) + 1;
4907       }
4908
4909       log_position = ExpectLogContainsSomewhereAfter(
4910               entries,
4911               log_position,
4912               NetLog::TYPE_URL_REQUEST_DELEGATE,
4913               NetLog::PHASE_BEGIN);
4914
4915       log_position = AsyncDelegateLogger::CheckDelegateInfo(entries,
4916                                                             log_position + 1);
4917
4918       ASSERT_LT(log_position, entries.size());
4919       EXPECT_EQ(NetLog::TYPE_URL_REQUEST_DELEGATE, entries[log_position].type);
4920       EXPECT_EQ(NetLog::PHASE_END, entries[log_position].phase);
4921     }
4922
4923     EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4924         entries, log_position + 1, NetLog::TYPE_DELEGATE_INFO));
4925     EXPECT_FALSE(LogContainsEntryWithTypeAfter(
4926         entries, log_position + 1, NetLog::TYPE_URL_REQUEST_DELEGATE));
4927   }
4928 }
4929
4930 namespace {
4931
4932 const char kExtraHeader[] = "Allow-Snafu";
4933 const char kExtraValue[] = "fubar";
4934
4935 class RedirectWithAdditionalHeadersDelegate : public TestDelegate {
4936   void OnReceivedRedirect(URLRequest* request,
4937                           const RedirectInfo& redirect_info,
4938                           bool* defer_redirect) override {
4939     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
4940     request->SetExtraRequestHeaderByName(kExtraHeader, kExtraValue, false);
4941   }
4942 };
4943
4944 }  // namespace
4945
4946 TEST_F(URLRequestTestHTTP, RedirectWithAdditionalHeadersTest) {
4947   ASSERT_TRUE(test_server_.Start());
4948
4949   GURL destination_url = test_server_.GetURL(
4950       "echoheader?" + std::string(kExtraHeader));
4951   GURL original_url = test_server_.GetURL(
4952       "server-redirect?" + destination_url.spec());
4953   RedirectWithAdditionalHeadersDelegate d;
4954   scoped_ptr<URLRequest> req(
4955       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
4956   req->Start();
4957   base::RunLoop().Run();
4958
4959   std::string value;
4960   const HttpRequestHeaders& headers = req->extra_request_headers();
4961   EXPECT_TRUE(headers.GetHeader(kExtraHeader, &value));
4962   EXPECT_EQ(kExtraValue, value);
4963   EXPECT_FALSE(req->is_pending());
4964   EXPECT_FALSE(req->is_redirecting());
4965   EXPECT_EQ(kExtraValue, d.data_received());
4966 }
4967
4968 namespace {
4969
4970 const char kExtraHeaderToRemove[] = "To-Be-Removed";
4971
4972 class RedirectWithHeaderRemovalDelegate : public TestDelegate {
4973   void OnReceivedRedirect(URLRequest* request,
4974                           const RedirectInfo& redirect_info,
4975                           bool* defer_redirect) override {
4976     TestDelegate::OnReceivedRedirect(request, redirect_info, defer_redirect);
4977     request->RemoveRequestHeaderByName(kExtraHeaderToRemove);
4978   }
4979 };
4980
4981 }  // namespace
4982
4983 TEST_F(URLRequestTestHTTP, RedirectWithHeaderRemovalTest) {
4984   ASSERT_TRUE(test_server_.Start());
4985
4986   GURL destination_url = test_server_.GetURL(
4987       "echoheader?" + std::string(kExtraHeaderToRemove));
4988   GURL original_url = test_server_.GetURL(
4989       "server-redirect?" + destination_url.spec());
4990   RedirectWithHeaderRemovalDelegate d;
4991   scoped_ptr<URLRequest> req(
4992       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
4993   req->SetExtraRequestHeaderByName(kExtraHeaderToRemove, "dummy", false);
4994   req->Start();
4995   base::RunLoop().Run();
4996
4997   std::string value;
4998   const HttpRequestHeaders& headers = req->extra_request_headers();
4999   EXPECT_FALSE(headers.GetHeader(kExtraHeaderToRemove, &value));
5000   EXPECT_FALSE(req->is_pending());
5001   EXPECT_FALSE(req->is_redirecting());
5002   EXPECT_EQ("None", d.data_received());
5003 }
5004
5005 TEST_F(URLRequestTestHTTP, CancelTest) {
5006   TestDelegate d;
5007   {
5008     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5009         GURL("http://www.google.com/"), DEFAULT_PRIORITY, &d));
5010
5011     r->Start();
5012     EXPECT_TRUE(r->is_pending());
5013
5014     r->Cancel();
5015
5016     base::RunLoop().Run();
5017
5018     // We expect to receive OnResponseStarted even though the request has been
5019     // cancelled.
5020     EXPECT_EQ(1, d.response_started_count());
5021     EXPECT_EQ(0, d.bytes_received());
5022     EXPECT_FALSE(d.received_data_before_response());
5023   }
5024 }
5025
5026 TEST_F(URLRequestTestHTTP, CancelTest2) {
5027   ASSERT_TRUE(test_server_.Start());
5028
5029   TestDelegate d;
5030   {
5031     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5032         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
5033
5034     d.set_cancel_in_response_started(true);
5035
5036     r->Start();
5037     EXPECT_TRUE(r->is_pending());
5038
5039     base::RunLoop().Run();
5040
5041     EXPECT_EQ(1, d.response_started_count());
5042     EXPECT_EQ(0, d.bytes_received());
5043     EXPECT_FALSE(d.received_data_before_response());
5044     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
5045   }
5046 }
5047
5048 TEST_F(URLRequestTestHTTP, CancelTest3) {
5049   ASSERT_TRUE(test_server_.Start());
5050
5051   TestDelegate d;
5052   {
5053     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5054         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
5055
5056     d.set_cancel_in_received_data(true);
5057
5058     r->Start();
5059     EXPECT_TRUE(r->is_pending());
5060
5061     base::RunLoop().Run();
5062
5063     EXPECT_EQ(1, d.response_started_count());
5064     // There is no guarantee about how much data was received
5065     // before the cancel was issued.  It could have been 0 bytes,
5066     // or it could have been all the bytes.
5067     // EXPECT_EQ(0, d.bytes_received());
5068     EXPECT_FALSE(d.received_data_before_response());
5069     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
5070   }
5071 }
5072
5073 TEST_F(URLRequestTestHTTP, CancelTest4) {
5074   ASSERT_TRUE(test_server_.Start());
5075
5076   TestDelegate d;
5077   {
5078     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5079         test_server_.GetURL(std::string()), DEFAULT_PRIORITY, &d));
5080
5081     r->Start();
5082     EXPECT_TRUE(r->is_pending());
5083
5084     // The request will be implicitly canceled when it is destroyed. The
5085     // test delegate must not post a quit message when this happens because
5086     // this test doesn't actually have a message loop. The quit message would
5087     // get put on this thread's message queue and the next test would exit
5088     // early, causing problems.
5089     d.set_quit_on_complete(false);
5090   }
5091   // expect things to just cleanup properly.
5092
5093   // we won't actually get a received reponse here because we've never run the
5094   // message loop
5095   EXPECT_FALSE(d.received_data_before_response());
5096   EXPECT_EQ(0, d.bytes_received());
5097 }
5098
5099 TEST_F(URLRequestTestHTTP, CancelTest5) {
5100   ASSERT_TRUE(test_server_.Start());
5101
5102   // populate cache
5103   {
5104     TestDelegate d;
5105     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5106         test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d));
5107     r->Start();
5108     base::RunLoop().Run();
5109     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
5110   }
5111
5112   // cancel read from cache (see bug 990242)
5113   {
5114     TestDelegate d;
5115     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5116         test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d));
5117     r->Start();
5118     r->Cancel();
5119     base::RunLoop().Run();
5120
5121     EXPECT_EQ(URLRequestStatus::CANCELED, r->status().status());
5122     EXPECT_EQ(1, d.response_started_count());
5123     EXPECT_EQ(0, d.bytes_received());
5124     EXPECT_FALSE(d.received_data_before_response());
5125   }
5126 }
5127
5128 TEST_F(URLRequestTestHTTP, PostTest) {
5129   ASSERT_TRUE(test_server_.Start());
5130   HTTPUploadDataOperationTest("POST");
5131 }
5132
5133 TEST_F(URLRequestTestHTTP, PutTest) {
5134   ASSERT_TRUE(test_server_.Start());
5135   HTTPUploadDataOperationTest("PUT");
5136 }
5137
5138 TEST_F(URLRequestTestHTTP, PostEmptyTest) {
5139   ASSERT_TRUE(test_server_.Start());
5140
5141   TestDelegate d;
5142   {
5143     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5144         test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
5145     r->set_method("POST");
5146
5147     r->Start();
5148     EXPECT_TRUE(r->is_pending());
5149
5150     base::RunLoop().Run();
5151
5152     ASSERT_EQ(1, d.response_started_count())
5153         << "request failed: " << r->status().status()
5154         << ", error: " << r->status().error();
5155
5156     EXPECT_FALSE(d.received_data_before_response());
5157     EXPECT_TRUE(d.data_received().empty());
5158   }
5159 }
5160
5161 TEST_F(URLRequestTestHTTP, PostFileTest) {
5162   ASSERT_TRUE(test_server_.Start());
5163
5164   TestDelegate d;
5165   {
5166     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5167         test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
5168     r->set_method("POST");
5169
5170     base::FilePath dir;
5171     PathService::Get(base::DIR_EXE, &dir);
5172     base::SetCurrentDirectory(dir);
5173
5174     ScopedVector<UploadElementReader> element_readers;
5175
5176     base::FilePath path;
5177     PathService::Get(base::DIR_SOURCE_ROOT, &path);
5178     path = path.Append(kTestFilePath);
5179     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
5180     element_readers.push_back(
5181         new UploadFileElementReader(base::ThreadTaskRunnerHandle::Get().get(),
5182                                     path, 0, kuint64max, base::Time()));
5183     r->set_upload(make_scoped_ptr<UploadDataStream>(
5184         new ElementsUploadDataStream(element_readers.Pass(), 0)));
5185
5186     r->Start();
5187     EXPECT_TRUE(r->is_pending());
5188
5189     base::RunLoop().Run();
5190
5191     int64 size64 = 0;
5192     ASSERT_EQ(true, base::GetFileSize(path, &size64));
5193     ASSERT_LE(size64, std::numeric_limits<int>::max());
5194     int size = static_cast<int>(size64);
5195     scoped_ptr<char[]> buf(new char[size]);
5196
5197     ASSERT_EQ(size, base::ReadFile(path, buf.get(), size));
5198
5199     ASSERT_EQ(1, d.response_started_count())
5200         << "request failed: " << r->status().status()
5201         << ", error: " << r->status().error();
5202
5203     EXPECT_FALSE(d.received_data_before_response());
5204
5205     EXPECT_EQ(size, d.bytes_received());
5206     EXPECT_EQ(std::string(&buf[0], size), d.data_received());
5207   }
5208 }
5209
5210 TEST_F(URLRequestTestHTTP, PostUnreadableFileTest) {
5211   ASSERT_TRUE(test_server_.Start());
5212
5213   TestDelegate d;
5214   {
5215     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5216         test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
5217     r->set_method("POST");
5218
5219     ScopedVector<UploadElementReader> element_readers;
5220
5221     element_readers.push_back(new UploadFileElementReader(
5222         base::ThreadTaskRunnerHandle::Get().get(),
5223         base::FilePath(FILE_PATH_LITERAL(
5224             "c:\\path\\to\\non\\existant\\file.randomness.12345")),
5225         0, kuint64max, base::Time()));
5226     r->set_upload(make_scoped_ptr<UploadDataStream>(
5227         new ElementsUploadDataStream(element_readers.Pass(), 0)));
5228
5229     r->Start();
5230     EXPECT_TRUE(r->is_pending());
5231
5232     base::RunLoop().Run();
5233
5234     EXPECT_TRUE(d.request_failed());
5235     EXPECT_FALSE(d.received_data_before_response());
5236     EXPECT_EQ(0, d.bytes_received());
5237     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
5238     EXPECT_EQ(ERR_FILE_NOT_FOUND, r->status().error());
5239   }
5240 }
5241
5242 TEST_F(URLRequestTestHTTP, TestPostChunkedDataBeforeStart) {
5243   ASSERT_TRUE(test_server_.Start());
5244
5245   TestDelegate d;
5246   {
5247     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5248         test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
5249     r->EnableChunkedUpload();
5250     r->set_method("POST");
5251     AddChunksToUpload(r.get());
5252     r->Start();
5253     EXPECT_TRUE(r->is_pending());
5254
5255     base::RunLoop().Run();
5256
5257     VerifyReceivedDataMatchesChunks(r.get(), &d);
5258   }
5259 }
5260
5261 TEST_F(URLRequestTestHTTP, TestPostChunkedDataJustAfterStart) {
5262   ASSERT_TRUE(test_server_.Start());
5263
5264   TestDelegate d;
5265   {
5266     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5267         test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
5268     r->EnableChunkedUpload();
5269     r->set_method("POST");
5270     r->Start();
5271     EXPECT_TRUE(r->is_pending());
5272     AddChunksToUpload(r.get());
5273     base::RunLoop().Run();
5274
5275     VerifyReceivedDataMatchesChunks(r.get(), &d);
5276   }
5277 }
5278
5279 TEST_F(URLRequestTestHTTP, TestPostChunkedDataAfterStart) {
5280   ASSERT_TRUE(test_server_.Start());
5281
5282   TestDelegate d;
5283   {
5284     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5285         test_server_.GetURL("echo"), DEFAULT_PRIORITY, &d));
5286     r->EnableChunkedUpload();
5287     r->set_method("POST");
5288     r->Start();
5289     EXPECT_TRUE(r->is_pending());
5290
5291     base::RunLoop().RunUntilIdle();
5292     AddChunksToUpload(r.get());
5293     base::RunLoop().Run();
5294
5295     VerifyReceivedDataMatchesChunks(r.get(), &d);
5296   }
5297 }
5298
5299 TEST_F(URLRequestTestHTTP, ResponseHeadersTest) {
5300   ASSERT_TRUE(test_server_.Start());
5301
5302   TestDelegate d;
5303   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
5304       test_server_.GetURL("files/with-headers.html"), DEFAULT_PRIORITY, &d));
5305   req->Start();
5306   base::RunLoop().Run();
5307
5308   const HttpResponseHeaders* headers = req->response_headers();
5309
5310   // Simple sanity check that response_info() accesses the same data.
5311   EXPECT_EQ(headers, req->response_info().headers.get());
5312
5313   std::string header;
5314   EXPECT_TRUE(headers->GetNormalizedHeader("cache-control", &header));
5315   EXPECT_EQ("private", header);
5316
5317   header.clear();
5318   EXPECT_TRUE(headers->GetNormalizedHeader("content-type", &header));
5319   EXPECT_EQ("text/html; charset=ISO-8859-1", header);
5320
5321   // The response has two "X-Multiple-Entries" headers.
5322   // This verfies our output has them concatenated together.
5323   header.clear();
5324   EXPECT_TRUE(headers->GetNormalizedHeader("x-multiple-entries", &header));
5325   EXPECT_EQ("a, b", header);
5326 }
5327
5328 TEST_F(URLRequestTestHTTP, ProcessSTS) {
5329   SpawnedTestServer::SSLOptions ssl_options(
5330       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5331   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5332                                       ssl_options,
5333                                       base::FilePath(kTestFilePath));
5334   ASSERT_TRUE(https_test_server.Start());
5335
5336   std::string test_server_hostname = https_test_server.GetURL("").host();
5337
5338   TestDelegate d;
5339   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5340       https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY,
5341       &d));
5342   request->Start();
5343   base::RunLoop().Run();
5344
5345   TransportSecurityState* security_state =
5346       default_context_.transport_security_state();
5347   TransportSecurityState::STSState sts_state;
5348   TransportSecurityState::PKPState pkp_state;
5349   EXPECT_TRUE(
5350       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
5351   EXPECT_FALSE(
5352       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
5353   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
5354             sts_state.upgrade_mode);
5355   EXPECT_TRUE(sts_state.include_subdomains);
5356   EXPECT_FALSE(pkp_state.include_subdomains);
5357 #if defined(OS_ANDROID)
5358   // Android's CertVerifyProc does not (yet) handle pins.
5359 #else
5360   EXPECT_FALSE(pkp_state.HasPublicKeyPins());
5361 #endif
5362 }
5363
5364 TEST_F(URLRequestTestHTTP, STSNotProcessedOnIP) {
5365   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5366                                       SpawnedTestServer::SSLOptions(),
5367                                       base::FilePath(kTestFilePath));
5368   ASSERT_TRUE(https_test_server.Start());
5369   // Make sure this test fails if the test server is changed to not
5370   // listen on an IP by default.
5371   ASSERT_TRUE(https_test_server.GetURL("").HostIsIPAddress());
5372   std::string test_server_hostname = https_test_server.GetURL("").host();
5373
5374   TestDelegate d;
5375   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5376       https_test_server.GetURL("files/hsts-headers.html"), DEFAULT_PRIORITY,
5377       &d));
5378   request->Start();
5379   base::RunLoop().Run();
5380
5381   TransportSecurityState* security_state =
5382       default_context_.transport_security_state();
5383   TransportSecurityState::STSState sts_state;
5384   EXPECT_FALSE(
5385       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
5386 }
5387
5388 // Android's CertVerifyProc does not (yet) handle pins. Therefore, it will
5389 // reject HPKP headers, and a test setting only HPKP headers will fail (no
5390 // PKPState present because header rejected).
5391 #if defined(OS_ANDROID)
5392 #define MAYBE_ProcessPKP DISABLED_ProcessPKP
5393 #define MAYBE_ProcessPKPAndSendReport DISABLED_ProcessPKPAndSendReport
5394 #define MAYBE_ProcessPKPReportOnly DISABLED_ProcessPKPReportOnly
5395 #define MAYBE_ProcessPKPReportOnlyWithNoViolation \
5396   DISABLED_ProcessPKPReportOnlyWithNoViolation
5397 #else
5398 #define MAYBE_ProcessPKP ProcessPKP
5399 #define MAYBE_ProcessPKPAndSendReport ProcessPKPAndSendReport
5400 #define MAYBE_ProcessPKPReportOnly ProcessPKPReportOnly
5401 #define MAYBE_ProcessPKPReportOnlyWithNoViolation \
5402   ProcessPKPReportOnlyWithNoViolation
5403 #endif
5404
5405 namespace {
5406 const char kHPKPReportUri[] = "https://hpkp-report.test";
5407 }  // namespace
5408
5409 // Tests that enabling HPKP on a domain does not affect the HSTS
5410 // validity/expiration.
5411 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKP) {
5412   GURL report_uri(kHPKPReportUri);
5413   SpawnedTestServer::SSLOptions ssl_options(
5414       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5415   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5416                                       ssl_options,
5417                                       base::FilePath(kTestFilePath));
5418   ASSERT_TRUE(https_test_server.Start());
5419
5420   std::string test_server_hostname = https_test_server.GetURL("").host();
5421
5422   TestDelegate d;
5423   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5424       https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY,
5425       &d));
5426   request->Start();
5427   base::RunLoop().Run();
5428
5429   TransportSecurityState* security_state =
5430       default_context_.transport_security_state();
5431   TransportSecurityState::STSState sts_state;
5432   TransportSecurityState::PKPState pkp_state;
5433   EXPECT_FALSE(
5434       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
5435   EXPECT_TRUE(
5436       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
5437   EXPECT_EQ(TransportSecurityState::STSState::MODE_DEFAULT,
5438             sts_state.upgrade_mode);
5439   EXPECT_FALSE(sts_state.include_subdomains);
5440   EXPECT_FALSE(pkp_state.include_subdomains);
5441   EXPECT_TRUE(pkp_state.HasPublicKeyPins());
5442   EXPECT_EQ(report_uri, pkp_state.report_uri);
5443   EXPECT_NE(sts_state.expiry, pkp_state.expiry);
5444 }
5445
5446 // Tests that reports get sent on HPKP violations when a report-uri is set.
5447 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKPAndSendReport) {
5448   GURL report_uri(kHPKPReportUri);
5449   SpawnedTestServer::SSLOptions ssl_options(
5450       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5451   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5452                                       ssl_options,
5453                                       base::FilePath(kTestFilePath));
5454
5455   ASSERT_TRUE(https_test_server.Start());
5456
5457   std::string test_server_hostname = https_test_server.GetURL("").host();
5458
5459   // Set up a pin for |test_server_hostname|.
5460   TransportSecurityState security_state;
5461   const base::Time current_time(base::Time::Now());
5462   const base::Time expiry = current_time + base::TimeDelta::FromSeconds(1000);
5463   HashValueVector hashes;
5464   HashValue hash1;
5465   HashValue hash2;
5466   // The values here don't matter, as long as they are different from
5467   // the mocked CertVerifyResult below.
5468   ASSERT_TRUE(
5469       hash1.FromString("sha256/1111111111111111111111111111111111111111111="));
5470   ASSERT_TRUE(
5471       hash2.FromString("sha256/2222222222222222222222222222222222222222222="));
5472   hashes.push_back(hash1);
5473   hashes.push_back(hash2);
5474   security_state.AddHPKP(test_server_hostname, expiry,
5475                          false, /* include subdomains */
5476                          hashes, report_uri);
5477
5478   MockCertificateReportSender mock_report_sender;
5479   security_state.SetReportSender(&mock_report_sender);
5480
5481   // Set up a MockCertVerifier to trigger a violation of the previously
5482   // set pin.
5483   scoped_refptr<X509Certificate> cert = https_test_server.GetCertificate();
5484   ASSERT_TRUE(cert);
5485
5486   MockCertVerifier cert_verifier;
5487   CertVerifyResult verify_result;
5488   verify_result.verified_cert = cert;
5489   verify_result.is_issued_by_known_root = true;
5490   HashValue hash3;
5491   ASSERT_TRUE(
5492       hash3.FromString("sha256/3333333333333333333333333333333333333333333="));
5493   verify_result.public_key_hashes.push_back(hash3);
5494   cert_verifier.AddResultForCert(cert.get(), verify_result, OK);
5495
5496   TestNetworkDelegate network_delegate;
5497   TestURLRequestContext context(true);
5498   context.set_transport_security_state(&security_state);
5499   context.set_network_delegate(&network_delegate);
5500   context.set_cert_verifier(&cert_verifier);
5501   context.Init();
5502
5503   // Now send a request to trigger the violation.
5504   TestDelegate d;
5505   scoped_ptr<URLRequest> violating_request(context.CreateRequest(
5506       https_test_server.GetURL("files/simple.html"), DEFAULT_PRIORITY, &d));
5507   violating_request->Start();
5508   base::RunLoop().Run();
5509
5510   // Check that a report was sent.
5511   EXPECT_EQ(report_uri, mock_report_sender.latest_report_uri());
5512   ASSERT_FALSE(mock_report_sender.latest_report().empty());
5513   scoped_ptr<base::Value> value(
5514       base::JSONReader::Read(mock_report_sender.latest_report()));
5515   ASSERT_TRUE(value);
5516   ASSERT_TRUE(value->IsType(base::Value::TYPE_DICTIONARY));
5517   base::DictionaryValue* report_dict;
5518   ASSERT_TRUE(value->GetAsDictionary(&report_dict));
5519   std::string report_hostname;
5520   EXPECT_TRUE(report_dict->GetString("hostname", &report_hostname));
5521   EXPECT_EQ(test_server_hostname, report_hostname);
5522 }
5523
5524 // Tests that reports get sent on requests with
5525 // Public-Key-Pins-Report-Only headers.
5526 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKPReportOnly) {
5527   GURL report_uri(kHPKPReportUri);
5528   SpawnedTestServer::SSLOptions ssl_options(
5529       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5530   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5531                                       ssl_options,
5532                                       base::FilePath(kTestFilePath));
5533
5534   ASSERT_TRUE(https_test_server.Start());
5535
5536   std::string test_server_hostname = https_test_server.GetURL("").host();
5537
5538   TransportSecurityState security_state;
5539   MockCertificateReportSender mock_report_sender;
5540   security_state.SetReportSender(&mock_report_sender);
5541
5542   // Set up a MockCertVerifier to violate the pin in the Report-Only
5543   // header.
5544   scoped_refptr<X509Certificate> cert = https_test_server.GetCertificate();
5545   ASSERT_TRUE(cert);
5546
5547   MockCertVerifier cert_verifier;
5548   CertVerifyResult verify_result;
5549   verify_result.verified_cert = cert;
5550   verify_result.is_issued_by_known_root = true;
5551   HashValue hash;
5552   // This value doesn't matter, as long as it is different from the pins
5553   // for the request to hpkp-headers-report-only.html.
5554   ASSERT_TRUE(
5555       hash.FromString("sha256/1111111111111111111111111111111111111111111="));
5556   verify_result.public_key_hashes.push_back(hash);
5557   cert_verifier.AddResultForCert(cert.get(), verify_result, OK);
5558
5559   TestNetworkDelegate network_delegate;
5560   TestURLRequestContext context(true);
5561   context.set_transport_security_state(&security_state);
5562   context.set_network_delegate(&network_delegate);
5563   context.set_cert_verifier(&cert_verifier);
5564   context.Init();
5565
5566   // Now send a request to trigger the violation.
5567   TestDelegate d;
5568   scoped_ptr<URLRequest> violating_request(context.CreateRequest(
5569       https_test_server.GetURL("files/hpkp-headers-report-only.html"),
5570       DEFAULT_PRIORITY, &d));
5571   violating_request->Start();
5572   base::RunLoop().Run();
5573
5574   // Check that a report was sent.
5575   EXPECT_EQ(report_uri, mock_report_sender.latest_report_uri());
5576   ASSERT_FALSE(mock_report_sender.latest_report().empty());
5577   scoped_ptr<base::Value> value(
5578       base::JSONReader::Read(mock_report_sender.latest_report()));
5579   ASSERT_TRUE(value);
5580   ASSERT_TRUE(value->IsType(base::Value::TYPE_DICTIONARY));
5581   base::DictionaryValue* report_dict;
5582   ASSERT_TRUE(value->GetAsDictionary(&report_dict));
5583   std::string report_hostname;
5584   EXPECT_TRUE(report_dict->GetString("hostname", &report_hostname));
5585   EXPECT_EQ(test_server_hostname, report_hostname);
5586 }
5587
5588 // Tests that reports do not get sent on requests with
5589 // Public-Key-Pins-Report-Only headers that don't have pin violations.
5590 TEST_F(URLRequestTestHTTP, MAYBE_ProcessPKPReportOnlyWithNoViolation) {
5591   GURL report_uri(kHPKPReportUri);
5592   SpawnedTestServer::SSLOptions ssl_options(
5593       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5594   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5595                                       ssl_options,
5596                                       base::FilePath(kTestFilePath));
5597
5598   ASSERT_TRUE(https_test_server.Start());
5599
5600   std::string test_server_hostname = https_test_server.GetURL("").host();
5601
5602   TransportSecurityState security_state;
5603   MockCertificateReportSender mock_report_sender;
5604   security_state.SetReportSender(&mock_report_sender);
5605
5606   TestNetworkDelegate network_delegate;
5607   MockCertVerifier mock_cert_verifier;
5608   TestURLRequestContext context(true);
5609   context.set_transport_security_state(&security_state);
5610   context.set_network_delegate(&network_delegate);
5611   context.set_cert_verifier(&mock_cert_verifier);
5612   mock_cert_verifier.set_default_result(OK);
5613   context.Init();
5614
5615   // Now send a request that does not trigger the violation.
5616   TestDelegate d;
5617   scoped_ptr<URLRequest> request(context.CreateRequest(
5618       https_test_server.GetURL("files/hpkp-headers-report-only.html"),
5619       DEFAULT_PRIORITY, &d));
5620   request->Start();
5621   base::RunLoop().Run();
5622
5623   // Check that a report was not sent.
5624   EXPECT_EQ(GURL(), mock_report_sender.latest_report_uri());
5625   EXPECT_EQ(std::string(), mock_report_sender.latest_report());
5626 }
5627
5628 TEST_F(URLRequestTestHTTP, PKPNotProcessedOnIP) {
5629   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5630                                       SpawnedTestServer::SSLOptions(),
5631                                       base::FilePath(kTestFilePath));
5632   ASSERT_TRUE(https_test_server.Start());
5633   // Make sure this test fails if the test server is changed to not
5634   // listen on an IP by default.
5635   ASSERT_TRUE(https_test_server.GetURL("").HostIsIPAddress());
5636   std::string test_server_hostname = https_test_server.GetURL("").host();
5637
5638   TestDelegate d;
5639   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5640       https_test_server.GetURL("files/hpkp-headers.html"), DEFAULT_PRIORITY,
5641       &d));
5642   request->Start();
5643   base::RunLoop().Run();
5644
5645   TransportSecurityState* security_state =
5646       default_context_.transport_security_state();
5647   TransportSecurityState::PKPState pkp_state;
5648   EXPECT_FALSE(
5649       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
5650 }
5651
5652 TEST_F(URLRequestTestHTTP, ProcessSTSOnce) {
5653   SpawnedTestServer::SSLOptions ssl_options(
5654       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5655   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5656                                       ssl_options,
5657                                       base::FilePath(kTestFilePath));
5658   ASSERT_TRUE(https_test_server.Start());
5659
5660   std::string test_server_hostname = https_test_server.GetURL("").host();
5661
5662   TestDelegate d;
5663   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5664       https_test_server.GetURL("files/hsts-multiple-headers.html"),
5665       DEFAULT_PRIORITY, &d));
5666   request->Start();
5667   base::RunLoop().Run();
5668
5669   // We should have set parameters from the first header, not the second.
5670   TransportSecurityState* security_state =
5671       default_context_.transport_security_state();
5672   TransportSecurityState::STSState sts_state;
5673   EXPECT_TRUE(
5674       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
5675   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
5676             sts_state.upgrade_mode);
5677   EXPECT_FALSE(sts_state.include_subdomains);
5678   EXPECT_FALSE(sts_state.include_subdomains);
5679 }
5680
5681 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP) {
5682   SpawnedTestServer::SSLOptions ssl_options(
5683       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5684   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5685                                       ssl_options,
5686                                       base::FilePath(kTestFilePath));
5687   ASSERT_TRUE(https_test_server.Start());
5688
5689   std::string test_server_hostname = https_test_server.GetURL("").host();
5690
5691   TestDelegate d;
5692   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5693       https_test_server.GetURL("files/hsts-and-hpkp-headers.html"),
5694       DEFAULT_PRIORITY, &d));
5695   request->Start();
5696   base::RunLoop().Run();
5697
5698   // We should have set parameters from the first header, not the second.
5699   TransportSecurityState* security_state =
5700       default_context_.transport_security_state();
5701   TransportSecurityState::STSState sts_state;
5702   TransportSecurityState::PKPState pkp_state;
5703   EXPECT_TRUE(
5704       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
5705   EXPECT_TRUE(
5706       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
5707   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
5708             sts_state.upgrade_mode);
5709 #if defined(OS_ANDROID)
5710   // Android's CertVerifyProc does not (yet) handle pins.
5711 #else
5712   EXPECT_TRUE(pkp_state.HasPublicKeyPins());
5713 #endif
5714   EXPECT_NE(sts_state.expiry, pkp_state.expiry);
5715
5716   // Even though there is an HSTS header asserting includeSubdomains, it is
5717   // the *second* such header, and we MUST process only the first.
5718   EXPECT_FALSE(sts_state.include_subdomains);
5719   // includeSubdomains does not occur in the test HPKP header.
5720   EXPECT_FALSE(pkp_state.include_subdomains);
5721 }
5722
5723 // Tests that when multiple HPKP headers are present, asserting different
5724 // policies, that only the first such policy is processed.
5725 TEST_F(URLRequestTestHTTP, ProcessSTSAndPKP2) {
5726   SpawnedTestServer::SSLOptions ssl_options(
5727       SpawnedTestServer::SSLOptions::CERT_COMMON_NAME_IS_DOMAIN);
5728   SpawnedTestServer https_test_server(SpawnedTestServer::TYPE_HTTPS,
5729                                       ssl_options,
5730                                       base::FilePath(kTestFilePath));
5731   ASSERT_TRUE(https_test_server.Start());
5732
5733   std::string test_server_hostname = https_test_server.GetURL("").host();
5734
5735   TestDelegate d;
5736   scoped_ptr<URLRequest> request(default_context_.CreateRequest(
5737       https_test_server.GetURL("files/hsts-and-hpkp-headers2.html"),
5738       DEFAULT_PRIORITY, &d));
5739   request->Start();
5740   base::RunLoop().Run();
5741
5742   TransportSecurityState* security_state =
5743       default_context_.transport_security_state();
5744   TransportSecurityState::STSState sts_state;
5745   TransportSecurityState::PKPState pkp_state;
5746   EXPECT_TRUE(
5747       security_state->GetDynamicSTSState(test_server_hostname, &sts_state));
5748   EXPECT_TRUE(
5749       security_state->GetDynamicPKPState(test_server_hostname, &pkp_state));
5750   EXPECT_EQ(TransportSecurityState::STSState::MODE_FORCE_HTTPS,
5751             sts_state.upgrade_mode);
5752 #if defined(OS_ANDROID)
5753   // Android's CertVerifyProc does not (yet) handle pins.
5754 #else
5755   EXPECT_TRUE(pkp_state.HasPublicKeyPins());
5756 #endif
5757   EXPECT_NE(sts_state.expiry, pkp_state.expiry);
5758
5759   EXPECT_TRUE(sts_state.include_subdomains);
5760   EXPECT_FALSE(pkp_state.include_subdomains);
5761 }
5762
5763 TEST_F(URLRequestTestHTTP, ContentTypeNormalizationTest) {
5764   ASSERT_TRUE(test_server_.Start());
5765
5766   TestDelegate d;
5767   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
5768       test_server_.GetURL("files/content-type-normalization.html"),
5769       DEFAULT_PRIORITY, &d));
5770   req->Start();
5771   base::RunLoop().Run();
5772
5773   std::string mime_type;
5774   req->GetMimeType(&mime_type);
5775   EXPECT_EQ("text/html", mime_type);
5776
5777   std::string charset;
5778   req->GetCharset(&charset);
5779   EXPECT_EQ("utf-8", charset);
5780   req->Cancel();
5781 }
5782
5783 TEST_F(URLRequestTestHTTP, ProtocolHandlerAndFactoryRestrictDataRedirects) {
5784   // Test URLRequestJobFactory::ProtocolHandler::IsSafeRedirectTarget().
5785   GURL data_url("data:,foo");
5786   DataProtocolHandler data_protocol_handler;
5787   EXPECT_FALSE(data_protocol_handler.IsSafeRedirectTarget(data_url));
5788
5789   // Test URLRequestJobFactoryImpl::IsSafeRedirectTarget().
5790   EXPECT_FALSE(job_factory_->IsSafeRedirectTarget(data_url));
5791 }
5792
5793 #if !defined(DISABLE_FILE_SUPPORT)
5794 TEST_F(URLRequestTestHTTP, ProtocolHandlerAndFactoryRestrictFileRedirects) {
5795   // Test URLRequestJobFactory::ProtocolHandler::IsSafeRedirectTarget().
5796   GURL file_url("file:///foo.txt");
5797   FileProtocolHandler file_protocol_handler(
5798       base::ThreadTaskRunnerHandle::Get());
5799   EXPECT_FALSE(file_protocol_handler.IsSafeRedirectTarget(file_url));
5800
5801   // Test URLRequestJobFactoryImpl::IsSafeRedirectTarget().
5802   EXPECT_FALSE(job_factory_->IsSafeRedirectTarget(file_url));
5803 }
5804
5805 TEST_F(URLRequestTestHTTP, RestrictFileRedirects) {
5806   ASSERT_TRUE(test_server_.Start());
5807
5808   TestDelegate d;
5809   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
5810       test_server_.GetURL("files/redirect-to-file.html"), DEFAULT_PRIORITY,
5811       &d));
5812   req->Start();
5813   base::RunLoop().Run();
5814
5815   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
5816   EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
5817 }
5818 #endif  // !defined(DISABLE_FILE_SUPPORT)
5819
5820 TEST_F(URLRequestTestHTTP, RestrictDataRedirects) {
5821   ASSERT_TRUE(test_server_.Start());
5822
5823   TestDelegate d;
5824   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
5825       test_server_.GetURL("files/redirect-to-data.html"), DEFAULT_PRIORITY,
5826       &d));
5827   req->Start();
5828   base::MessageLoop::current()->Run();
5829
5830   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
5831   EXPECT_EQ(ERR_UNSAFE_REDIRECT, req->status().error());
5832 }
5833
5834 TEST_F(URLRequestTestHTTP, RedirectToInvalidURL) {
5835   ASSERT_TRUE(test_server_.Start());
5836
5837   TestDelegate d;
5838   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
5839       test_server_.GetURL("files/redirect-to-invalid-url.html"),
5840       DEFAULT_PRIORITY, &d));
5841   req->Start();
5842   base::RunLoop().Run();
5843
5844   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
5845   EXPECT_EQ(ERR_INVALID_URL, req->status().error());
5846 }
5847
5848 // Make sure redirects are cached, despite not reading their bodies.
5849 TEST_F(URLRequestTestHTTP, CacheRedirect) {
5850   ASSERT_TRUE(test_server_.Start());
5851   GURL redirect_url =
5852       test_server_.GetURL("files/redirect302-to-echo-cacheable");
5853
5854   {
5855     TestDelegate d;
5856     scoped_ptr<URLRequest> req(
5857         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
5858     req->Start();
5859     base::RunLoop().Run();
5860     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
5861     EXPECT_EQ(1, d.received_redirect_count());
5862     EXPECT_EQ(test_server_.GetURL("echo"), req->url());
5863   }
5864
5865   {
5866     TestDelegate d;
5867     d.set_quit_on_redirect(true);
5868     scoped_ptr<URLRequest> req(
5869         default_context_.CreateRequest(redirect_url, DEFAULT_PRIORITY, &d));
5870     req->Start();
5871     base::RunLoop().Run();
5872
5873     EXPECT_EQ(1, d.received_redirect_count());
5874     EXPECT_EQ(0, d.response_started_count());
5875     EXPECT_TRUE(req->was_cached());
5876
5877     req->FollowDeferredRedirect();
5878     base::RunLoop().Run();
5879     EXPECT_EQ(1, d.received_redirect_count());
5880     EXPECT_EQ(1, d.response_started_count());
5881     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
5882     EXPECT_EQ(test_server_.GetURL("echo"), req->url());
5883   }
5884 }
5885
5886 // Make sure a request isn't cached when a NetworkDelegate forces a redirect
5887 // when the headers are read, since the body won't have been read.
5888 TEST_F(URLRequestTestHTTP, NoCacheOnNetworkDelegateRedirect) {
5889   ASSERT_TRUE(test_server_.Start());
5890   // URL that is normally cached.
5891   GURL initial_url = test_server_.GetURL("cachetime");
5892
5893   {
5894     // Set up the TestNetworkDelegate tp force a redirect.
5895     GURL redirect_to_url = test_server_.GetURL("echo");
5896     default_network_delegate_.set_redirect_on_headers_received_url(
5897         redirect_to_url);
5898
5899     TestDelegate d;
5900     scoped_ptr<URLRequest> req(
5901         default_context_.CreateRequest(initial_url, DEFAULT_PRIORITY, &d));
5902     req->Start();
5903     base::RunLoop().Run();
5904     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
5905     EXPECT_EQ(1, d.received_redirect_count());
5906     EXPECT_EQ(redirect_to_url, req->url());
5907   }
5908
5909   {
5910     TestDelegate d;
5911     scoped_ptr<URLRequest> req(
5912         default_context_.CreateRequest(initial_url, DEFAULT_PRIORITY, &d));
5913     req->Start();
5914     base::RunLoop().Run();
5915
5916     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
5917     EXPECT_FALSE(req->was_cached());
5918     EXPECT_EQ(0, d.received_redirect_count());
5919     EXPECT_EQ(initial_url, req->url());
5920   }
5921 }
5922
5923 // Tests that redirection to an unsafe URL is allowed when it has been marked as
5924 // safe.
5925 TEST_F(URLRequestTestHTTP, UnsafeRedirectToWhitelistedUnsafeURL) {
5926   ASSERT_TRUE(test_server_.Start());
5927
5928   GURL unsafe_url("data:text/html,this-is-considered-an-unsafe-url");
5929   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
5930   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
5931
5932   TestDelegate d;
5933   {
5934     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5935         test_server_.GetURL("whatever"), DEFAULT_PRIORITY, &d));
5936
5937     r->Start();
5938     base::RunLoop().Run();
5939
5940     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
5941
5942     EXPECT_EQ(2U, r->url_chain().size());
5943     EXPECT_EQ(OK, r->status().error());
5944     EXPECT_EQ(unsafe_url, r->url());
5945     EXPECT_EQ("this-is-considered-an-unsafe-url", d.data_received());
5946   }
5947 }
5948
5949 // Tests that a redirect to a different unsafe URL is blocked, even after adding
5950 // some other URL to the whitelist.
5951 TEST_F(URLRequestTestHTTP, UnsafeRedirectToDifferentUnsafeURL) {
5952   ASSERT_TRUE(test_server_.Start());
5953
5954   GURL unsafe_url("data:text/html,something");
5955   GURL different_unsafe_url("data:text/html,something-else");
5956   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
5957   default_network_delegate_.set_allowed_unsafe_redirect_url(
5958       different_unsafe_url);
5959
5960   TestDelegate d;
5961   {
5962     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
5963         test_server_.GetURL("whatever"), DEFAULT_PRIORITY, &d));
5964
5965     r->Start();
5966     base::RunLoop().Run();
5967
5968     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
5969     EXPECT_EQ(ERR_UNSAFE_REDIRECT, r->status().error());
5970   }
5971 }
5972
5973 // Redirects from an URL with fragment to an unsafe URL with fragment should
5974 // be allowed, and the reference fragment of the target URL should be preserved.
5975 TEST_F(URLRequestTestHTTP, UnsafeRedirectWithDifferentReferenceFragment) {
5976   ASSERT_TRUE(test_server_.Start());
5977
5978   GURL original_url(test_server_.GetURL("original#fragment1"));
5979   GURL unsafe_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
5980   GURL expected_url("data:,url-marked-safe-and-used-in-redirect#fragment2");
5981
5982   default_network_delegate_.set_redirect_on_headers_received_url(unsafe_url);
5983   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
5984
5985   TestDelegate d;
5986   {
5987     scoped_ptr<URLRequest> r(
5988         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
5989
5990     r->Start();
5991     base::RunLoop().Run();
5992
5993     EXPECT_EQ(2U, r->url_chain().size());
5994     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
5995     EXPECT_EQ(OK, r->status().error());
5996     EXPECT_EQ(original_url, r->original_url());
5997     EXPECT_EQ(expected_url, r->url());
5998   }
5999 }
6000
6001 // When a delegate has specified a safe redirect URL, but it does not match the
6002 // redirect target, then do not prevent the reference fragment from being added.
6003 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragmentAndUnrelatedUnsafeUrl) {
6004   ASSERT_TRUE(test_server_.Start());
6005
6006   GURL original_url(test_server_.GetURL("original#expected-fragment"));
6007   GURL unsafe_url("data:text/html,this-url-does-not-match-redirect-url");
6008   GURL redirect_url(test_server_.GetURL("target"));
6009   GURL expected_redirect_url(test_server_.GetURL("target#expected-fragment"));
6010
6011   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
6012   default_network_delegate_.set_allowed_unsafe_redirect_url(unsafe_url);
6013
6014   TestDelegate d;
6015   {
6016     scoped_ptr<URLRequest> r(
6017         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
6018
6019     r->Start();
6020     base::RunLoop().Run();
6021
6022     EXPECT_EQ(2U, r->url_chain().size());
6023     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
6024     EXPECT_EQ(OK, r->status().error());
6025     EXPECT_EQ(original_url, r->original_url());
6026     EXPECT_EQ(expected_redirect_url, r->url());
6027   }
6028 }
6029
6030 // When a delegate has specified a safe redirect URL, assume that the redirect
6031 // URL should not be changed. In particular, the reference fragment should not
6032 // be modified.
6033 TEST_F(URLRequestTestHTTP, RedirectWithReferenceFragment) {
6034   ASSERT_TRUE(test_server_.Start());
6035
6036   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
6037   GURL redirect_url("data:text/html,expect-no-reference-fragment");
6038
6039   default_network_delegate_.set_redirect_on_headers_received_url(redirect_url);
6040   default_network_delegate_.set_allowed_unsafe_redirect_url(redirect_url);
6041
6042   TestDelegate d;
6043   {
6044     scoped_ptr<URLRequest> r(
6045         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
6046
6047     r->Start();
6048     base::RunLoop().Run();
6049
6050     EXPECT_EQ(2U, r->url_chain().size());
6051     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
6052     EXPECT_EQ(OK, r->status().error());
6053     EXPECT_EQ(original_url, r->original_url());
6054     EXPECT_EQ(redirect_url, r->url());
6055   }
6056 }
6057
6058 // When a URLRequestRedirectJob is created, the redirection must be followed and
6059 // the reference fragment of the target URL must not be modified.
6060 TEST_F(URLRequestTestHTTP, RedirectJobWithReferenceFragment) {
6061   ASSERT_TRUE(test_server_.Start());
6062
6063   GURL original_url(test_server_.GetURL("original#should-not-be-appended"));
6064   GURL redirect_url(test_server_.GetURL("echo"));
6065
6066   TestDelegate d;
6067   scoped_ptr<URLRequest> r(
6068       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
6069
6070   URLRequestRedirectJob* job = new URLRequestRedirectJob(
6071       r.get(), &default_network_delegate_, redirect_url,
6072       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
6073   AddTestInterceptor()->set_main_intercept_job(job);
6074
6075   r->Start();
6076   base::RunLoop().Run();
6077
6078   EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
6079   EXPECT_EQ(OK, r->status().error());
6080   EXPECT_EQ(original_url, r->original_url());
6081   EXPECT_EQ(redirect_url, r->url());
6082 }
6083
6084 TEST_F(URLRequestTestHTTP, NoUserPassInReferrer) {
6085   ASSERT_TRUE(test_server_.Start());
6086
6087   TestDelegate d;
6088   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6089       test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
6090   req->SetReferrer("http://user:pass@foo.com/");
6091   req->Start();
6092   base::RunLoop().Run();
6093
6094   EXPECT_EQ(std::string("http://foo.com/"), d.data_received());
6095 }
6096
6097 TEST_F(URLRequestTestHTTP, NoFragmentInReferrer) {
6098   ASSERT_TRUE(test_server_.Start());
6099
6100   TestDelegate d;
6101   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6102       test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
6103   req->SetReferrer("http://foo.com/test#fragment");
6104   req->Start();
6105   base::RunLoop().Run();
6106
6107   EXPECT_EQ(std::string("http://foo.com/test"), d.data_received());
6108 }
6109
6110 TEST_F(URLRequestTestHTTP, EmptyReferrerAfterValidReferrer) {
6111   ASSERT_TRUE(test_server_.Start());
6112
6113   TestDelegate d;
6114   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6115       test_server_.GetURL("echoheader?Referer"), DEFAULT_PRIORITY, &d));
6116   req->SetReferrer("http://foo.com/test#fragment");
6117   req->SetReferrer("");
6118   req->Start();
6119   base::RunLoop().Run();
6120
6121   EXPECT_EQ(std::string("None"), d.data_received());
6122 }
6123
6124 // Defer network start and then resume, checking that the request was a success
6125 // and bytes were received.
6126 TEST_F(URLRequestTestHTTP, DeferredBeforeNetworkStart) {
6127   ASSERT_TRUE(test_server_.Start());
6128
6129   TestDelegate d;
6130   {
6131     d.set_quit_on_network_start(true);
6132     GURL test_url(test_server_.GetURL("echo"));
6133     scoped_ptr<URLRequest> req(
6134         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
6135
6136     req->Start();
6137     base::RunLoop().Run();
6138
6139     EXPECT_EQ(1, d.received_before_network_start_count());
6140     EXPECT_EQ(0, d.response_started_count());
6141
6142     req->ResumeNetworkStart();
6143     base::RunLoop().Run();
6144
6145     EXPECT_EQ(1, d.response_started_count());
6146     EXPECT_NE(0, d.bytes_received());
6147     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
6148   }
6149 }
6150
6151 // Check that OnBeforeNetworkStart is only called once even if there is a
6152 // redirect.
6153 TEST_F(URLRequestTestHTTP, BeforeNetworkStartCalledOnce) {
6154   ASSERT_TRUE(test_server_.Start());
6155
6156   TestDelegate d;
6157   {
6158     d.set_quit_on_redirect(true);
6159     d.set_quit_on_network_start(true);
6160     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6161         test_server_.GetURL("server-redirect?echo"), DEFAULT_PRIORITY, &d));
6162
6163     req->Start();
6164     base::RunLoop().Run();
6165
6166     EXPECT_EQ(1, d.received_before_network_start_count());
6167     EXPECT_EQ(0, d.response_started_count());
6168     EXPECT_EQ(0, d.received_redirect_count());
6169
6170     req->ResumeNetworkStart();
6171     base::RunLoop().Run();
6172
6173     EXPECT_EQ(1, d.received_redirect_count());
6174     req->FollowDeferredRedirect();
6175     base::RunLoop().Run();
6176
6177     // Check that the redirect's new network transaction does not get propagated
6178     // to a second OnBeforeNetworkStart() notification.
6179     EXPECT_EQ(1, d.received_before_network_start_count());
6180
6181     EXPECT_EQ(1, d.response_started_count());
6182     EXPECT_NE(0, d.bytes_received());
6183     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
6184   }
6185 }
6186
6187 // Cancel the request after learning that the request would use the network.
6188 TEST_F(URLRequestTestHTTP, CancelOnBeforeNetworkStart) {
6189   ASSERT_TRUE(test_server_.Start());
6190
6191   TestDelegate d;
6192   {
6193     d.set_quit_on_network_start(true);
6194     GURL test_url(test_server_.GetURL("echo"));
6195     scoped_ptr<URLRequest> req(
6196         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
6197
6198     req->Start();
6199     base::RunLoop().Run();
6200
6201     EXPECT_EQ(1, d.received_before_network_start_count());
6202     EXPECT_EQ(0, d.response_started_count());
6203
6204     req->Cancel();
6205     base::RunLoop().Run();
6206
6207     EXPECT_EQ(1, d.response_started_count());
6208     EXPECT_EQ(0, d.bytes_received());
6209     EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
6210   }
6211 }
6212
6213 TEST_F(URLRequestTestHTTP, CancelRedirect) {
6214   ASSERT_TRUE(test_server_.Start());
6215
6216   TestDelegate d;
6217   {
6218     d.set_cancel_in_received_redirect(true);
6219     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6220         test_server_.GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d));
6221     req->Start();
6222     base::RunLoop().Run();
6223
6224     EXPECT_EQ(1, d.response_started_count());
6225     EXPECT_EQ(0, d.bytes_received());
6226     EXPECT_FALSE(d.received_data_before_response());
6227     EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
6228   }
6229 }
6230
6231 TEST_F(URLRequestTestHTTP, DeferredRedirect) {
6232   ASSERT_TRUE(test_server_.Start());
6233
6234   TestDelegate d;
6235   {
6236     d.set_quit_on_redirect(true);
6237     GURL test_url(test_server_.GetURL("files/redirect-test.html"));
6238     scoped_ptr<URLRequest> req(
6239         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
6240
6241     req->Start();
6242     base::RunLoop().Run();
6243
6244     EXPECT_EQ(1, d.received_redirect_count());
6245
6246     req->FollowDeferredRedirect();
6247     base::RunLoop().Run();
6248
6249     EXPECT_EQ(1, d.response_started_count());
6250     EXPECT_FALSE(d.received_data_before_response());
6251     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
6252
6253     base::FilePath path;
6254     PathService::Get(base::DIR_SOURCE_ROOT, &path);
6255     path = path.Append(kTestFilePath);
6256     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
6257
6258     std::string contents;
6259     EXPECT_TRUE(base::ReadFileToString(path, &contents));
6260     EXPECT_EQ(contents, d.data_received());
6261   }
6262 }
6263
6264 TEST_F(URLRequestTestHTTP, DeferredRedirect_GetFullRequestHeaders) {
6265   ASSERT_TRUE(test_server_.Start());
6266
6267   TestDelegate d;
6268   {
6269     d.set_quit_on_redirect(true);
6270     GURL test_url(test_server_.GetURL("files/redirect-test.html"));
6271     scoped_ptr<URLRequest> req(
6272         default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
6273
6274     EXPECT_FALSE(d.have_full_request_headers());
6275
6276     req->Start();
6277     base::RunLoop().Run();
6278
6279     EXPECT_EQ(1, d.received_redirect_count());
6280     EXPECT_TRUE(d.have_full_request_headers());
6281     CheckFullRequestHeaders(d.full_request_headers(), test_url);
6282     d.ClearFullRequestHeaders();
6283
6284     req->FollowDeferredRedirect();
6285     base::RunLoop().Run();
6286
6287     GURL target_url(test_server_.GetURL("files/with-headers.html"));
6288     EXPECT_EQ(1, d.response_started_count());
6289     EXPECT_TRUE(d.have_full_request_headers());
6290     CheckFullRequestHeaders(d.full_request_headers(), target_url);
6291     EXPECT_FALSE(d.received_data_before_response());
6292     EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
6293
6294     base::FilePath path;
6295     PathService::Get(base::DIR_SOURCE_ROOT, &path);
6296     path = path.Append(kTestFilePath);
6297     path = path.Append(FILE_PATH_LITERAL("with-headers.html"));
6298
6299     std::string contents;
6300     EXPECT_TRUE(base::ReadFileToString(path, &contents));
6301     EXPECT_EQ(contents, d.data_received());
6302   }
6303 }
6304
6305 TEST_F(URLRequestTestHTTP, CancelDeferredRedirect) {
6306   ASSERT_TRUE(test_server_.Start());
6307
6308   TestDelegate d;
6309   {
6310     d.set_quit_on_redirect(true);
6311     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6312         test_server_.GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d));
6313     req->Start();
6314     base::RunLoop().Run();
6315
6316     EXPECT_EQ(1, d.received_redirect_count());
6317
6318     req->Cancel();
6319     base::RunLoop().Run();
6320
6321     EXPECT_EQ(1, d.response_started_count());
6322     EXPECT_EQ(0, d.bytes_received());
6323     EXPECT_FALSE(d.received_data_before_response());
6324     EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
6325   }
6326 }
6327
6328 TEST_F(URLRequestTestHTTP, VaryHeader) {
6329   ASSERT_TRUE(test_server_.Start());
6330
6331   // Populate the cache.
6332   {
6333     TestDelegate d;
6334     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6335         test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d));
6336     HttpRequestHeaders headers;
6337     headers.SetHeader("foo", "1");
6338     req->SetExtraRequestHeaders(headers);
6339     req->Start();
6340     base::RunLoop().Run();
6341
6342     LoadTimingInfo load_timing_info;
6343     req->GetLoadTimingInfo(&load_timing_info);
6344     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
6345   }
6346
6347   // Expect a cache hit.
6348   {
6349     TestDelegate d;
6350     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6351         test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d));
6352     HttpRequestHeaders headers;
6353     headers.SetHeader("foo", "1");
6354     req->SetExtraRequestHeaders(headers);
6355     req->Start();
6356     base::RunLoop().Run();
6357
6358     EXPECT_TRUE(req->was_cached());
6359
6360     LoadTimingInfo load_timing_info;
6361     req->GetLoadTimingInfo(&load_timing_info);
6362     TestLoadTimingCacheHitNoNetwork(load_timing_info);
6363   }
6364
6365   // Expect a cache miss.
6366   {
6367     TestDelegate d;
6368     scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6369         test_server_.GetURL("echoheadercache?foo"), DEFAULT_PRIORITY, &d));
6370     HttpRequestHeaders headers;
6371     headers.SetHeader("foo", "2");
6372     req->SetExtraRequestHeaders(headers);
6373     req->Start();
6374     base::RunLoop().Run();
6375
6376     EXPECT_FALSE(req->was_cached());
6377
6378     LoadTimingInfo load_timing_info;
6379     req->GetLoadTimingInfo(&load_timing_info);
6380     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
6381   }
6382 }
6383
6384 TEST_F(URLRequestTestHTTP, BasicAuth) {
6385   ASSERT_TRUE(test_server_.Start());
6386
6387   // populate the cache
6388   {
6389     TestDelegate d;
6390     d.set_credentials(AuthCredentials(kUser, kSecret));
6391
6392     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
6393         test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
6394     r->Start();
6395
6396     base::RunLoop().Run();
6397
6398     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
6399   }
6400
6401   // repeat request with end-to-end validation.  since auth-basic results in a
6402   // cachable page, we expect this test to result in a 304.  in which case, the
6403   // response should be fetched from the cache.
6404   {
6405     TestDelegate d;
6406     d.set_credentials(AuthCredentials(kUser, kSecret));
6407
6408     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
6409         test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
6410     r->SetLoadFlags(LOAD_VALIDATE_CACHE);
6411     r->Start();
6412
6413     base::RunLoop().Run();
6414
6415     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
6416
6417     // Should be the same cached document.
6418     EXPECT_TRUE(r->was_cached());
6419   }
6420 }
6421
6422 // Check that Set-Cookie headers in 401 responses are respected.
6423 // http://crbug.com/6450
6424 TEST_F(URLRequestTestHTTP, BasicAuthWithCookies) {
6425   ASSERT_TRUE(test_server_.Start());
6426
6427   GURL url_requiring_auth =
6428       test_server_.GetURL("auth-basic?set-cookie-if-challenged");
6429
6430   // Request a page that will give a 401 containing a Set-Cookie header.
6431   // Verify that when the transaction is restarted, it includes the new cookie.
6432   {
6433     TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
6434     TestURLRequestContext context(true);
6435     context.set_network_delegate(&network_delegate);
6436     context.Init();
6437
6438     TestDelegate d;
6439     d.set_credentials(AuthCredentials(kUser, kSecret));
6440
6441     scoped_ptr<URLRequest> r(
6442         context.CreateRequest(url_requiring_auth, DEFAULT_PRIORITY, &d));
6443     r->Start();
6444
6445     base::RunLoop().Run();
6446
6447     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
6448
6449     // Make sure we sent the cookie in the restarted transaction.
6450     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
6451         != std::string::npos);
6452   }
6453
6454   // Same test as above, except this time the restart is initiated earlier
6455   // (without user intervention since identity is embedded in the URL).
6456   {
6457     TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
6458     TestURLRequestContext context(true);
6459     context.set_network_delegate(&network_delegate);
6460     context.Init();
6461
6462     TestDelegate d;
6463
6464     GURL::Replacements replacements;
6465     replacements.SetUsernameStr("user2");
6466     replacements.SetPasswordStr("secret");
6467     GURL url_with_identity = url_requiring_auth.ReplaceComponents(replacements);
6468
6469     scoped_ptr<URLRequest> r(
6470         context.CreateRequest(url_with_identity, DEFAULT_PRIORITY, &d));
6471     r->Start();
6472
6473     base::RunLoop().Run();
6474
6475     EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
6476
6477     // Make sure we sent the cookie in the restarted transaction.
6478     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
6479         != std::string::npos);
6480   }
6481 }
6482
6483 // Tests that load timing works as expected with auth and the cache.
6484 TEST_F(URLRequestTestHTTP, BasicAuthLoadTiming) {
6485   ASSERT_TRUE(test_server_.Start());
6486
6487   // populate the cache
6488   {
6489     TestDelegate d;
6490     d.set_credentials(AuthCredentials(kUser, kSecret));
6491
6492     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
6493         test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
6494     r->Start();
6495
6496     base::RunLoop().Run();
6497
6498     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
6499
6500     LoadTimingInfo load_timing_info_before_auth;
6501     EXPECT_TRUE(default_network_delegate_.GetLoadTimingInfoBeforeAuth(
6502         &load_timing_info_before_auth));
6503     TestLoadTimingNotReused(load_timing_info_before_auth,
6504                             CONNECT_TIMING_HAS_DNS_TIMES);
6505
6506     LoadTimingInfo load_timing_info;
6507     r->GetLoadTimingInfo(&load_timing_info);
6508     // The test server does not support keep alive sockets, so the second
6509     // request with auth should use a new socket.
6510     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
6511     EXPECT_NE(load_timing_info_before_auth.socket_log_id,
6512               load_timing_info.socket_log_id);
6513     EXPECT_LE(load_timing_info_before_auth.receive_headers_end,
6514               load_timing_info.connect_timing.connect_start);
6515   }
6516
6517   // Repeat request with end-to-end validation.  Since auth-basic results in a
6518   // cachable page, we expect this test to result in a 304.  In which case, the
6519   // response should be fetched from the cache.
6520   {
6521     TestDelegate d;
6522     d.set_credentials(AuthCredentials(kUser, kSecret));
6523
6524     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
6525         test_server_.GetURL("auth-basic"), DEFAULT_PRIORITY, &d));
6526     r->SetLoadFlags(LOAD_VALIDATE_CACHE);
6527     r->Start();
6528
6529     base::RunLoop().Run();
6530
6531     EXPECT_TRUE(d.data_received().find("user/secret") != std::string::npos);
6532
6533     // Should be the same cached document.
6534     EXPECT_TRUE(r->was_cached());
6535
6536     // Since there was a request that went over the wire, the load timing
6537     // information should include connection times.
6538     LoadTimingInfo load_timing_info;
6539     r->GetLoadTimingInfo(&load_timing_info);
6540     TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_DNS_TIMES);
6541   }
6542 }
6543
6544 // In this test, we do a POST which the server will 302 redirect.
6545 // The subsequent transaction should use GET, and should not send the
6546 // Content-Type header.
6547 // http://code.google.com/p/chromium/issues/detail?id=843
6548 TEST_F(URLRequestTestHTTP, Post302RedirectGet) {
6549   ASSERT_TRUE(test_server_.Start());
6550
6551   const char kData[] = "hello world";
6552
6553   TestDelegate d;
6554   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6555       test_server_.GetURL("files/redirect-to-echoall"), DEFAULT_PRIORITY, &d));
6556   req->set_method("POST");
6557   req->set_upload(CreateSimpleUploadData(kData));
6558
6559   // Set headers (some of which are specific to the POST).
6560   HttpRequestHeaders headers;
6561   headers.AddHeadersFromString(
6562     "Content-Type: multipart/form-data; "
6563     "boundary=----WebKitFormBoundaryAADeAA+NAAWMAAwZ\r\n"
6564     "Accept: text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,"
6565     "text/plain;q=0.8,image/png,*/*;q=0.5\r\n"
6566     "Accept-Language: en-US,en\r\n"
6567     "Accept-Charset: ISO-8859-1,*,utf-8\r\n"
6568     "Content-Length: 11\r\n"
6569     "Origin: http://localhost:1337/");
6570   req->SetExtraRequestHeaders(headers);
6571   req->Start();
6572   base::RunLoop().Run();
6573
6574   std::string mime_type;
6575   req->GetMimeType(&mime_type);
6576   EXPECT_EQ("text/html", mime_type);
6577
6578   const std::string& data = d.data_received();
6579
6580   // Check that the post-specific headers were stripped:
6581   EXPECT_FALSE(ContainsString(data, "Content-Length:"));
6582   EXPECT_FALSE(ContainsString(data, "Content-Type:"));
6583   EXPECT_FALSE(ContainsString(data, "Origin:"));
6584
6585   // These extra request headers should not have been stripped.
6586   EXPECT_TRUE(ContainsString(data, "Accept:"));
6587   EXPECT_TRUE(ContainsString(data, "Accept-Language:"));
6588   EXPECT_TRUE(ContainsString(data, "Accept-Charset:"));
6589 }
6590
6591 // The following tests check that we handle mutating the request for HTTP
6592 // redirects as expected.
6593 // See https://crbug.com/56373, https://crbug.com/102130, and
6594 // https://crbug.com/465517.
6595
6596 TEST_F(URLRequestTestHTTP, Redirect301Tests) {
6597   ASSERT_TRUE(test_server_.Start());
6598
6599   const GURL url = test_server_.GetURL("files/redirect301-to-echo");
6600   const GURL https_redirect_url =
6601       test_server_.GetURL("files/redirect301-to-https");
6602
6603   HTTPRedirectMethodTest(url, "POST", "GET", true);
6604   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
6605   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
6606
6607   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
6608   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
6609   HTTPRedirectOriginHeaderTest(url, "POST", "GET", std::string());
6610   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "GET",
6611                                std::string());
6612 }
6613
6614 TEST_F(URLRequestTestHTTP, Redirect302Tests) {
6615   ASSERT_TRUE(test_server_.Start());
6616
6617   const GURL url = test_server_.GetURL("files/redirect302-to-echo");
6618   const GURL https_redirect_url =
6619       test_server_.GetURL("files/redirect302-to-https");
6620
6621   HTTPRedirectMethodTest(url, "POST", "GET", true);
6622   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
6623   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
6624
6625   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
6626   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
6627   HTTPRedirectOriginHeaderTest(url, "POST", "GET", std::string());
6628   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "GET",
6629                                std::string());
6630 }
6631
6632 TEST_F(URLRequestTestHTTP, Redirect303Tests) {
6633   ASSERT_TRUE(test_server_.Start());
6634
6635   const GURL url = test_server_.GetURL("files/redirect303-to-echo");
6636   const GURL https_redirect_url =
6637       test_server_.GetURL("files/redirect303-to-https");
6638
6639   HTTPRedirectMethodTest(url, "POST", "GET", true);
6640   HTTPRedirectMethodTest(url, "PUT", "GET", true);
6641   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
6642
6643   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
6644   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
6645   HTTPRedirectOriginHeaderTest(url, "POST", "GET", std::string());
6646   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "GET",
6647                                std::string());
6648 }
6649
6650 TEST_F(URLRequestTestHTTP, Redirect307Tests) {
6651   ASSERT_TRUE(test_server_.Start());
6652
6653   const GURL url = test_server_.GetURL("files/redirect307-to-echo");
6654   const GURL https_redirect_url =
6655       test_server_.GetURL("files/redirect307-to-https");
6656
6657   HTTPRedirectMethodTest(url, "POST", "POST", true);
6658   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
6659   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
6660
6661   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
6662   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
6663   HTTPRedirectOriginHeaderTest(url, "POST", "POST", url.GetOrigin().spec());
6664   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "POST", "null");
6665 }
6666
6667 TEST_F(URLRequestTestHTTP, Redirect308Tests) {
6668   ASSERT_TRUE(test_server_.Start());
6669
6670   const GURL url = test_server_.GetURL("files/redirect308-to-echo");
6671   const GURL https_redirect_url =
6672       test_server_.GetURL("files/redirect308-to-https");
6673
6674   HTTPRedirectMethodTest(url, "POST", "POST", true);
6675   HTTPRedirectMethodTest(url, "PUT", "PUT", true);
6676   HTTPRedirectMethodTest(url, "HEAD", "HEAD", false);
6677
6678   HTTPRedirectOriginHeaderTest(url, "GET", "GET", url.GetOrigin().spec());
6679   HTTPRedirectOriginHeaderTest(https_redirect_url, "GET", "GET", "null");
6680   HTTPRedirectOriginHeaderTest(url, "POST", "POST", url.GetOrigin().spec());
6681   HTTPRedirectOriginHeaderTest(https_redirect_url, "POST", "POST", "null");
6682 }
6683
6684 // Make sure that 308 responses without bodies are not treated as redirects.
6685 // Certain legacy apis that pre-date the response code expect this behavior
6686 // (Like Google Drive).
6687 TEST_F(URLRequestTestHTTP, NoRedirectOn308WithoutLocationHeader) {
6688   ASSERT_TRUE(test_server_.Start());
6689
6690   TestDelegate d;
6691   const GURL url = test_server_.GetURL("files/308-without-location-header");
6692
6693   scoped_ptr<URLRequest> request(
6694       default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
6695
6696   request->Start();
6697   base::RunLoop().Run();
6698   EXPECT_EQ(URLRequestStatus::SUCCESS, request->status().status());
6699   EXPECT_EQ(OK, request->status().error());
6700   EXPECT_EQ(0, d.received_redirect_count());
6701   EXPECT_EQ(308, request->response_headers()->response_code());
6702   EXPECT_EQ("This is not a redirect.", d.data_received());
6703 }
6704
6705 TEST_F(URLRequestTestHTTP, Redirect302PreserveReferenceFragment) {
6706   ASSERT_TRUE(test_server_.Start());
6707
6708   GURL original_url(test_server_.GetURL("files/redirect302-to-echo#fragment"));
6709   GURL expected_url(test_server_.GetURL("echo#fragment"));
6710
6711   TestDelegate d;
6712   {
6713     scoped_ptr<URLRequest> r(
6714         default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
6715
6716     r->Start();
6717     base::RunLoop().Run();
6718
6719     EXPECT_EQ(2U, r->url_chain().size());
6720     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
6721     EXPECT_EQ(OK, r->status().error());
6722     EXPECT_EQ(original_url, r->original_url());
6723     EXPECT_EQ(expected_url, r->url());
6724   }
6725 }
6726
6727 TEST_F(URLRequestTestHTTP, RedirectPreserveFirstPartyURL) {
6728   ASSERT_TRUE(test_server_.Start());
6729
6730   GURL url(test_server_.GetURL("files/redirect302-to-echo"));
6731   GURL first_party_url("http://example.com");
6732
6733   TestDelegate d;
6734   {
6735     scoped_ptr<URLRequest> r(
6736         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
6737     r->set_first_party_for_cookies(first_party_url);
6738
6739     r->Start();
6740     base::RunLoop().Run();
6741
6742     EXPECT_EQ(2U, r->url_chain().size());
6743     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
6744     EXPECT_EQ(OK, r->status().error());
6745     EXPECT_EQ(first_party_url, r->first_party_for_cookies());
6746   }
6747 }
6748
6749 TEST_F(URLRequestTestHTTP, RedirectUpdateFirstPartyURL) {
6750   ASSERT_TRUE(test_server_.Start());
6751
6752   GURL url(test_server_.GetURL("files/redirect302-to-echo"));
6753   GURL original_first_party_url("http://example.com");
6754   GURL expected_first_party_url(test_server_.GetURL("echo"));
6755
6756   TestDelegate d;
6757   {
6758     scoped_ptr<URLRequest> r(
6759         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
6760     r->set_first_party_for_cookies(original_first_party_url);
6761     r->set_first_party_url_policy(
6762         URLRequest::UPDATE_FIRST_PARTY_URL_ON_REDIRECT);
6763
6764     r->Start();
6765     base::RunLoop().Run();
6766
6767     EXPECT_EQ(2U, r->url_chain().size());
6768     EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
6769     EXPECT_EQ(OK, r->status().error());
6770     EXPECT_EQ(expected_first_party_url, r->first_party_for_cookies());
6771   }
6772 }
6773
6774 TEST_F(URLRequestTestHTTP, InterceptPost302RedirectGet) {
6775   ASSERT_TRUE(test_server_.Start());
6776
6777   const char kData[] = "hello world";
6778
6779   TestDelegate d;
6780   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6781       test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
6782   req->set_method("POST");
6783   req->set_upload(CreateSimpleUploadData(kData));
6784   HttpRequestHeaders headers;
6785   headers.SetHeader(HttpRequestHeaders::kContentLength,
6786                     base::SizeTToString(arraysize(kData) - 1));
6787   req->SetExtraRequestHeaders(headers);
6788
6789   URLRequestRedirectJob* job = new URLRequestRedirectJob(
6790       req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
6791       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
6792   AddTestInterceptor()->set_main_intercept_job(job);
6793
6794   req->Start();
6795   base::RunLoop().Run();
6796   EXPECT_EQ("GET", req->method());
6797 }
6798
6799 TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) {
6800   ASSERT_TRUE(test_server_.Start());
6801
6802   const char kData[] = "hello world";
6803
6804   TestDelegate d;
6805   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6806       test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
6807   req->set_method("POST");
6808   req->set_upload(CreateSimpleUploadData(kData));
6809   HttpRequestHeaders headers;
6810   headers.SetHeader(HttpRequestHeaders::kContentLength,
6811                     base::SizeTToString(arraysize(kData) - 1));
6812   req->SetExtraRequestHeaders(headers);
6813
6814   URLRequestRedirectJob* job = new URLRequestRedirectJob(
6815       req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
6816       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
6817       "Very Good Reason");
6818   AddTestInterceptor()->set_main_intercept_job(job);
6819
6820   req->Start();
6821   base::RunLoop().Run();
6822   EXPECT_EQ("POST", req->method());
6823   EXPECT_EQ(kData, d.data_received());
6824 }
6825
6826 // Check that default A-L header is sent.
6827 TEST_F(URLRequestTestHTTP, DefaultAcceptLanguage) {
6828   ASSERT_TRUE(test_server_.Start());
6829
6830   StaticHttpUserAgentSettings settings("en", std::string());
6831   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
6832   TestURLRequestContext context(true);
6833   context.set_network_delegate(&network_delegate);
6834   context.set_http_user_agent_settings(&settings);
6835   context.Init();
6836
6837   TestDelegate d;
6838   scoped_ptr<URLRequest> req(context.CreateRequest(
6839       test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d));
6840   req->Start();
6841   base::RunLoop().Run();
6842   EXPECT_EQ("en", d.data_received());
6843 }
6844
6845 // Check that an empty A-L header is not sent. http://crbug.com/77365.
6846 TEST_F(URLRequestTestHTTP, EmptyAcceptLanguage) {
6847   ASSERT_TRUE(test_server_.Start());
6848
6849   std::string empty_string;  // Avoid most vexing parse on line below.
6850   StaticHttpUserAgentSettings settings(empty_string, empty_string);
6851   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
6852   TestURLRequestContext context(true);
6853   context.set_network_delegate(&network_delegate);
6854   context.Init();
6855   // We override the language after initialization because empty entries
6856   // get overridden by Init().
6857   context.set_http_user_agent_settings(&settings);
6858
6859   TestDelegate d;
6860   scoped_ptr<URLRequest> req(context.CreateRequest(
6861       test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d));
6862   req->Start();
6863   base::RunLoop().Run();
6864   EXPECT_EQ("None", d.data_received());
6865 }
6866
6867 // Check that if request overrides the A-L header, the default is not appended.
6868 // See http://crbug.com/20894
6869 TEST_F(URLRequestTestHTTP, OverrideAcceptLanguage) {
6870   ASSERT_TRUE(test_server_.Start());
6871
6872   TestDelegate d;
6873   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6874       test_server_.GetURL("echoheader?Accept-Language"), DEFAULT_PRIORITY, &d));
6875   HttpRequestHeaders headers;
6876   headers.SetHeader(HttpRequestHeaders::kAcceptLanguage, "ru");
6877   req->SetExtraRequestHeaders(headers);
6878   req->Start();
6879   base::RunLoop().Run();
6880   EXPECT_EQ(std::string("ru"), d.data_received());
6881 }
6882
6883 // Check that default A-E header is sent.
6884 TEST_F(URLRequestTestHTTP, DefaultAcceptEncoding) {
6885   ASSERT_TRUE(test_server_.Start());
6886
6887   TestDelegate d;
6888   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6889       test_server_.GetURL("echoheader?Accept-Encoding"), DEFAULT_PRIORITY, &d));
6890   HttpRequestHeaders headers;
6891   req->SetExtraRequestHeaders(headers);
6892   req->Start();
6893   base::RunLoop().Run();
6894   EXPECT_TRUE(ContainsString(d.data_received(), "gzip"));
6895 }
6896
6897 // Check that if request overrides the A-E header, the default is not appended.
6898 // See http://crbug.com/47381
6899 TEST_F(URLRequestTestHTTP, OverrideAcceptEncoding) {
6900   ASSERT_TRUE(test_server_.Start());
6901
6902   TestDelegate d;
6903   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6904       test_server_.GetURL("echoheader?Accept-Encoding"), DEFAULT_PRIORITY, &d));
6905   HttpRequestHeaders headers;
6906   headers.SetHeader(HttpRequestHeaders::kAcceptEncoding, "identity");
6907   req->SetExtraRequestHeaders(headers);
6908   req->Start();
6909   base::RunLoop().Run();
6910   EXPECT_FALSE(ContainsString(d.data_received(), "gzip"));
6911   EXPECT_TRUE(ContainsString(d.data_received(), "identity"));
6912 }
6913
6914 // Check that setting the A-C header sends the proper header.
6915 TEST_F(URLRequestTestHTTP, SetAcceptCharset) {
6916   ASSERT_TRUE(test_server_.Start());
6917
6918   TestDelegate d;
6919   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6920       test_server_.GetURL("echoheader?Accept-Charset"), DEFAULT_PRIORITY, &d));
6921   HttpRequestHeaders headers;
6922   headers.SetHeader(HttpRequestHeaders::kAcceptCharset, "koi-8r");
6923   req->SetExtraRequestHeaders(headers);
6924   req->Start();
6925   base::RunLoop().Run();
6926   EXPECT_EQ(std::string("koi-8r"), d.data_received());
6927 }
6928
6929 // Check that default User-Agent header is sent.
6930 TEST_F(URLRequestTestHTTP, DefaultUserAgent) {
6931   ASSERT_TRUE(test_server_.Start());
6932
6933   TestDelegate d;
6934   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6935       test_server_.GetURL("echoheader?User-Agent"), DEFAULT_PRIORITY, &d));
6936   req->Start();
6937   base::RunLoop().Run();
6938   EXPECT_EQ(default_context_.http_user_agent_settings()->GetUserAgent(),
6939             d.data_received());
6940 }
6941
6942 // Check that if request overrides the User-Agent header,
6943 // the default is not appended.
6944 TEST_F(URLRequestTestHTTP, OverrideUserAgent) {
6945   ASSERT_TRUE(test_server_.Start());
6946
6947   TestDelegate d;
6948   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6949       test_server_.GetURL("echoheader?User-Agent"), DEFAULT_PRIORITY, &d));
6950   HttpRequestHeaders headers;
6951   headers.SetHeader(HttpRequestHeaders::kUserAgent, "Lynx (textmode)");
6952   req->SetExtraRequestHeaders(headers);
6953   req->Start();
6954   base::RunLoop().Run();
6955   EXPECT_EQ(std::string("Lynx (textmode)"), d.data_received());
6956 }
6957
6958 // Check that a NULL HttpUserAgentSettings causes the corresponding empty
6959 // User-Agent header to be sent but does not send the Accept-Language and
6960 // Accept-Charset headers.
6961 TEST_F(URLRequestTestHTTP, EmptyHttpUserAgentSettings) {
6962   ASSERT_TRUE(test_server_.Start());
6963
6964   TestNetworkDelegate network_delegate;  // Must outlive URLRequests.
6965   TestURLRequestContext context(true);
6966   context.set_network_delegate(&network_delegate);
6967   context.Init();
6968   // We override the HttpUserAgentSettings after initialization because empty
6969   // entries get overridden by Init().
6970   context.set_http_user_agent_settings(NULL);
6971
6972   struct {
6973     const char* request;
6974     const char* expected_response;
6975   } tests[] = { { "echoheader?Accept-Language", "None" },
6976                 { "echoheader?Accept-Charset", "None" },
6977                 { "echoheader?User-Agent", "" } };
6978
6979   for (size_t i = 0; i < arraysize(tests); i++) {
6980     TestDelegate d;
6981     scoped_ptr<URLRequest> req(context.CreateRequest(
6982         test_server_.GetURL(tests[i].request), DEFAULT_PRIORITY, &d));
6983     req->Start();
6984     base::RunLoop().Run();
6985     EXPECT_EQ(tests[i].expected_response, d.data_received())
6986         << " Request = \"" << tests[i].request << "\"";
6987   }
6988 }
6989
6990 // Make sure that URLRequest passes on its priority updates to
6991 // newly-created jobs after the first one.
6992 TEST_F(URLRequestTestHTTP, SetSubsequentJobPriority) {
6993   ASSERT_TRUE(test_server_.Start());
6994
6995   TestDelegate d;
6996   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
6997       test_server_.GetURL("empty.html"), DEFAULT_PRIORITY, &d));
6998   EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
6999
7000   scoped_refptr<URLRequestRedirectJob> redirect_job =
7001       new URLRequestRedirectJob(
7002           req.get(), &default_network_delegate_, test_server_.GetURL("echo"),
7003           URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason");
7004   AddTestInterceptor()->set_main_intercept_job(redirect_job.get());
7005
7006   req->SetPriority(LOW);
7007   req->Start();
7008   EXPECT_TRUE(req->is_pending());
7009
7010   scoped_refptr<URLRequestTestJob> job =
7011       new URLRequestTestJob(req.get(), &default_network_delegate_);
7012   AddTestInterceptor()->set_main_intercept_job(job.get());
7013
7014   // Should trigger |job| to be started.
7015   base::RunLoop().Run();
7016   EXPECT_EQ(LOW, job->priority());
7017 }
7018
7019 // Check that creating a network request while entering/exiting suspend mode
7020 // fails as it should.  This is the only case where an HttpTransactionFactory
7021 // does not return an HttpTransaction.
7022 TEST_F(URLRequestTestHTTP, NetworkSuspendTest) {
7023   // Create a new HttpNetworkLayer that thinks it's suspended.
7024   HttpNetworkSession::Params params;
7025   params.host_resolver = default_context_.host_resolver();
7026   params.cert_verifier = default_context_.cert_verifier();
7027   params.transport_security_state = default_context_.transport_security_state();
7028   params.proxy_service = default_context_.proxy_service();
7029   params.ssl_config_service = default_context_.ssl_config_service();
7030   params.http_auth_handler_factory =
7031       default_context_.http_auth_handler_factory();
7032   params.network_delegate = &default_network_delegate_;
7033   params.http_server_properties = default_context_.http_server_properties();
7034   scoped_ptr<HttpNetworkLayer> network_layer(
7035       new HttpNetworkLayer(new HttpNetworkSession(params)));
7036   network_layer->OnSuspend();
7037
7038   HttpCache http_cache(network_layer.release(), default_context_.net_log(),
7039                        HttpCache::DefaultBackend::InMemory(0));
7040
7041   TestURLRequestContext context(true);
7042   context.set_http_transaction_factory(&http_cache);
7043   context.Init();
7044
7045   TestDelegate d;
7046   scoped_ptr<URLRequest> req(
7047       context.CreateRequest(GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d));
7048   req->Start();
7049   base::RunLoop().Run();
7050
7051   EXPECT_TRUE(d.request_failed());
7052   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
7053   EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req->status().error());
7054 }
7055
7056 // Check that creating a network request while entering/exiting suspend mode
7057 // fails as it should in the case there is no cache.  This is the only case
7058 // where an HttpTransactionFactory does not return an HttpTransaction.
7059 TEST_F(URLRequestTestHTTP, NetworkSuspendTestNoCache) {
7060   // Create a new HttpNetworkLayer that thinks it's suspended.
7061   HttpNetworkSession::Params params;
7062   params.host_resolver = default_context_.host_resolver();
7063   params.cert_verifier = default_context_.cert_verifier();
7064   params.transport_security_state = default_context_.transport_security_state();
7065   params.proxy_service = default_context_.proxy_service();
7066   params.ssl_config_service = default_context_.ssl_config_service();
7067   params.http_auth_handler_factory =
7068       default_context_.http_auth_handler_factory();
7069   params.network_delegate = &default_network_delegate_;
7070   params.http_server_properties = default_context_.http_server_properties();
7071   HttpNetworkLayer network_layer(new HttpNetworkSession(params));
7072   network_layer.OnSuspend();
7073
7074   TestURLRequestContext context(true);
7075   context.set_http_transaction_factory(&network_layer);
7076   context.Init();
7077
7078   TestDelegate d;
7079   scoped_ptr<URLRequest> req(
7080       context.CreateRequest(GURL("http://127.0.0.1/"), DEFAULT_PRIORITY, &d));
7081   req->Start();
7082   base::RunLoop().Run();
7083
7084   EXPECT_TRUE(d.request_failed());
7085   EXPECT_EQ(URLRequestStatus::FAILED, req->status().status());
7086   EXPECT_EQ(ERR_NETWORK_IO_SUSPENDED, req->status().error());
7087 }
7088
7089 TEST_F(URLRequestTestHTTP, NetworkAccessedSetOnNetworkRequest) {
7090   ASSERT_TRUE(test_server_.Start());
7091
7092   TestDelegate d;
7093   GURL test_url(test_server_.GetURL(std::string()));
7094   scoped_ptr<URLRequest> req(
7095       default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
7096
7097   req->Start();
7098   base::RunLoop().Run();
7099
7100   EXPECT_TRUE(req->response_info().network_accessed);
7101 }
7102
7103 TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnCachedResponse) {
7104   ASSERT_TRUE(test_server_.Start());
7105
7106   // Populate the cache.
7107   TestDelegate d;
7108   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
7109       test_server_.GetURL("cachetime"), DEFAULT_PRIORITY, &d));
7110   req->Start();
7111   base::RunLoop().Run();
7112
7113   EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
7114   EXPECT_TRUE(req->response_info().network_accessed);
7115   EXPECT_FALSE(req->response_info().was_cached);
7116
7117   req = default_context_.CreateRequest(test_server_.GetURL("cachetime"),
7118                                        DEFAULT_PRIORITY, &d);
7119   req->Start();
7120   base::RunLoop().Run();
7121
7122   EXPECT_EQ(URLRequestStatus::SUCCESS, req->status().status());
7123   EXPECT_FALSE(req->response_info().network_accessed);
7124   EXPECT_TRUE(req->response_info().was_cached);
7125 }
7126
7127 TEST_F(URLRequestTestHTTP, NetworkAccessedClearOnLoadOnlyFromCache) {
7128   ASSERT_TRUE(test_server_.Start());
7129
7130   TestDelegate d;
7131   GURL test_url(test_server_.GetURL(std::string()));
7132   scoped_ptr<URLRequest> req(
7133       default_context_.CreateRequest(test_url, DEFAULT_PRIORITY, &d));
7134   req->SetLoadFlags(LOAD_ONLY_FROM_CACHE);
7135
7136   req->Start();
7137   base::RunLoop().Run();
7138
7139   EXPECT_FALSE(req->response_info().network_accessed);
7140 }
7141
7142 class URLRequestInterceptorTestHTTP : public URLRequestTestHTTP {
7143  public:
7144   // TODO(bengr): Merge this with the URLRequestInterceptorHTTPTest fixture,
7145   // ideally remove the dependency on URLRequestTestJob, and maybe move these
7146   // tests into the factory tests.
7147   URLRequestInterceptorTestHTTP() : URLRequestTestHTTP(), interceptor_(NULL) {
7148   }
7149
7150   void SetUpFactory() override {
7151     interceptor_ = new MockURLRequestInterceptor();
7152     job_factory_.reset(new URLRequestInterceptingJobFactory(
7153         job_factory_.Pass(), make_scoped_ptr(interceptor_)));
7154   }
7155
7156   MockURLRequestInterceptor* interceptor() const {
7157     return interceptor_;
7158   }
7159
7160  private:
7161   MockURLRequestInterceptor* interceptor_;
7162 };
7163
7164 TEST_F(URLRequestInterceptorTestHTTP,
7165        NetworkDelegateNotificationOnRedirectIntercept) {
7166   interceptor()->set_intercept_redirect(true);
7167   interceptor()->set_redirect_headers(MockURLRequestInterceptor::ok_headers());
7168   interceptor()->set_redirect_data(MockURLRequestInterceptor::ok_data());
7169
7170   ASSERT_TRUE(test_server()->Start());
7171
7172   TestDelegate d;
7173   scoped_ptr<URLRequest> req(default_context().CreateRequest(
7174       test_server()->GetURL("files/redirect-test.html"), DEFAULT_PRIORITY, &d));
7175   req->Start();
7176   base::RunLoop().Run();
7177
7178   EXPECT_TRUE(interceptor()->did_intercept_redirect());
7179   // Check we got one good response
7180   EXPECT_TRUE(req->status().is_success());
7181   if (req->status().is_success())
7182     EXPECT_EQ(200, req->response_headers()->response_code());
7183
7184   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
7185   EXPECT_EQ(1, d.response_started_count());
7186   EXPECT_EQ(0, d.received_redirect_count());
7187
7188   EXPECT_EQ(1, default_network_delegate()->created_requests());
7189   EXPECT_EQ(1, default_network_delegate()->before_send_headers_count());
7190   EXPECT_EQ(1, default_network_delegate()->headers_received_count());
7191 }
7192
7193 TEST_F(URLRequestInterceptorTestHTTP,
7194        NetworkDelegateNotificationOnErrorIntercept) {
7195   // Intercept that error and respond with an OK response.
7196   interceptor()->set_intercept_final_response(true);
7197   interceptor()->set_final_headers(MockURLRequestInterceptor::ok_headers());
7198   interceptor()->set_final_data(MockURLRequestInterceptor::ok_data());
7199   default_network_delegate()->set_can_be_intercepted_on_error(true);
7200
7201   ASSERT_TRUE(test_server()->Start());
7202
7203   TestDelegate d;
7204   scoped_ptr<URLRequest> req(default_context().CreateRequest(
7205       test_server()->GetURL("files/two-content-lengths.html"), DEFAULT_PRIORITY,
7206       &d));
7207   req->set_method("GET");
7208   req->Start();
7209   base::RunLoop().Run();
7210
7211   EXPECT_TRUE(interceptor()->did_intercept_final());
7212
7213   // Check we received one good response.
7214   EXPECT_TRUE(req->status().is_success());
7215   if (req->status().is_success())
7216     EXPECT_EQ(200, req->response_headers()->response_code());
7217   EXPECT_EQ(MockURLRequestInterceptor::ok_data(), d.data_received());
7218   EXPECT_EQ(1, d.response_started_count());
7219   EXPECT_EQ(0, d.received_redirect_count());
7220
7221   EXPECT_EQ(1, default_network_delegate()->created_requests());
7222   EXPECT_EQ(1, default_network_delegate()->before_send_headers_count());
7223   EXPECT_EQ(0, default_network_delegate()->headers_received_count());
7224 }
7225
7226 TEST_F(URLRequestInterceptorTestHTTP,
7227        NetworkDelegateNotificationOnResponseIntercept) {
7228   // Intercept that error and respond with an OK response.
7229   interceptor()->set_intercept_final_response(true);
7230
7231   // Intercept with a real URLRequestHttpJob.
7232   interceptor()->set_use_url_request_http_job(true);
7233
7234   ASSERT_TRUE(test_server()->Start());
7235
7236   TestDelegate d;
7237   scoped_ptr<URLRequest> req(default_context().CreateRequest(
7238       test_server()->GetURL("files/simple.html"), DEFAULT_PRIORITY, &d));
7239   req->set_method("GET");
7240   req->Start();
7241   base::RunLoop().Run();
7242
7243   EXPECT_TRUE(interceptor()->did_intercept_final());
7244
7245   // Check we received one good response.
7246   EXPECT_TRUE(req->status().is_success());
7247   if (req->status().is_success())
7248     EXPECT_EQ(200, req->response_headers()->response_code());
7249   EXPECT_EQ("hello", d.data_received());
7250   EXPECT_EQ(1, d.response_started_count());
7251   EXPECT_EQ(0, d.received_redirect_count());
7252
7253   EXPECT_EQ(1, default_network_delegate()->created_requests());
7254   EXPECT_EQ(2, default_network_delegate()->before_send_headers_count());
7255   EXPECT_EQ(2, default_network_delegate()->headers_received_count());
7256 }
7257
7258 class URLRequestTestReferrerPolicy : public URLRequestTest {
7259  public:
7260   URLRequestTestReferrerPolicy() {}
7261
7262   void InstantiateSameOriginServers(SpawnedTestServer::Type origin_type) {
7263     origin_server_.reset(new SpawnedTestServer(
7264         origin_type, SpawnedTestServer::kLocalhost,
7265         origin_type == SpawnedTestServer::TYPE_HTTPS
7266             ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
7267             : base::FilePath(kTestFilePath)));
7268     ASSERT_TRUE(origin_server_->Start());
7269   }
7270
7271   void InstantiateCrossOriginServers(SpawnedTestServer::Type origin_type,
7272                                      SpawnedTestServer::Type destination_type) {
7273     origin_server_.reset(new SpawnedTestServer(
7274         origin_type, SpawnedTestServer::kLocalhost,
7275         origin_type == SpawnedTestServer::TYPE_HTTPS
7276             ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
7277             : base::FilePath(kTestFilePath)));
7278     ASSERT_TRUE(origin_server_->Start());
7279
7280     destination_server_.reset(new SpawnedTestServer(
7281         destination_type, SpawnedTestServer::kLocalhost,
7282         destination_type == SpawnedTestServer::TYPE_HTTPS
7283             ? base::FilePath(FILE_PATH_LITERAL("net/data/ssl"))
7284             : base::FilePath(kTestFilePath)));
7285     ASSERT_TRUE(destination_server_->Start());
7286   }
7287
7288   void VerifyReferrerAfterRedirect(URLRequest::ReferrerPolicy policy,
7289                                    const GURL& referrer,
7290                                    const GURL& expected) {
7291     // Create and execute the request: we'll only have a |destination_server_|
7292     // if the origins are meant to be distinct. Otherwise, we'll use the
7293     // |origin_server_| for both endpoints.
7294     GURL destination_url =
7295         destination_server_ ? destination_server_->GetURL("echoheader?Referer")
7296                             : origin_server_->GetURL("echoheader?Referer");
7297     GURL origin_url =
7298         origin_server_->GetURL("server-redirect?" + destination_url.spec());
7299
7300     TestDelegate d;
7301     scoped_ptr<URLRequest> req(
7302         default_context_.CreateRequest(origin_url, DEFAULT_PRIORITY, &d));
7303     req->set_referrer_policy(policy);
7304     req->SetReferrer(referrer.spec());
7305     req->Start();
7306     base::RunLoop().Run();
7307
7308     EXPECT_EQ(1, d.response_started_count());
7309     EXPECT_EQ(1, d.received_redirect_count());
7310     EXPECT_EQ(destination_url, req->url());
7311     EXPECT_TRUE(req->status().is_success());
7312     EXPECT_EQ(200, req->response_headers()->response_code());
7313
7314     EXPECT_EQ(expected.spec(), req->referrer());
7315     if (expected.is_empty())
7316       EXPECT_EQ("None", d.data_received());
7317     else
7318       EXPECT_EQ(expected.spec(), d.data_received());
7319   }
7320
7321   SpawnedTestServer* origin_server() const { return origin_server_.get(); }
7322
7323  private:
7324   scoped_ptr<SpawnedTestServer> origin_server_;
7325   scoped_ptr<SpawnedTestServer> destination_server_;
7326 };
7327
7328 TEST_F(URLRequestTestReferrerPolicy, HTTPToSameOriginHTTP) {
7329   InstantiateSameOriginServers(SpawnedTestServer::TYPE_HTTP);
7330
7331   VerifyReferrerAfterRedirect(
7332       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
7333       origin_server()->GetURL("path/to/file.html"),
7334       origin_server()->GetURL("path/to/file.html"));
7335
7336   VerifyReferrerAfterRedirect(
7337       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
7338       origin_server()->GetURL("path/to/file.html"),
7339       origin_server()->GetURL("path/to/file.html"));
7340
7341   VerifyReferrerAfterRedirect(
7342       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
7343       origin_server()->GetURL("path/to/file.html"),
7344       origin_server()->GetURL("path/to/file.html"));
7345
7346   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
7347                               origin_server()->GetURL("path/to/file.html"),
7348                               origin_server()->GetURL("path/to/file.html"));
7349 }
7350
7351 // Can't spin up more than one SpawnedTestServer on Android.
7352 #if defined(OS_ANDROID)
7353 #define MAYBE_HTTPToCrossOriginHTTP DISABLED_HTTPToCrosOriginHTTP
7354 #else
7355 #define MAYBE_HTTPToCrossOriginHTTP HTTPToCrossOriginHTTP
7356 #endif
7357 TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPToCrossOriginHTTP) {
7358   InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTP,
7359                                 SpawnedTestServer::TYPE_HTTP);
7360
7361   VerifyReferrerAfterRedirect(
7362       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
7363       origin_server()->GetURL("path/to/file.html"),
7364       origin_server()->GetURL("path/to/file.html"));
7365
7366   VerifyReferrerAfterRedirect(
7367       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
7368       origin_server()->GetURL("path/to/file.html"),
7369       origin_server()->GetURL(std::string()));
7370
7371   VerifyReferrerAfterRedirect(
7372       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
7373       origin_server()->GetURL("path/to/file.html"),
7374       origin_server()->GetURL(std::string()));
7375
7376   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
7377                               origin_server()->GetURL("path/to/file.html"),
7378                               origin_server()->GetURL("path/to/file.html"));
7379 }
7380
7381 TEST_F(URLRequestTestReferrerPolicy, HTTPSToSameOriginHTTPS) {
7382   InstantiateSameOriginServers(SpawnedTestServer::TYPE_HTTPS);
7383
7384   VerifyReferrerAfterRedirect(
7385       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
7386       origin_server()->GetURL("path/to/file.html"),
7387       origin_server()->GetURL("path/to/file.html"));
7388
7389   VerifyReferrerAfterRedirect(
7390       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
7391       origin_server()->GetURL("path/to/file.html"),
7392       origin_server()->GetURL("path/to/file.html"));
7393
7394   VerifyReferrerAfterRedirect(
7395       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
7396       origin_server()->GetURL("path/to/file.html"),
7397       origin_server()->GetURL("path/to/file.html"));
7398
7399   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
7400                               origin_server()->GetURL("path/to/file.html"),
7401                               origin_server()->GetURL("path/to/file.html"));
7402 }
7403
7404 // Can't spin up more than one SpawnedTestServer on Android.
7405 #if defined(OS_ANDROID)
7406 #define MAYBE_HTTPSToCrossOriginHTTPS DISABLED_HTTPSToCrosOriginHTTPS
7407 #else
7408 #define MAYBE_HTTPSToCrossOriginHTTPS HTTPSToCrossOriginHTTPS
7409 #endif
7410 TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPSToCrossOriginHTTPS) {
7411   InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTPS,
7412                                 SpawnedTestServer::TYPE_HTTPS);
7413
7414   VerifyReferrerAfterRedirect(
7415       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
7416       origin_server()->GetURL("path/to/file.html"),
7417       origin_server()->GetURL("path/to/file.html"));
7418
7419   VerifyReferrerAfterRedirect(
7420       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
7421       origin_server()->GetURL("path/to/file.html"),
7422       origin_server()->GetURL(std::string()));
7423
7424   VerifyReferrerAfterRedirect(
7425       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
7426       origin_server()->GetURL("path/to/file.html"),
7427       origin_server()->GetURL(std::string()));
7428
7429   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
7430                               origin_server()->GetURL("path/to/file.html"),
7431                               origin_server()->GetURL("path/to/file.html"));
7432 }
7433
7434 // Can't spin up more than one SpawnedTestServer on Android.
7435 #if defined(OS_ANDROID)
7436 #define MAYBE_HTTPToHTTPS DISABLED_HTTPToHTTPS
7437 #else
7438 #define MAYBE_HTTPToHTTPS HTTPToHTTPS
7439 #endif
7440 TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPToHTTPS) {
7441   InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTP,
7442                                 SpawnedTestServer::TYPE_HTTPS);
7443
7444   VerifyReferrerAfterRedirect(
7445       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
7446       origin_server()->GetURL("path/to/file.html"),
7447       origin_server()->GetURL("path/to/file.html"));
7448
7449   VerifyReferrerAfterRedirect(
7450       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
7451       origin_server()->GetURL("path/to/file.html"),
7452       origin_server()->GetURL(std::string()));
7453
7454   VerifyReferrerAfterRedirect(
7455       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
7456       origin_server()->GetURL("path/to/file.html"),
7457       origin_server()->GetURL(std::string()));
7458
7459   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
7460                               origin_server()->GetURL("path/to/file.html"),
7461                               origin_server()->GetURL("path/to/file.html"));
7462 }
7463
7464 // Can't spin up more than one SpawnedTestServer on Android.
7465 #if defined(OS_ANDROID)
7466 #define MAYBE_HTTPSToHTTP DISABLED_HTTPSToHTTP
7467 #else
7468 #define MAYBE_HTTPSToHTTP HTTPSToHTTP
7469 #endif
7470 TEST_F(URLRequestTestReferrerPolicy, MAYBE_HTTPSToHTTP) {
7471   InstantiateCrossOriginServers(SpawnedTestServer::TYPE_HTTPS,
7472                                 SpawnedTestServer::TYPE_HTTP);
7473
7474   VerifyReferrerAfterRedirect(
7475       URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
7476       origin_server()->GetURL("path/to/file.html"), GURL());
7477
7478   VerifyReferrerAfterRedirect(
7479       URLRequest::REDUCE_REFERRER_GRANULARITY_ON_TRANSITION_CROSS_ORIGIN,
7480       origin_server()->GetURL("path/to/file.html"), GURL());
7481
7482   VerifyReferrerAfterRedirect(
7483       URLRequest::ORIGIN_ONLY_ON_TRANSITION_CROSS_ORIGIN,
7484       origin_server()->GetURL("path/to/file.html"),
7485       origin_server()->GetURL(std::string()));
7486
7487   VerifyReferrerAfterRedirect(URLRequest::NEVER_CLEAR_REFERRER,
7488                               origin_server()->GetURL("path/to/file.html"),
7489                               origin_server()->GetURL("path/to/file.html"));
7490 }
7491
7492 class HTTPSRequestTest : public testing::Test {
7493  public:
7494   HTTPSRequestTest() : default_context_(true) {
7495     default_context_.set_network_delegate(&default_network_delegate_);
7496     default_context_.Init();
7497   }
7498   ~HTTPSRequestTest() override {}
7499
7500  protected:
7501   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
7502   TestURLRequestContext default_context_;
7503 };
7504
7505 TEST_F(HTTPSRequestTest, HTTPSGetTest) {
7506   SpawnedTestServer test_server(
7507       SpawnedTestServer::TYPE_HTTPS,
7508       SpawnedTestServer::kLocalhost,
7509       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7510   ASSERT_TRUE(test_server.Start());
7511
7512   TestDelegate d;
7513   {
7514     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
7515         test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
7516     r->Start();
7517     EXPECT_TRUE(r->is_pending());
7518
7519     base::RunLoop().Run();
7520
7521     EXPECT_EQ(1, d.response_started_count());
7522     EXPECT_FALSE(d.received_data_before_response());
7523     EXPECT_NE(0, d.bytes_received());
7524     CheckSSLInfo(r->ssl_info());
7525     EXPECT_EQ(test_server.host_port_pair().host(),
7526               r->GetSocketAddress().host());
7527     EXPECT_EQ(test_server.host_port_pair().port(),
7528               r->GetSocketAddress().port());
7529   }
7530 }
7531
7532 TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) {
7533   SpawnedTestServer::SSLOptions ssl_options(
7534       SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
7535   SpawnedTestServer test_server(
7536       SpawnedTestServer::TYPE_HTTPS,
7537       ssl_options,
7538       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7539   ASSERT_TRUE(test_server.Start());
7540
7541   bool err_allowed = true;
7542   for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
7543     TestDelegate d;
7544     {
7545       d.set_allow_certificate_errors(err_allowed);
7546       scoped_ptr<URLRequest> r(default_context_.CreateRequest(
7547           test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
7548
7549       r->Start();
7550       EXPECT_TRUE(r->is_pending());
7551
7552       base::RunLoop().Run();
7553
7554       EXPECT_EQ(1, d.response_started_count());
7555       EXPECT_FALSE(d.received_data_before_response());
7556       EXPECT_TRUE(d.have_certificate_errors());
7557       if (err_allowed) {
7558         EXPECT_NE(0, d.bytes_received());
7559         CheckSSLInfo(r->ssl_info());
7560       } else {
7561         EXPECT_EQ(0, d.bytes_received());
7562       }
7563     }
7564   }
7565 }
7566
7567 TEST_F(HTTPSRequestTest, HTTPSExpiredTest) {
7568   SpawnedTestServer::SSLOptions ssl_options(
7569       SpawnedTestServer::SSLOptions::CERT_EXPIRED);
7570   SpawnedTestServer test_server(
7571       SpawnedTestServer::TYPE_HTTPS,
7572       ssl_options,
7573       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7574   ASSERT_TRUE(test_server.Start());
7575
7576   // Iterate from false to true, just so that we do the opposite of the
7577   // previous test in order to increase test coverage.
7578   bool err_allowed = false;
7579   for (int i = 0; i < 2 ; i++, err_allowed = !err_allowed) {
7580     TestDelegate d;
7581     {
7582       d.set_allow_certificate_errors(err_allowed);
7583       scoped_ptr<URLRequest> r(default_context_.CreateRequest(
7584           test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
7585
7586       r->Start();
7587       EXPECT_TRUE(r->is_pending());
7588
7589       base::RunLoop().Run();
7590
7591       EXPECT_EQ(1, d.response_started_count());
7592       EXPECT_FALSE(d.received_data_before_response());
7593       EXPECT_TRUE(d.have_certificate_errors());
7594       if (err_allowed) {
7595         EXPECT_NE(0, d.bytes_received());
7596         CheckSSLInfo(r->ssl_info());
7597       } else {
7598         EXPECT_EQ(0, d.bytes_received());
7599       }
7600     }
7601   }
7602 }
7603
7604 // Tests that servers which require a deprecated cipher suite still work.
7605 TEST_F(HTTPSRequestTest, CipherFallbackTest) {
7606   TestNetLog net_log;
7607   default_context_.set_net_log(&net_log);
7608
7609   SpawnedTestServer::SSLOptions ssl_options;
7610   ssl_options.bulk_ciphers = SpawnedTestServer::SSLOptions::BULK_CIPHER_RC4;
7611   SpawnedTestServer test_server(
7612       SpawnedTestServer::TYPE_HTTPS, ssl_options,
7613       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7614   ASSERT_TRUE(test_server.Start());
7615
7616   TestDelegate d;
7617   scoped_ptr<URLRequest> r(default_context_.CreateRequest(
7618       test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
7619   r->Start();
7620   EXPECT_TRUE(r->is_pending());
7621
7622   base::RunLoop().Run();
7623
7624   EXPECT_EQ(1, d.response_started_count());
7625   EXPECT_FALSE(d.received_data_before_response());
7626   EXPECT_NE(0, d.bytes_received());
7627   CheckSSLInfo(r->ssl_info());
7628   EXPECT_EQ(test_server.host_port_pair().host(), r->GetSocketAddress().host());
7629   EXPECT_EQ(test_server.host_port_pair().port(), r->GetSocketAddress().port());
7630
7631   // No version downgrade should have been necessary.
7632   EXPECT_FALSE(r->ssl_info().connection_status &
7633                SSL_CONNECTION_VERSION_FALLBACK);
7634   int expected_version = SSL_CONNECTION_VERSION_TLS1_2;
7635   if (SSLClientSocket::GetMaxSupportedSSLVersion() <
7636       SSL_PROTOCOL_VERSION_TLS1_2) {
7637     expected_version = SSL_CONNECTION_VERSION_TLS1_1;
7638   }
7639   EXPECT_EQ(expected_version,
7640             SSLConnectionStatusToVersion(r->ssl_info().connection_status));
7641
7642   TestNetLogEntry::List entries;
7643   net_log.GetEntries(&entries);
7644   ExpectLogContainsSomewhere(entries, 0, NetLog::TYPE_SSL_CIPHER_FALLBACK,
7645                              NetLog::PHASE_NONE);
7646 }
7647
7648 // This tests that a load of www.google.com with a certificate error sets
7649 // the |certificate_errors_are_fatal| flag correctly. This flag will cause
7650 // the interstitial to be fatal.
7651 TEST_F(HTTPSRequestTest, HTTPSPreloadedHSTSTest) {
7652   SpawnedTestServer::SSLOptions ssl_options(
7653       SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
7654   SpawnedTestServer test_server(
7655       SpawnedTestServer::TYPE_HTTPS,
7656       ssl_options,
7657       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7658   ASSERT_TRUE(test_server.Start());
7659
7660   // We require that the URL be www.google.com in order to pick up the
7661   // preloaded HSTS entries in the TransportSecurityState. This means that we
7662   // have to use a MockHostResolver in order to direct www.google.com to the
7663   // testserver. By default, MockHostResolver maps all hosts to 127.0.0.1.
7664
7665   MockHostResolver host_resolver;
7666   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
7667   TestURLRequestContext context(true);
7668   context.set_network_delegate(&network_delegate);
7669   context.set_host_resolver(&host_resolver);
7670   TransportSecurityState transport_security_state;
7671   context.set_transport_security_state(&transport_security_state);
7672   context.Init();
7673
7674   TestDelegate d;
7675   scoped_ptr<URLRequest> r(context.CreateRequest(
7676       GURL(base::StringPrintf("https://www.google.com:%d",
7677                               test_server.host_port_pair().port())),
7678       DEFAULT_PRIORITY, &d));
7679
7680   r->Start();
7681   EXPECT_TRUE(r->is_pending());
7682
7683   base::RunLoop().Run();
7684
7685   EXPECT_EQ(1, d.response_started_count());
7686   EXPECT_FALSE(d.received_data_before_response());
7687   EXPECT_TRUE(d.have_certificate_errors());
7688   EXPECT_TRUE(d.certificate_errors_are_fatal());
7689 }
7690
7691 // This tests that cached HTTPS page loads do not cause any updates to the
7692 // TransportSecurityState.
7693 TEST_F(HTTPSRequestTest, HTTPSErrorsNoClobberTSSTest) {
7694   // The actual problem -- CERT_MISMATCHED_NAME in this case -- doesn't
7695   // matter. It just has to be any error.
7696   SpawnedTestServer::SSLOptions ssl_options(
7697       SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME);
7698   SpawnedTestServer test_server(
7699       SpawnedTestServer::TYPE_HTTPS,
7700       ssl_options,
7701       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7702   ASSERT_TRUE(test_server.Start());
7703
7704   // We require that the URL be www.google.com in order to pick up the static
7705   // and dynamic STS and PKP entries in the TransportSecurityState. This means
7706   // that we have to use a MockHostResolver in order to direct www.google.com to
7707   // the testserver. By default, MockHostResolver maps all hosts to 127.0.0.1.
7708
7709   MockHostResolver host_resolver;
7710   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
7711   TestURLRequestContext context(true);
7712   context.set_network_delegate(&network_delegate);
7713   context.set_host_resolver(&host_resolver);
7714   TransportSecurityState transport_security_state;
7715
7716   TransportSecurityState::STSState static_sts_state;
7717   TransportSecurityState::PKPState static_pkp_state;
7718   EXPECT_TRUE(transport_security_state.GetStaticDomainState(
7719       "www.google.com", &static_sts_state, &static_pkp_state));
7720   context.set_transport_security_state(&transport_security_state);
7721   context.Init();
7722
7723   TransportSecurityState::STSState dynamic_sts_state;
7724   TransportSecurityState::PKPState dynamic_pkp_state;
7725   EXPECT_FALSE(transport_security_state.GetDynamicSTSState("www.google.com",
7726                                                            &dynamic_sts_state));
7727   EXPECT_FALSE(transport_security_state.GetDynamicPKPState("www.google.com",
7728                                                            &dynamic_pkp_state));
7729
7730   TestDelegate d;
7731   scoped_ptr<URLRequest> r(context.CreateRequest(
7732       GURL(base::StringPrintf("https://www.google.com:%d",
7733                               test_server.host_port_pair().port())),
7734       DEFAULT_PRIORITY, &d));
7735
7736   r->Start();
7737   EXPECT_TRUE(r->is_pending());
7738
7739   base::RunLoop().Run();
7740
7741   EXPECT_EQ(1, d.response_started_count());
7742   EXPECT_FALSE(d.received_data_before_response());
7743   EXPECT_TRUE(d.have_certificate_errors());
7744   EXPECT_TRUE(d.certificate_errors_are_fatal());
7745
7746   // Get a fresh copy of the states, and check that they haven't changed.
7747   TransportSecurityState::STSState new_static_sts_state;
7748   TransportSecurityState::PKPState new_static_pkp_state;
7749   EXPECT_TRUE(transport_security_state.GetStaticDomainState(
7750       "www.google.com", &new_static_sts_state, &new_static_pkp_state));
7751   TransportSecurityState::STSState new_dynamic_sts_state;
7752   TransportSecurityState::PKPState new_dynamic_pkp_state;
7753   EXPECT_FALSE(transport_security_state.GetDynamicSTSState(
7754       "www.google.com", &new_dynamic_sts_state));
7755   EXPECT_FALSE(transport_security_state.GetDynamicPKPState(
7756       "www.google.com", &new_dynamic_pkp_state));
7757
7758   EXPECT_EQ(new_static_sts_state.upgrade_mode, static_sts_state.upgrade_mode);
7759   EXPECT_EQ(new_static_sts_state.include_subdomains,
7760             static_sts_state.include_subdomains);
7761   EXPECT_EQ(new_static_pkp_state.include_subdomains,
7762             static_pkp_state.include_subdomains);
7763   EXPECT_TRUE(FingerprintsEqual(new_static_pkp_state.spki_hashes,
7764                                 static_pkp_state.spki_hashes));
7765   EXPECT_TRUE(FingerprintsEqual(new_static_pkp_state.bad_spki_hashes,
7766                                 static_pkp_state.bad_spki_hashes));
7767 }
7768
7769 // Make sure HSTS preserves a POST request's method and body.
7770 TEST_F(HTTPSRequestTest, HSTSPreservesPosts) {
7771   static const char kData[] = "hello world";
7772
7773   SpawnedTestServer::SSLOptions ssl_options(
7774       SpawnedTestServer::SSLOptions::CERT_OK);
7775   SpawnedTestServer test_server(
7776       SpawnedTestServer::TYPE_HTTPS,
7777       ssl_options,
7778       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7779   ASSERT_TRUE(test_server.Start());
7780
7781
7782   // Per spec, TransportSecurityState expects a domain name, rather than an IP
7783   // address, so a MockHostResolver is needed to redirect www.somewhere.com to
7784   // the SpawnedTestServer.  By default, MockHostResolver maps all hosts
7785   // to 127.0.0.1.
7786   MockHostResolver host_resolver;
7787
7788   // Force https for www.somewhere.com.
7789   TransportSecurityState transport_security_state;
7790   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1000);
7791   bool include_subdomains = false;
7792   transport_security_state.AddHSTS("www.somewhere.com", expiry,
7793                                    include_subdomains);
7794
7795   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
7796
7797   TestURLRequestContext context(true);
7798   context.set_host_resolver(&host_resolver);
7799   context.set_transport_security_state(&transport_security_state);
7800   context.set_network_delegate(&network_delegate);
7801   context.Init();
7802
7803   TestDelegate d;
7804   // Navigating to https://www.somewhere.com instead of https://127.0.0.1 will
7805   // cause a certificate error.  Ignore the error.
7806   d.set_allow_certificate_errors(true);
7807
7808   scoped_ptr<URLRequest> req(context.CreateRequest(
7809       GURL(base::StringPrintf("http://www.somewhere.com:%d/echo",
7810                               test_server.host_port_pair().port())),
7811       DEFAULT_PRIORITY, &d));
7812   req->set_method("POST");
7813   req->set_upload(CreateSimpleUploadData(kData));
7814
7815   req->Start();
7816   base::RunLoop().Run();
7817
7818   EXPECT_EQ("https", req->url().scheme());
7819   EXPECT_EQ("POST", req->method());
7820   EXPECT_EQ(kData, d.data_received());
7821
7822   LoadTimingInfo load_timing_info;
7823   network_delegate.GetLoadTimingInfoBeforeRedirect(&load_timing_info);
7824   // LoadTimingInfo of HSTS redirects is similar to that of network cache hits
7825   TestLoadTimingCacheHitNoNetwork(load_timing_info);
7826 }
7827
7828 // Make sure that the CORS headers are added to cross-origin HSTS redirects.
7829 TEST_F(HTTPSRequestTest, HSTSCrossOriginAddHeaders) {
7830   static const char kOriginHeaderValue[] = "http://www.example.com";
7831
7832   SpawnedTestServer::SSLOptions ssl_options(
7833       SpawnedTestServer::SSLOptions::CERT_OK);
7834   SpawnedTestServer test_server(
7835       SpawnedTestServer::TYPE_HTTPS,
7836       ssl_options,
7837       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7838   ASSERT_TRUE(test_server.Start());
7839
7840   // Per spec, TransportSecurityState expects a domain name, rather than an IP
7841   // address, so a MockHostResolver is needed to redirect example.net to the
7842   // SpawnedTestServer. MockHostResolver maps all hosts to 127.0.0.1 by default.
7843   MockHostResolver host_resolver;
7844
7845   TransportSecurityState transport_security_state;
7846   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1);
7847   bool include_subdomains = false;
7848   transport_security_state.AddHSTS("example.net", expiry, include_subdomains);
7849
7850   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
7851
7852   MockCertVerifier cert_verifier;
7853   cert_verifier.set_default_result(OK);
7854
7855   TestURLRequestContext context(true);
7856   context.set_host_resolver(&host_resolver);
7857   context.set_transport_security_state(&transport_security_state);
7858   context.set_network_delegate(&network_delegate);
7859   context.set_cert_verifier(&cert_verifier);
7860   context.Init();
7861
7862   GURL hsts_http_url(base::StringPrintf("http://example.net:%d/somehstssite",
7863                                         test_server.host_port_pair().port()));
7864   url::Replacements<char> replacements;
7865   const char kNewScheme[] = "https";
7866   replacements.SetScheme(kNewScheme, url::Component(0, strlen(kNewScheme)));
7867   GURL hsts_https_url = hsts_http_url.ReplaceComponents(replacements);
7868
7869   TestDelegate d;
7870   // Quit on redirect to allow response header inspection upon redirect.
7871   d.set_quit_on_redirect(true);
7872
7873   scoped_ptr<URLRequest> req(
7874       context.CreateRequest(hsts_http_url, DEFAULT_PRIORITY, &d));
7875   // Set Origin header to simulate a cross-origin request.
7876   HttpRequestHeaders request_headers;
7877   request_headers.SetHeader("Origin", kOriginHeaderValue);
7878   req->SetExtraRequestHeaders(request_headers);
7879
7880   req->Start();
7881   base::RunLoop().Run();
7882
7883   EXPECT_EQ(1, d.received_redirect_count());
7884
7885   const HttpResponseHeaders* headers = req->response_headers();
7886   std::string redirect_location;
7887   EXPECT_TRUE(headers->EnumerateHeader(NULL, "Location", &redirect_location));
7888   EXPECT_EQ(hsts_https_url.spec(), redirect_location);
7889
7890   std::string received_cors_header;
7891   EXPECT_TRUE(headers->EnumerateHeader(NULL, "Access-Control-Allow-Origin",
7892                                        &received_cors_header));
7893   EXPECT_EQ(kOriginHeaderValue, received_cors_header);
7894 }
7895
7896 // This just tests the behaviour of GetHSTSRedirect(). End-to-end tests of HSTS
7897 // are performed in net/websockets/websocket_end_to_end_test.cc.
7898 TEST(WebSocketURLRequestTest, HSTSApplied) {
7899   TestNetworkDelegate network_delegate;
7900   TransportSecurityState transport_security_state;
7901   base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1);
7902   bool include_subdomains = false;
7903   transport_security_state.AddHSTS("example.net", expiry, include_subdomains);
7904   TestURLRequestContext context(true);
7905   context.set_transport_security_state(&transport_security_state);
7906   context.set_network_delegate(&network_delegate);
7907   context.Init();
7908   GURL ws_url("ws://example.net/echo");
7909   TestDelegate delegate;
7910   scoped_ptr<URLRequest> request(
7911       context.CreateRequest(ws_url, DEFAULT_PRIORITY, &delegate));
7912   EXPECT_TRUE(request->GetHSTSRedirect(&ws_url));
7913   EXPECT_TRUE(ws_url.SchemeIs("wss"));
7914 }
7915
7916 namespace {
7917
7918 class SSLClientAuthTestDelegate : public TestDelegate {
7919  public:
7920   SSLClientAuthTestDelegate() : on_certificate_requested_count_(0) {
7921   }
7922   void OnCertificateRequested(URLRequest* request,
7923                               SSLCertRequestInfo* cert_request_info) override {
7924     on_certificate_requested_count_++;
7925     base::MessageLoop::current()->Quit();
7926   }
7927   int on_certificate_requested_count() {
7928     return on_certificate_requested_count_;
7929   }
7930  private:
7931   int on_certificate_requested_count_;
7932 };
7933
7934 }  // namespace
7935
7936 // TODO(davidben): Test the rest of the code. Specifically,
7937 // - Filtering which certificates to select.
7938 // - Sending a certificate back.
7939 // - Getting a certificate request in an SSL renegotiation sending the
7940 //   HTTP request.
7941 TEST_F(HTTPSRequestTest, ClientAuthTest) {
7942   SpawnedTestServer::SSLOptions ssl_options;
7943   ssl_options.request_client_certificate = true;
7944   SpawnedTestServer test_server(
7945       SpawnedTestServer::TYPE_HTTPS,
7946       ssl_options,
7947       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7948   ASSERT_TRUE(test_server.Start());
7949
7950   SSLClientAuthTestDelegate d;
7951   {
7952     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
7953         test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
7954
7955     r->Start();
7956     EXPECT_TRUE(r->is_pending());
7957
7958     base::RunLoop().Run();
7959
7960     EXPECT_EQ(1, d.on_certificate_requested_count());
7961     EXPECT_FALSE(d.received_data_before_response());
7962     EXPECT_EQ(0, d.bytes_received());
7963
7964     // Send no certificate.
7965     // TODO(davidben): Get temporary client cert import (with keys) working on
7966     // all platforms so we can test sending a cert as well.
7967     r->ContinueWithCertificate(NULL);
7968
7969     base::RunLoop().Run();
7970
7971     EXPECT_EQ(1, d.response_started_count());
7972     EXPECT_FALSE(d.received_data_before_response());
7973     EXPECT_NE(0, d.bytes_received());
7974   }
7975 }
7976
7977 TEST_F(HTTPSRequestTest, ResumeTest) {
7978   // Test that we attempt a session resume when making two connections to the
7979   // same host.
7980   SpawnedTestServer::SSLOptions ssl_options;
7981   ssl_options.record_resume = true;
7982   SpawnedTestServer test_server(
7983       SpawnedTestServer::TYPE_HTTPS,
7984       ssl_options,
7985       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
7986   ASSERT_TRUE(test_server.Start());
7987
7988   SSLClientSocket::ClearSessionCache();
7989
7990   {
7991     TestDelegate d;
7992     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
7993         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d));
7994
7995     r->Start();
7996     EXPECT_TRUE(r->is_pending());
7997
7998     base::RunLoop().Run();
7999
8000     EXPECT_EQ(1, d.response_started_count());
8001   }
8002
8003   reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
8004     CloseAllConnections();
8005
8006   {
8007     TestDelegate d;
8008     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
8009         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d));
8010
8011     r->Start();
8012     EXPECT_TRUE(r->is_pending());
8013
8014     base::RunLoop().Run();
8015
8016     // The response will look like;
8017     //   insert abc
8018     //   lookup abc
8019     //   insert xyz
8020     //
8021     // With a newline at the end which makes the split think that there are
8022     // four lines.
8023
8024     EXPECT_EQ(1, d.response_started_count());
8025     std::vector<std::string> lines = base::SplitString(
8026         d.data_received(), "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
8027     ASSERT_EQ(4u, lines.size()) << d.data_received();
8028
8029     std::string session_id;
8030
8031     for (size_t i = 0; i < 2; i++) {
8032       std::vector<std::string> parts = base::SplitString(
8033           lines[i], "\t", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
8034       ASSERT_EQ(2u, parts.size());
8035       if (i == 0) {
8036         EXPECT_EQ("insert", parts[0]);
8037         session_id = parts[1];
8038       } else {
8039         EXPECT_EQ("lookup", parts[0]);
8040         EXPECT_EQ(session_id, parts[1]);
8041       }
8042     }
8043   }
8044 }
8045
8046 // AssertTwoDistinctSessionsInserted checks that |session_info|, which must be
8047 // the result of fetching "ssl-session-cache" from the test server, indicates
8048 // that exactly two different sessions were inserted, with no lookups etc.
8049 static void AssertTwoDistinctSessionsInserted(const string& session_info) {
8050   std::vector<std::string> lines = base::SplitString(
8051       session_info, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
8052   ASSERT_EQ(3u, lines.size()) << session_info;
8053
8054   std::string session_id;
8055   for (size_t i = 0; i < 2; i++) {
8056     std::vector<std::string> parts = base::SplitString(
8057         lines[i], "\t", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
8058     ASSERT_EQ(2u, parts.size());
8059     EXPECT_EQ("insert", parts[0]);
8060     if (i == 0) {
8061       session_id = parts[1];
8062     } else {
8063       EXPECT_NE(session_id, parts[1]);
8064     }
8065   }
8066 }
8067
8068 TEST_F(HTTPSRequestTest, SSLSessionCacheShardTest) {
8069   // Test that sessions aren't resumed when the value of ssl_session_cache_shard
8070   // differs.
8071   SpawnedTestServer::SSLOptions ssl_options;
8072   ssl_options.record_resume = true;
8073   SpawnedTestServer test_server(
8074       SpawnedTestServer::TYPE_HTTPS,
8075       ssl_options,
8076       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
8077   ASSERT_TRUE(test_server.Start());
8078
8079   SSLClientSocket::ClearSessionCache();
8080
8081   {
8082     TestDelegate d;
8083     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
8084         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d));
8085
8086     r->Start();
8087     EXPECT_TRUE(r->is_pending());
8088
8089     base::RunLoop().Run();
8090
8091     EXPECT_EQ(1, d.response_started_count());
8092   }
8093
8094   // Now create a new HttpCache with a different ssl_session_cache_shard value.
8095   HttpNetworkSession::Params params;
8096   params.host_resolver = default_context_.host_resolver();
8097   params.cert_verifier = default_context_.cert_verifier();
8098   params.transport_security_state = default_context_.transport_security_state();
8099   params.proxy_service = default_context_.proxy_service();
8100   params.ssl_config_service = default_context_.ssl_config_service();
8101   params.http_auth_handler_factory =
8102       default_context_.http_auth_handler_factory();
8103   params.network_delegate = &default_network_delegate_;
8104   params.http_server_properties = default_context_.http_server_properties();
8105   params.ssl_session_cache_shard = "alternate";
8106
8107   scoped_ptr<HttpCache> cache(new HttpCache(
8108       new HttpNetworkSession(params),
8109       HttpCache::DefaultBackend::InMemory(0)));
8110
8111   default_context_.set_http_transaction_factory(cache.get());
8112
8113   {
8114     TestDelegate d;
8115     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
8116         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d));
8117
8118     r->Start();
8119     EXPECT_TRUE(r->is_pending());
8120
8121     base::RunLoop().Run();
8122
8123     // The response will look like;
8124     //   insert abc
8125     //   insert xyz
8126     //
8127     // With a newline at the end which makes the split think that there are
8128     // three lines.
8129
8130     EXPECT_EQ(1, d.response_started_count());
8131     AssertTwoDistinctSessionsInserted(d.data_received());
8132   }
8133 }
8134
8135 #if defined(OS_WIN)
8136
8137 namespace {
8138
8139 bool IsECDSACipherSuite(uint16_t cipher_suite) {
8140   const char* key_exchange;
8141   const char* cipher;
8142   const char* mac;
8143   bool is_aead;
8144   SSLCipherSuiteToStrings(&key_exchange, &cipher, &mac, &is_aead, cipher_suite);
8145   return std::string(key_exchange).find("ECDSA") != std::string::npos;
8146 }
8147
8148 }  // namespace
8149
8150 // Test that ECDSA is disabled on Windows XP, where ECDSA certificates cannot be
8151 // verified.
8152 TEST_F(HTTPSRequestTest, DisableECDSAOnXP) {
8153   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
8154     LOG(INFO) << "Skipping test on this version.";
8155     return;
8156   }
8157
8158   SpawnedTestServer test_server(
8159       SpawnedTestServer::TYPE_HTTPS,
8160       SpawnedTestServer::kLocalhost,
8161       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
8162   ASSERT_TRUE(test_server.Start());
8163
8164   TestDelegate d;
8165   scoped_ptr<URLRequest> r(default_context_.CreateRequest(
8166       test_server.GetURL("client-cipher-list"), DEFAULT_PRIORITY, &d));
8167   r->Start();
8168   EXPECT_TRUE(r->is_pending());
8169
8170   base::RunLoop().Run();
8171
8172   EXPECT_EQ(1, d.response_started_count());
8173   std::vector<std::string> lines = base::SplitString(
8174       d.data_received(), "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
8175
8176   for (size_t i = 0; i < lines.size(); i++) {
8177     int cipher_suite;
8178     ASSERT_TRUE(base::StringToInt(lines[i], &cipher_suite));
8179     EXPECT_FALSE(IsECDSACipherSuite(cipher_suite))
8180         << "ClientHello advertised " << cipher_suite;
8181   }
8182 }
8183
8184 #endif  // OS_WIN
8185
8186 class TestSSLConfigService : public SSLConfigService {
8187  public:
8188   TestSSLConfigService(bool ev_enabled,
8189                        bool online_rev_checking,
8190                        bool rev_checking_required_local_anchors)
8191       : ev_enabled_(ev_enabled),
8192         online_rev_checking_(online_rev_checking),
8193         rev_checking_required_local_anchors_(
8194             rev_checking_required_local_anchors),
8195         min_version_(kDefaultSSLVersionMin),
8196         fallback_min_version_(kDefaultSSLVersionFallbackMin) {}
8197
8198   void set_min_version(uint16 version) {
8199     min_version_ = version;
8200   }
8201
8202   void set_fallback_min_version(uint16 version) {
8203     fallback_min_version_ = version;
8204   }
8205
8206   // SSLConfigService:
8207   void GetSSLConfig(SSLConfig* config) override {
8208     *config = SSLConfig();
8209     config->rev_checking_enabled = online_rev_checking_;
8210     config->verify_ev_cert = ev_enabled_;
8211     config->rev_checking_required_local_anchors =
8212         rev_checking_required_local_anchors_;
8213     if (fallback_min_version_) {
8214       config->version_fallback_min = fallback_min_version_;
8215     }
8216     if (min_version_) {
8217       config->version_min = min_version_;
8218     }
8219   }
8220
8221  protected:
8222   ~TestSSLConfigService() override {}
8223
8224  private:
8225   const bool ev_enabled_;
8226   const bool online_rev_checking_;
8227   const bool rev_checking_required_local_anchors_;
8228   uint16 min_version_;
8229   uint16 fallback_min_version_;
8230 };
8231
8232 class FallbackTestURLRequestContext : public TestURLRequestContext {
8233  public:
8234   explicit FallbackTestURLRequestContext(bool delay_initialization)
8235       : TestURLRequestContext(delay_initialization) {}
8236
8237   void set_fallback_min_version(uint16 version) {
8238     TestSSLConfigService *ssl_config_service =
8239         new TestSSLConfigService(true /* check for EV */,
8240                                  false /* online revocation checking */,
8241                                  false /* require rev. checking for local
8242                                           anchors */);
8243     ssl_config_service->set_fallback_min_version(version);
8244     set_ssl_config_service(ssl_config_service);
8245   }
8246 };
8247
8248 class HTTPSFallbackTest : public testing::Test {
8249  public:
8250   HTTPSFallbackTest() : context_(true) {}
8251   ~HTTPSFallbackTest() override {}
8252
8253  protected:
8254   void DoFallbackTest(const SpawnedTestServer::SSLOptions& ssl_options) {
8255     DCHECK(!request_);
8256     context_.Init();
8257     delegate_.set_allow_certificate_errors(true);
8258
8259     SpawnedTestServer test_server(
8260         SpawnedTestServer::TYPE_HTTPS,
8261         ssl_options,
8262         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
8263     ASSERT_TRUE(test_server.Start());
8264
8265     request_ = context_.CreateRequest(test_server.GetURL(std::string()),
8266                                       DEFAULT_PRIORITY, &delegate_);
8267     request_->Start();
8268
8269     base::RunLoop().Run();
8270   }
8271
8272   void set_fallback_min_version(uint16 version) {
8273     context_.set_fallback_min_version(version);
8274   }
8275
8276   void ExpectConnection(int version) {
8277     EXPECT_EQ(1, delegate_.response_started_count());
8278     EXPECT_NE(0, delegate_.bytes_received());
8279     EXPECT_EQ(version, SSLConnectionStatusToVersion(
8280         request_->ssl_info().connection_status));
8281     EXPECT_TRUE(request_->ssl_info().connection_status &
8282                 SSL_CONNECTION_VERSION_FALLBACK);
8283   }
8284
8285   void ExpectFailure(int error) {
8286     EXPECT_EQ(1, delegate_.response_started_count());
8287     EXPECT_FALSE(request_->status().is_success());
8288     EXPECT_EQ(URLRequestStatus::FAILED, request_->status().status());
8289     EXPECT_EQ(error, request_->status().error());
8290   }
8291
8292  private:
8293   TestDelegate delegate_;
8294   FallbackTestURLRequestContext context_;
8295   scoped_ptr<URLRequest> request_;
8296 };
8297
8298 // Tests the TLS 1.0 fallback doesn't happen.
8299 TEST_F(HTTPSFallbackTest, TLSv1NoFallback) {
8300   SpawnedTestServer::SSLOptions ssl_options(
8301       SpawnedTestServer::SSLOptions::CERT_OK);
8302   ssl_options.tls_intolerant =
8303       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
8304
8305   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
8306   ExpectFailure(ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION);
8307 }
8308
8309 // Tests the TLS 1.1 fallback.
8310 TEST_F(HTTPSFallbackTest, TLSv1_1Fallback) {
8311   if (SSLClientSocket::GetMaxSupportedSSLVersion() <
8312       SSL_PROTOCOL_VERSION_TLS1_2) {
8313     return;
8314   }
8315
8316   SpawnedTestServer::SSLOptions ssl_options(
8317       SpawnedTestServer::SSLOptions::CERT_OK);
8318   ssl_options.tls_intolerant =
8319       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_2;
8320
8321   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
8322   ExpectConnection(SSL_CONNECTION_VERSION_TLS1_1);
8323 }
8324
8325 // Tests that the TLS 1.1 fallback triggers on closed connections.
8326 TEST_F(HTTPSFallbackTest, TLSv1_1FallbackClosed) {
8327   if (SSLClientSocket::GetMaxSupportedSSLVersion() <
8328       SSL_PROTOCOL_VERSION_TLS1_2) {
8329     return;
8330   }
8331
8332   SpawnedTestServer::SSLOptions ssl_options(
8333       SpawnedTestServer::SSLOptions::CERT_OK);
8334   ssl_options.tls_intolerant =
8335       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_2;
8336   ssl_options.tls_intolerance_type =
8337       SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE;
8338
8339   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
8340   ExpectConnection(SSL_CONNECTION_VERSION_TLS1_1);
8341 }
8342
8343 // This test is disabled on Android because the remote test server doesn't cause
8344 // a TCP reset.
8345 #if !defined(OS_ANDROID)
8346 // Tests fallback to TLS 1.1 on connection reset.
8347 TEST_F(HTTPSFallbackTest, TLSv1_1FallbackReset) {
8348   if (SSLClientSocket::GetMaxSupportedSSLVersion() <
8349       SSL_PROTOCOL_VERSION_TLS1_2) {
8350     return;
8351   }
8352
8353   SpawnedTestServer::SSLOptions ssl_options(
8354       SpawnedTestServer::SSLOptions::CERT_OK);
8355   ssl_options.tls_intolerant =
8356       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_2;
8357   ssl_options.tls_intolerance_type =
8358       SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_RESET;
8359
8360   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
8361   ExpectConnection(SSL_CONNECTION_VERSION_TLS1_1);
8362 }
8363 #endif  // !OS_ANDROID
8364
8365 // Tests that we don't fallback on handshake failure with servers that implement
8366 // TLS_FALLBACK_SCSV. Also ensure that the original error code is reported.
8367 TEST_F(HTTPSFallbackTest, FallbackSCSV) {
8368   SpawnedTestServer::SSLOptions ssl_options(
8369       SpawnedTestServer::SSLOptions::CERT_OK);
8370   // Configure HTTPS server to be intolerant of TLS >= 1.1 in order to trigger
8371   // a version fallback.
8372   ssl_options.tls_intolerant =
8373       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
8374   // Have the server process TLS_FALLBACK_SCSV so that version fallback
8375   // connections are rejected.
8376   ssl_options.fallback_scsv_enabled = true;
8377
8378   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
8379
8380   // ERR_SSL_VERSION_OR_CIPHER_MISMATCH is how the server simulates version
8381   // intolerance. If the fallback SCSV is processed when the original error
8382   // that caused the fallback should be returned, which should be
8383   // ERR_SSL_VERSION_OR_CIPHER_MISMATCH.
8384   ExpectFailure(ERR_SSL_VERSION_OR_CIPHER_MISMATCH);
8385 }
8386
8387 // Tests that we don't fallback on connection closed with servers that implement
8388 // TLS_FALLBACK_SCSV. Also ensure that the original error code is reported.
8389 TEST_F(HTTPSFallbackTest, FallbackSCSVClosed) {
8390   SpawnedTestServer::SSLOptions ssl_options(
8391       SpawnedTestServer::SSLOptions::CERT_OK);
8392   // Configure HTTPS server to be intolerant of TLS >= 1.1 in order to trigger
8393   // a version fallback.
8394   ssl_options.tls_intolerant =
8395       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
8396   ssl_options.tls_intolerance_type =
8397       SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE;
8398   // Have the server process TLS_FALLBACK_SCSV so that version fallback
8399   // connections are rejected.
8400   ssl_options.fallback_scsv_enabled = true;
8401
8402   ASSERT_NO_FATAL_FAILURE(DoFallbackTest(ssl_options));
8403
8404   // The original error should be replayed on rejected fallback.
8405   ExpectFailure(ERR_CONNECTION_CLOSED);
8406 }
8407
8408 // Test that fallback probe connections don't cause sessions to be cached.
8409 TEST_F(HTTPSRequestTest, FallbackProbeNoCache) {
8410   SpawnedTestServer::SSLOptions ssl_options(
8411       SpawnedTestServer::SSLOptions::CERT_OK);
8412   ssl_options.tls_intolerant =
8413       SpawnedTestServer::SSLOptions::TLS_INTOLERANT_TLS1_1;
8414   ssl_options.tls_intolerance_type =
8415       SpawnedTestServer::SSLOptions::TLS_INTOLERANCE_CLOSE;
8416   ssl_options.record_resume = true;
8417
8418   SpawnedTestServer test_server(
8419       SpawnedTestServer::TYPE_HTTPS,
8420       ssl_options,
8421       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
8422   ASSERT_TRUE(test_server.Start());
8423
8424   SSLClientSocket::ClearSessionCache();
8425
8426   // Make a connection that does a probe fallback to TLSv1 but fails because
8427   // TLSv1 fallback is disabled. We don't wish a session for this connection to
8428   // be inserted locally.
8429   {
8430     TestDelegate delegate;
8431     FallbackTestURLRequestContext context(true);
8432
8433     context.set_fallback_min_version(SSL_PROTOCOL_VERSION_TLS1_2);
8434     context.Init();
8435     scoped_ptr<URLRequest> request(context.CreateRequest(
8436         test_server.GetURL(std::string()), DEFAULT_PRIORITY, &delegate));
8437     request->Start();
8438
8439     base::RunLoop().Run();
8440
8441     EXPECT_EQ(1, delegate.response_started_count());
8442     EXPECT_FALSE(request->status().is_success());
8443     EXPECT_EQ(URLRequestStatus::FAILED, request->status().status());
8444     EXPECT_EQ(ERR_SSL_FALLBACK_BEYOND_MINIMUM_VERSION,
8445               request->status().error());
8446   }
8447
8448   // Now allow TLSv1 fallback connections and request the session cache log.
8449   {
8450     TestDelegate delegate;
8451     FallbackTestURLRequestContext context(true);
8452     context.set_fallback_min_version(SSL_PROTOCOL_VERSION_TLS1);
8453
8454     context.Init();
8455     scoped_ptr<URLRequest> request(context.CreateRequest(
8456         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &delegate));
8457     request->Start();
8458
8459     base::RunLoop().Run();
8460
8461     EXPECT_EQ(1, delegate.response_started_count());
8462     EXPECT_NE(0, delegate.bytes_received());
8463     EXPECT_EQ(
8464         SSL_CONNECTION_VERSION_TLS1,
8465         SSLConnectionStatusToVersion(request->ssl_info().connection_status));
8466     EXPECT_TRUE(request->ssl_info().connection_status &
8467                 SSL_CONNECTION_VERSION_FALLBACK);
8468
8469     std::vector<std::string> lines;
8470     // If no sessions were cached then the server should have seen two sessions
8471     // inserted with no lookups.
8472     AssertTwoDistinctSessionsInserted(delegate.data_received());
8473   }
8474 }
8475
8476 class HTTPSSessionTest : public testing::Test {
8477  public:
8478   HTTPSSessionTest() : default_context_(true) {
8479     cert_verifier_.set_default_result(OK);
8480
8481     default_context_.set_network_delegate(&default_network_delegate_);
8482     default_context_.set_cert_verifier(&cert_verifier_);
8483     default_context_.Init();
8484   }
8485   ~HTTPSSessionTest() override {}
8486
8487  protected:
8488   MockCertVerifier cert_verifier_;
8489   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
8490   TestURLRequestContext default_context_;
8491 };
8492
8493 // Tests that session resumption is not attempted if an invalid certificate
8494 // is presented.
8495 TEST_F(HTTPSSessionTest, DontResumeSessionsForInvalidCertificates) {
8496   SpawnedTestServer::SSLOptions ssl_options;
8497   ssl_options.record_resume = true;
8498   SpawnedTestServer test_server(
8499       SpawnedTestServer::TYPE_HTTPS,
8500       ssl_options,
8501       base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
8502   ASSERT_TRUE(test_server.Start());
8503
8504   SSLClientSocket::ClearSessionCache();
8505
8506   // Simulate the certificate being expired and attempt a connection.
8507   cert_verifier_.set_default_result(ERR_CERT_DATE_INVALID);
8508   {
8509     TestDelegate d;
8510     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
8511         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d));
8512
8513     r->Start();
8514     EXPECT_TRUE(r->is_pending());
8515
8516     base::RunLoop().Run();
8517
8518     EXPECT_EQ(1, d.response_started_count());
8519   }
8520
8521   reinterpret_cast<HttpCache*>(default_context_.http_transaction_factory())->
8522     CloseAllConnections();
8523
8524   // Now change the certificate to be acceptable (so that the response is
8525   // loaded), and ensure that no session id is presented to the peer.
8526   cert_verifier_.set_default_result(OK);
8527   {
8528     TestDelegate d;
8529     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
8530         test_server.GetURL("ssl-session-cache"), DEFAULT_PRIORITY, &d));
8531
8532     r->Start();
8533     EXPECT_TRUE(r->is_pending());
8534
8535     base::RunLoop().Run();
8536
8537     // The response will look like;
8538     //   insert abc
8539     //   insert xyz
8540     //
8541     // With a newline at the end which makes the split think that there are
8542     // three lines.
8543     //
8544     // If a session was presented (eg: a bug), then the response would look
8545     // like;
8546     //   insert abc
8547     //   lookup abc
8548     //   insert xyz
8549
8550     EXPECT_EQ(1, d.response_started_count());
8551     AssertTwoDistinctSessionsInserted(d.data_received());
8552   }
8553 }
8554
8555 // This the fingerprint of the "Testing CA" certificate used by the testserver.
8556 // See net/data/ssl/certificates/ocsp-test-root.pem.
8557 static const SHA1HashValue kOCSPTestCertFingerprint =
8558   { { 0xf1, 0xad, 0xf6, 0xce, 0x42, 0xac, 0xe7, 0xb4, 0xf4, 0x24,
8559       0xdb, 0x1a, 0xf7, 0xa0, 0x9f, 0x09, 0xa1, 0xea, 0xf1, 0x5c } };
8560
8561 // This is the SHA256, SPKI hash of the "Testing CA" certificate used by the
8562 // testserver.
8563 static const SHA256HashValue kOCSPTestCertSPKI = { {
8564   0xee, 0xe6, 0x51, 0x2d, 0x4c, 0xfa, 0xf7, 0x3e,
8565   0x6c, 0xd8, 0xca, 0x67, 0xed, 0xb5, 0x5d, 0x49,
8566   0x76, 0xe1, 0x52, 0xa7, 0x6e, 0x0e, 0xa0, 0x74,
8567   0x09, 0x75, 0xe6, 0x23, 0x24, 0xbd, 0x1b, 0x28,
8568 } };
8569
8570 // This is the policy OID contained in the certificates that testserver
8571 // generates.
8572 static const char kOCSPTestCertPolicy[] = "1.3.6.1.4.1.11129.2.4.1";
8573
8574 class HTTPSOCSPTest : public HTTPSRequestTest {
8575  public:
8576   HTTPSOCSPTest()
8577       : context_(true),
8578         ev_test_policy_(
8579             new ScopedTestEVPolicy(EVRootCAMetadata::GetInstance(),
8580                                    kOCSPTestCertFingerprint,
8581                                    kOCSPTestCertPolicy)) {
8582   }
8583
8584   void SetUp() override {
8585     SetupContext(&context_);
8586     context_.Init();
8587
8588     scoped_refptr<X509Certificate> root_cert =
8589         ImportCertFromFile(GetTestCertsDirectory(), "ocsp-test-root.pem");
8590     CHECK_NE(static_cast<X509Certificate*>(NULL), root_cert.get());
8591     test_root_.reset(new ScopedTestRoot(root_cert.get()));
8592
8593 #if defined(USE_NSS_CERTS) || defined(OS_IOS)
8594     SetURLRequestContextForNSSHttpIO(&context_);
8595     EnsureNSSHttpIOInit();
8596 #endif
8597   }
8598
8599   void DoConnection(const SpawnedTestServer::SSLOptions& ssl_options,
8600                     CertStatus* out_cert_status) {
8601     // We always overwrite out_cert_status.
8602     *out_cert_status = 0;
8603     SpawnedTestServer test_server(
8604         SpawnedTestServer::TYPE_HTTPS,
8605         ssl_options,
8606         base::FilePath(FILE_PATH_LITERAL("net/data/ssl")));
8607     ASSERT_TRUE(test_server.Start());
8608
8609     TestDelegate d;
8610     d.set_allow_certificate_errors(true);
8611     scoped_ptr<URLRequest> r(context_.CreateRequest(
8612         test_server.GetURL(std::string()), DEFAULT_PRIORITY, &d));
8613     r->Start();
8614
8615     base::RunLoop().Run();
8616
8617     EXPECT_EQ(1, d.response_started_count());
8618     *out_cert_status = r->ssl_info().cert_status;
8619   }
8620
8621   ~HTTPSOCSPTest() override {
8622 #if defined(USE_NSS_CERTS) || defined(OS_IOS)
8623     ShutdownNSSHttpIO();
8624 #endif
8625   }
8626
8627  protected:
8628   // SetupContext configures the URLRequestContext that will be used for making
8629   // connetions to testserver. This can be overridden in test subclasses for
8630   // different behaviour.
8631   virtual void SetupContext(URLRequestContext* context) {
8632     context->set_ssl_config_service(
8633         new TestSSLConfigService(true /* check for EV */,
8634                                  true /* online revocation checking */,
8635                                  false /* require rev. checking for local
8636                                           anchors */));
8637   }
8638
8639   scoped_ptr<ScopedTestRoot> test_root_;
8640   TestURLRequestContext context_;
8641   scoped_ptr<ScopedTestEVPolicy> ev_test_policy_;
8642 };
8643
8644 static CertStatus ExpectedCertStatusForFailedOnlineRevocationCheck() {
8645 #if defined(OS_WIN)
8646   // Windows can return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION but we don't
8647   // have that ability on other platforms.
8648   return CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
8649 #else
8650   return 0;
8651 #endif
8652 }
8653
8654 // SystemSupportsHardFailRevocationChecking returns true iff the current
8655 // operating system supports revocation checking and can distinguish between
8656 // situations where a given certificate lacks any revocation information (eg:
8657 // no CRLDistributionPoints and no OCSP Responder AuthorityInfoAccess) and when
8658 // revocation information cannot be obtained (eg: the CRL was unreachable).
8659 // If it does not, then tests which rely on 'hard fail' behaviour should be
8660 // skipped.
8661 static bool SystemSupportsHardFailRevocationChecking() {
8662 #if defined(OS_WIN) || defined(USE_NSS_CERTS) || defined(OS_IOS)
8663   return true;
8664 #else
8665   return false;
8666 #endif
8667 }
8668
8669 // SystemUsesChromiumEVMetadata returns true iff the current operating system
8670 // uses Chromium's EV metadata (i.e. EVRootCAMetadata). If it does not, then
8671 // several tests are effected because our testing EV certificate won't be
8672 // recognised as EV.
8673 static bool SystemUsesChromiumEVMetadata() {
8674 #if defined(USE_OPENSSL_CERTS) && !defined(OS_ANDROID)
8675   // http://crbug.com/117478 - OpenSSL does not support EV validation.
8676   return false;
8677 #elif (defined(OS_MACOSX) && !defined(OS_IOS)) || defined(OS_ANDROID)
8678   // On OS X and Android, we use the system to tell us whether a certificate is
8679   // EV or not and the system won't recognise our testing root.
8680   return false;
8681 #else
8682   return true;
8683 #endif
8684 }
8685
8686 static bool SystemSupportsOCSP() {
8687 #if defined(USE_OPENSSL_CERTS)
8688   // http://crbug.com/117478 - OpenSSL does not support OCSP.
8689   return false;
8690 #elif defined(OS_WIN)
8691   return base::win::GetVersion() >= base::win::VERSION_VISTA;
8692 #elif defined(OS_ANDROID)
8693   // TODO(jnd): http://crbug.com/117478 - EV verification is not yet supported.
8694   return false;
8695 #else
8696   return true;
8697 #endif
8698 }
8699
8700 static bool SystemSupportsOCSPStapling() {
8701 #if defined(USE_NSS_CERTS) || defined(OS_IOS)
8702   return true;
8703 #elif defined(OS_WIN)
8704   return base::win::GetVersion() >= base::win::VERSION_VISTA;
8705 #else
8706   return false;
8707 #endif
8708 }
8709
8710 TEST_F(HTTPSOCSPTest, Valid) {
8711   if (!SystemSupportsOCSP()) {
8712     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8713     return;
8714   }
8715
8716   SpawnedTestServer::SSLOptions ssl_options(
8717       SpawnedTestServer::SSLOptions::CERT_AUTO);
8718   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK;
8719
8720   CertStatus cert_status;
8721   DoConnection(ssl_options, &cert_status);
8722
8723   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
8724
8725   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8726             static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
8727
8728   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
8729 }
8730
8731 TEST_F(HTTPSOCSPTest, Revoked) {
8732   if (!SystemSupportsOCSP()) {
8733     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8734     return;
8735   }
8736
8737   SpawnedTestServer::SSLOptions ssl_options(
8738       SpawnedTestServer::SSLOptions::CERT_AUTO);
8739   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED;
8740
8741   CertStatus cert_status;
8742   DoConnection(ssl_options, &cert_status);
8743
8744 #if !(defined(OS_MACOSX) && !defined(OS_IOS))
8745   // Doesn't pass on OS X yet for reasons that need to be investigated.
8746   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
8747 #endif
8748   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
8749   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
8750 }
8751
8752 TEST_F(HTTPSOCSPTest, Invalid) {
8753   if (!SystemSupportsOCSP()) {
8754     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8755     return;
8756   }
8757
8758   SpawnedTestServer::SSLOptions ssl_options(
8759       SpawnedTestServer::SSLOptions::CERT_AUTO);
8760   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
8761
8762   CertStatus cert_status;
8763   DoConnection(ssl_options, &cert_status);
8764
8765   EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
8766             cert_status & CERT_STATUS_ALL_ERRORS);
8767
8768   // Without a positive OCSP response, we shouldn't show the EV status.
8769   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
8770   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
8771 }
8772
8773 TEST_F(HTTPSOCSPTest, ValidStapled) {
8774   if (!SystemSupportsOCSPStapling()) {
8775     LOG(WARNING)
8776         << "Skipping test because system doesn't support OCSP stapling";
8777     return;
8778   }
8779
8780   SpawnedTestServer::SSLOptions ssl_options(
8781       SpawnedTestServer::SSLOptions::CERT_AUTO);
8782   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK;
8783   ssl_options.staple_ocsp_response = true;
8784   ssl_options.ocsp_server_unavailable = true;
8785
8786   CertStatus cert_status;
8787   DoConnection(ssl_options, &cert_status);
8788
8789   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
8790
8791   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8792             static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
8793
8794   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
8795 }
8796
8797 // Disabled on NSS ports. See https://crbug.com/431716.
8798 #if defined(USE_NSS_CERTS)
8799 #define MAYBE_RevokedStapled DISABLED_RevokedStapled
8800 #else
8801 #define MAYBE_RevokedStapled RevokedStapled
8802 #endif
8803 TEST_F(HTTPSOCSPTest, MAYBE_RevokedStapled) {
8804   if (!SystemSupportsOCSPStapling()) {
8805     LOG(WARNING)
8806         << "Skipping test because system doesn't support OCSP stapling";
8807     return;
8808   }
8809
8810   SpawnedTestServer::SSLOptions ssl_options(
8811       SpawnedTestServer::SSLOptions::CERT_AUTO);
8812   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED;
8813   ssl_options.staple_ocsp_response = true;
8814   ssl_options.ocsp_server_unavailable = true;
8815
8816   CertStatus cert_status;
8817   DoConnection(ssl_options, &cert_status);
8818
8819   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
8820   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
8821   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
8822 }
8823
8824 class HTTPSHardFailTest : public HTTPSOCSPTest {
8825  protected:
8826   void SetupContext(URLRequestContext* context) override {
8827     context->set_ssl_config_service(
8828         new TestSSLConfigService(false /* check for EV */,
8829                                  false /* online revocation checking */,
8830                                  true /* require rev. checking for local
8831                                          anchors */));
8832   }
8833 };
8834
8835 TEST_F(HTTPSHardFailTest, FailsOnOCSPInvalid) {
8836   if (!SystemSupportsOCSP()) {
8837     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8838     return;
8839   }
8840
8841   if (!SystemSupportsHardFailRevocationChecking()) {
8842     LOG(WARNING) << "Skipping test because system doesn't support hard fail "
8843                  << "revocation checking";
8844     return;
8845   }
8846
8847   SpawnedTestServer::SSLOptions ssl_options(
8848       SpawnedTestServer::SSLOptions::CERT_AUTO);
8849   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
8850
8851   CertStatus cert_status;
8852   DoConnection(ssl_options, &cert_status);
8853
8854   EXPECT_EQ(CERT_STATUS_REVOKED,
8855             cert_status & CERT_STATUS_REVOKED);
8856
8857   // Without a positive OCSP response, we shouldn't show the EV status.
8858   EXPECT_TRUE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
8859 }
8860
8861 class HTTPSEVCRLSetTest : public HTTPSOCSPTest {
8862  protected:
8863   void SetupContext(URLRequestContext* context) override {
8864     context->set_ssl_config_service(
8865         new TestSSLConfigService(true /* check for EV */,
8866                                  false /* online revocation checking */,
8867                                  false /* require rev. checking for local
8868                                           anchors */));
8869   }
8870 };
8871
8872 TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndInvalidOCSP) {
8873   if (!SystemSupportsOCSP()) {
8874     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8875     return;
8876   }
8877
8878   SpawnedTestServer::SSLOptions ssl_options(
8879       SpawnedTestServer::SSLOptions::CERT_AUTO);
8880   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
8881   SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>());
8882
8883   CertStatus cert_status;
8884   DoConnection(ssl_options, &cert_status);
8885
8886   EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
8887             cert_status & CERT_STATUS_ALL_ERRORS);
8888
8889   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
8890   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8891             static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
8892 }
8893
8894 TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndRevokedOCSP) {
8895   if (!SystemSupportsOCSP()) {
8896     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8897     return;
8898   }
8899
8900   SpawnedTestServer::SSLOptions ssl_options(
8901       SpawnedTestServer::SSLOptions::CERT_AUTO);
8902   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED;
8903   SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>());
8904
8905   CertStatus cert_status;
8906   DoConnection(ssl_options, &cert_status);
8907
8908   // Currently only works for Windows. When using NSS or OS X, it's not
8909   // possible to determine whether the check failed because of actual
8910   // revocation or because there was an OCSP failure.
8911 #if defined(OS_WIN)
8912   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
8913 #else
8914   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
8915 #endif
8916
8917   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
8918   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8919             static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
8920 }
8921
8922 TEST_F(HTTPSEVCRLSetTest, MissingCRLSetAndGoodOCSP) {
8923   if (!SystemSupportsOCSP()) {
8924     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8925     return;
8926   }
8927
8928   SpawnedTestServer::SSLOptions ssl_options(
8929       SpawnedTestServer::SSLOptions::CERT_AUTO);
8930   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK;
8931   SSLConfigService::SetCRLSet(scoped_refptr<CRLSet>());
8932
8933   CertStatus cert_status;
8934   DoConnection(ssl_options, &cert_status);
8935
8936   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
8937
8938   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8939             static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
8940   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8941             static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
8942 }
8943
8944 TEST_F(HTTPSEVCRLSetTest, ExpiredCRLSet) {
8945   if (!SystemSupportsOCSP()) {
8946     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8947     return;
8948   }
8949
8950   SpawnedTestServer::SSLOptions ssl_options(
8951       SpawnedTestServer::SSLOptions::CERT_AUTO);
8952   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
8953   SSLConfigService::SetCRLSet(
8954       scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting()));
8955
8956   CertStatus cert_status;
8957   DoConnection(ssl_options, &cert_status);
8958
8959   EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
8960             cert_status & CERT_STATUS_ALL_ERRORS);
8961
8962   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
8963   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8964             static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
8965 }
8966
8967 TEST_F(HTTPSEVCRLSetTest, FreshCRLSetCovered) {
8968   if (!SystemSupportsOCSP()) {
8969     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8970     return;
8971   }
8972
8973   SpawnedTestServer::SSLOptions ssl_options(
8974       SpawnedTestServer::SSLOptions::CERT_AUTO);
8975   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
8976   SSLConfigService::SetCRLSet(
8977       scoped_refptr<CRLSet>(CRLSet::ForTesting(
8978           false, &kOCSPTestCertSPKI, "")));
8979
8980   CertStatus cert_status;
8981   DoConnection(ssl_options, &cert_status);
8982
8983   // With a fresh CRLSet that covers the issuing certificate, we shouldn't do a
8984   // revocation check for EV.
8985   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
8986   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
8987             static_cast<bool>(cert_status & CERT_STATUS_IS_EV));
8988   EXPECT_FALSE(
8989       static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
8990 }
8991
8992 TEST_F(HTTPSEVCRLSetTest, FreshCRLSetNotCovered) {
8993   if (!SystemSupportsOCSP()) {
8994     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
8995     return;
8996   }
8997
8998   SpawnedTestServer::SSLOptions ssl_options(
8999       SpawnedTestServer::SSLOptions::CERT_AUTO);
9000   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
9001   SSLConfigService::SetCRLSet(
9002       scoped_refptr<CRLSet>(CRLSet::EmptyCRLSetForTesting()));
9003
9004   CertStatus cert_status = 0;
9005   DoConnection(ssl_options, &cert_status);
9006
9007   // Even with a fresh CRLSet, we should still do online revocation checks when
9008   // the certificate chain isn't covered by the CRLSet, which it isn't in this
9009   // test.
9010   EXPECT_EQ(ExpectedCertStatusForFailedOnlineRevocationCheck(),
9011             cert_status & CERT_STATUS_ALL_ERRORS);
9012
9013   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
9014   EXPECT_EQ(SystemUsesChromiumEVMetadata(),
9015             static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
9016 }
9017
9018 TEST_F(HTTPSEVCRLSetTest, ExpiredCRLSetAndRevokedNonEVCert) {
9019   // Test that when EV verification is requested, but online revocation
9020   // checking is disabled, and the leaf certificate is not in fact EV, that
9021   // no revocation checking actually happens.
9022   if (!SystemSupportsOCSP()) {
9023     LOG(WARNING) << "Skipping test because system doesn't support OCSP";
9024     return;
9025   }
9026
9027   // Unmark the certificate's OID as EV, which should disable revocation
9028   // checking (as per the user preference)
9029   ev_test_policy_.reset();
9030
9031   SpawnedTestServer::SSLOptions ssl_options(
9032       SpawnedTestServer::SSLOptions::CERT_AUTO);
9033   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_REVOKED;
9034   SSLConfigService::SetCRLSet(
9035       scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting()));
9036
9037   CertStatus cert_status;
9038   DoConnection(ssl_options, &cert_status);
9039
9040   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
9041
9042   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
9043   EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
9044 }
9045
9046 class HTTPSCRLSetTest : public HTTPSOCSPTest {
9047  protected:
9048   void SetupContext(URLRequestContext* context) override {
9049     context->set_ssl_config_service(
9050         new TestSSLConfigService(false /* check for EV */,
9051                                  false /* online revocation checking */,
9052                                  false /* require rev. checking for local
9053                                           anchors */));
9054   }
9055 };
9056
9057 TEST_F(HTTPSCRLSetTest, ExpiredCRLSet) {
9058   SpawnedTestServer::SSLOptions ssl_options(
9059       SpawnedTestServer::SSLOptions::CERT_AUTO);
9060   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_INVALID;
9061   SSLConfigService::SetCRLSet(
9062       scoped_refptr<CRLSet>(CRLSet::ExpiredCRLSetForTesting()));
9063
9064   CertStatus cert_status;
9065   DoConnection(ssl_options, &cert_status);
9066
9067   // If we're not trying EV verification then, even if the CRLSet has expired,
9068   // we don't fall back to online revocation checks.
9069   EXPECT_EQ(0u, cert_status & CERT_STATUS_ALL_ERRORS);
9070   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
9071   EXPECT_FALSE(cert_status & CERT_STATUS_REV_CHECKING_ENABLED);
9072 }
9073
9074 TEST_F(HTTPSCRLSetTest, CRLSetRevoked) {
9075 #if defined(OS_ANDROID)
9076   LOG(WARNING) << "Skipping test because system doesn't support CRLSets";
9077   return;
9078 #endif
9079
9080   SpawnedTestServer::SSLOptions ssl_options(
9081       SpawnedTestServer::SSLOptions::CERT_AUTO);
9082   ssl_options.ocsp_status = SpawnedTestServer::SSLOptions::OCSP_OK;
9083   ssl_options.cert_serial = 10;
9084   SSLConfigService::SetCRLSet(
9085       scoped_refptr<CRLSet>(CRLSet::ForTesting(
9086           false, &kOCSPTestCertSPKI, "\x0a")));
9087
9088   CertStatus cert_status = 0;
9089   DoConnection(ssl_options, &cert_status);
9090
9091   // If the certificate is recorded as revoked in the CRLSet, that should be
9092   // reflected without online revocation checking.
9093   EXPECT_EQ(CERT_STATUS_REVOKED, cert_status & CERT_STATUS_ALL_ERRORS);
9094   EXPECT_FALSE(cert_status & CERT_STATUS_IS_EV);
9095   EXPECT_FALSE(
9096       static_cast<bool>(cert_status & CERT_STATUS_REV_CHECKING_ENABLED));
9097 }
9098 #endif  // !defined(OS_IOS)
9099
9100 #if !defined(DISABLE_FTP_SUPPORT) && !defined(OS_ANDROID)
9101 // These tests aren't passing on Android.  Either the RemoteTestServer isn't
9102 // starting up successfully, or it can't access the test files.
9103 // TODO(mmenke):  Fix this.  See http://crbug.com/495220
9104 class URLRequestTestFTP : public URLRequestTest {
9105  public:
9106   URLRequestTestFTP()
9107       : ftp_transaction_factory_(&host_resolver_),
9108         test_server_(SpawnedTestServer::TYPE_FTP,
9109                      SpawnedTestServer::kLocalhost,
9110                      base::FilePath(kTestFilePath)) {
9111     // Can't use |default_context_|'s HostResolver to set up the
9112     // FTPTransactionFactory because it hasn't been created yet.
9113     default_context_.set_host_resolver(&host_resolver_);
9114   }
9115
9116   // URLRequestTest interface:
9117   void SetUpFactory() override {
9118     // Add FTP support to the default URLRequestContext.
9119     job_factory_impl_->SetProtocolHandler(
9120         "ftp",
9121         make_scoped_ptr(new FtpProtocolHandler(&ftp_transaction_factory_)));
9122   }
9123
9124   std::string GetTestFileContents() {
9125     base::FilePath path;
9126     EXPECT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &path));
9127     path = path.Append(kTestFilePath);
9128     path = path.AppendASCII(kFtpTestFile);
9129     std::string contents;
9130     EXPECT_TRUE(base::ReadFileToString(path, &contents));
9131     return contents;
9132   }
9133
9134  protected:
9135   MockHostResolver host_resolver_;
9136   FtpNetworkLayer ftp_transaction_factory_;
9137
9138   SpawnedTestServer test_server_;
9139 };
9140
9141 // Make sure an FTP request using an unsafe ports fails.
9142 TEST_F(URLRequestTestFTP, UnsafePort) {
9143   GURL url("ftp://127.0.0.1:7");
9144
9145   TestDelegate d;
9146   {
9147     scoped_ptr<URLRequest> r(
9148         default_context_.CreateRequest(url, DEFAULT_PRIORITY, &d));
9149     r->Start();
9150     EXPECT_TRUE(r->is_pending());
9151
9152     base::RunLoop().Run();
9153
9154     EXPECT_FALSE(r->is_pending());
9155     EXPECT_EQ(URLRequestStatus::FAILED, r->status().status());
9156     EXPECT_EQ(ERR_UNSAFE_PORT, r->status().error());
9157   }
9158 }
9159
9160 TEST_F(URLRequestTestFTP, FTPDirectoryListing) {
9161   ASSERT_TRUE(test_server_.Start());
9162
9163   TestDelegate d;
9164   {
9165     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9166         test_server_.GetURL("/"), DEFAULT_PRIORITY, &d));
9167     r->Start();
9168     EXPECT_TRUE(r->is_pending());
9169
9170     base::RunLoop().Run();
9171
9172     EXPECT_FALSE(r->is_pending());
9173     EXPECT_EQ(1, d.response_started_count());
9174     EXPECT_FALSE(d.received_data_before_response());
9175     EXPECT_LT(0, d.bytes_received());
9176     EXPECT_EQ(test_server_.host_port_pair().host(),
9177               r->GetSocketAddress().host());
9178     EXPECT_EQ(test_server_.host_port_pair().port(),
9179               r->GetSocketAddress().port());
9180   }
9181 }
9182
9183 TEST_F(URLRequestTestFTP, FTPGetTestAnonymous) {
9184   ASSERT_TRUE(test_server_.Start());
9185
9186   TestDelegate d;
9187   {
9188     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9189         test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, &d));
9190     r->Start();
9191     EXPECT_TRUE(r->is_pending());
9192
9193     base::RunLoop().Run();
9194
9195     EXPECT_FALSE(r->is_pending());
9196     EXPECT_EQ(1, d.response_started_count());
9197     EXPECT_FALSE(d.received_data_before_response());
9198     EXPECT_EQ(GetTestFileContents(), d.data_received());
9199     EXPECT_EQ(test_server_.host_port_pair().host(),
9200               r->GetSocketAddress().host());
9201     EXPECT_EQ(test_server_.host_port_pair().port(),
9202               r->GetSocketAddress().port());
9203   }
9204 }
9205
9206 TEST_F(URLRequestTestFTP, FTPGetTest) {
9207   ASSERT_TRUE(test_server_.Start());
9208
9209   TestDelegate d;
9210   {
9211     scoped_ptr<URLRequest> r(
9212         default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
9213                                            kFtpTestFile, "chrome", "chrome"),
9214                                        DEFAULT_PRIORITY, &d));
9215     r->Start();
9216     EXPECT_TRUE(r->is_pending());
9217
9218     base::RunLoop().Run();
9219
9220     EXPECT_FALSE(r->is_pending());
9221     EXPECT_EQ(1, d.response_started_count());
9222     EXPECT_FALSE(d.received_data_before_response());
9223     EXPECT_EQ(GetTestFileContents(), d.data_received());
9224     EXPECT_EQ(test_server_.host_port_pair().host(),
9225               r->GetSocketAddress().host());
9226     EXPECT_EQ(test_server_.host_port_pair().port(),
9227               r->GetSocketAddress().port());
9228
9229     LoadTimingInfo load_timing_info;
9230     r->GetLoadTimingInfo(&load_timing_info);
9231     TestLoadTimingNoHttpResponse(load_timing_info);
9232   }
9233 }
9234
9235 TEST_F(URLRequestTestFTP, FTPCheckWrongPassword) {
9236   ASSERT_TRUE(test_server_.Start());
9237
9238   TestDelegate d;
9239   {
9240     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9241         test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
9242                                                "wrong_password"),
9243         DEFAULT_PRIORITY, &d));
9244     r->Start();
9245     EXPECT_TRUE(r->is_pending());
9246
9247     base::RunLoop().Run();
9248
9249     EXPECT_FALSE(r->is_pending());
9250     EXPECT_EQ(1, d.response_started_count());
9251     EXPECT_FALSE(d.received_data_before_response());
9252     EXPECT_EQ(d.bytes_received(), 0);
9253   }
9254 }
9255
9256 TEST_F(URLRequestTestFTP, FTPCheckWrongPasswordRestart) {
9257   ASSERT_TRUE(test_server_.Start());
9258
9259   TestDelegate d;
9260   // Set correct login credentials. The delegate will be asked for them when
9261   // the initial login with wrong credentials will fail.
9262   d.set_credentials(AuthCredentials(kChrome, kChrome));
9263   {
9264     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9265         test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
9266                                                "wrong_password"),
9267         DEFAULT_PRIORITY, &d));
9268     r->Start();
9269     EXPECT_TRUE(r->is_pending());
9270
9271     base::RunLoop().Run();
9272
9273     EXPECT_FALSE(r->is_pending());
9274     EXPECT_EQ(1, d.response_started_count());
9275     EXPECT_FALSE(d.received_data_before_response());
9276     EXPECT_EQ(GetTestFileContents(), d.data_received());
9277   }
9278 }
9279
9280 TEST_F(URLRequestTestFTP, FTPCheckWrongUser) {
9281   ASSERT_TRUE(test_server_.Start());
9282
9283   TestDelegate d;
9284   {
9285     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9286         test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
9287                                                "chrome"),
9288         DEFAULT_PRIORITY, &d));
9289     r->Start();
9290     EXPECT_TRUE(r->is_pending());
9291
9292     base::RunLoop().Run();
9293
9294     EXPECT_FALSE(r->is_pending());
9295     EXPECT_EQ(1, d.response_started_count());
9296     EXPECT_FALSE(d.received_data_before_response());
9297     EXPECT_EQ(0, d.bytes_received());
9298   }
9299 }
9300
9301 TEST_F(URLRequestTestFTP, FTPCheckWrongUserRestart) {
9302   ASSERT_TRUE(test_server_.Start());
9303
9304   TestDelegate d;
9305   // Set correct login credentials. The delegate will be asked for them when
9306   // the initial login with wrong credentials will fail.
9307   d.set_credentials(AuthCredentials(kChrome, kChrome));
9308   {
9309     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9310         test_server_.GetURLWithUserAndPassword(kFtpTestFile, "wrong_user",
9311                                                "chrome"),
9312         DEFAULT_PRIORITY, &d));
9313     r->Start();
9314     EXPECT_TRUE(r->is_pending());
9315
9316     base::RunLoop().Run();
9317
9318     EXPECT_FALSE(r->is_pending());
9319     EXPECT_EQ(1, d.response_started_count());
9320     EXPECT_FALSE(d.received_data_before_response());
9321     EXPECT_EQ(GetTestFileContents(), d.data_received());
9322   }
9323 }
9324
9325 TEST_F(URLRequestTestFTP, FTPCacheURLCredentials) {
9326   ASSERT_TRUE(test_server_.Start());
9327
9328   scoped_ptr<TestDelegate> d(new TestDelegate);
9329   {
9330     // Pass correct login identity in the URL.
9331     scoped_ptr<URLRequest> r(
9332         default_context_.CreateRequest(test_server_.GetURLWithUserAndPassword(
9333                                            kFtpTestFile, "chrome", "chrome"),
9334                                        DEFAULT_PRIORITY, d.get()));
9335     r->Start();
9336     EXPECT_TRUE(r->is_pending());
9337
9338     base::RunLoop().Run();
9339
9340     EXPECT_FALSE(r->is_pending());
9341     EXPECT_EQ(1, d->response_started_count());
9342     EXPECT_FALSE(d->received_data_before_response());
9343     EXPECT_EQ(GetTestFileContents(), d->data_received());
9344   }
9345
9346   d.reset(new TestDelegate);
9347   {
9348     // This request should use cached identity from previous request.
9349     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9350         test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
9351     r->Start();
9352     EXPECT_TRUE(r->is_pending());
9353
9354     base::RunLoop().Run();
9355
9356     EXPECT_FALSE(r->is_pending());
9357     EXPECT_EQ(1, d->response_started_count());
9358     EXPECT_FALSE(d->received_data_before_response());
9359     EXPECT_EQ(GetTestFileContents(), d->data_received());
9360   }
9361 }
9362
9363 TEST_F(URLRequestTestFTP, FTPCacheLoginBoxCredentials) {
9364   ASSERT_TRUE(test_server_.Start());
9365
9366   scoped_ptr<TestDelegate> d(new TestDelegate);
9367   // Set correct login credentials. The delegate will be asked for them when
9368   // the initial login with wrong credentials will fail.
9369   d->set_credentials(AuthCredentials(kChrome, kChrome));
9370   {
9371     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9372         test_server_.GetURLWithUserAndPassword(kFtpTestFile, "chrome",
9373                                                "wrong_password"),
9374         DEFAULT_PRIORITY, d.get()));
9375     r->Start();
9376     EXPECT_TRUE(r->is_pending());
9377
9378     base::RunLoop().Run();
9379
9380     EXPECT_FALSE(r->is_pending());
9381     EXPECT_EQ(1, d->response_started_count());
9382     EXPECT_FALSE(d->received_data_before_response());
9383     EXPECT_EQ(GetTestFileContents(), d->data_received());
9384   }
9385
9386   // Use a new delegate without explicit credentials. The cached ones should be
9387   // used.
9388   d.reset(new TestDelegate);
9389   {
9390     // Don't pass wrong credentials in the URL, they would override valid cached
9391     // ones.
9392     scoped_ptr<URLRequest> r(default_context_.CreateRequest(
9393         test_server_.GetURL(kFtpTestFile), DEFAULT_PRIORITY, d.get()));
9394     r->Start();
9395     EXPECT_TRUE(r->is_pending());
9396
9397     base::RunLoop().Run();
9398
9399     EXPECT_FALSE(r->is_pending());
9400     EXPECT_EQ(1, d->response_started_count());
9401     EXPECT_FALSE(d->received_data_before_response());
9402     EXPECT_EQ(GetTestFileContents(), d->data_received());
9403   }
9404 }
9405 #endif  // !defined(DISABLE_FTP_SUPPORT)
9406
9407 TEST_F(URLRequestTest, NetworkAccessedClearBeforeNetworkStart) {
9408   TestDelegate d;
9409   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
9410       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
9411   d.set_quit_on_network_start(true);
9412
9413   EXPECT_FALSE(req->response_info().network_accessed);
9414
9415   req->Start();
9416   base::RunLoop().Run();
9417
9418   EXPECT_EQ(1, d.received_before_network_start_count());
9419   EXPECT_EQ(0, d.response_started_count());
9420   EXPECT_FALSE(req->response_info().network_accessed);
9421
9422   req->ResumeNetworkStart();
9423   base::RunLoop().Run();
9424 }
9425
9426 TEST_F(URLRequestTest, NetworkAccessedClearOnDataRequest) {
9427   TestDelegate d;
9428   scoped_ptr<URLRequest> req(
9429       default_context_.CreateRequest(GURL("data:,"), DEFAULT_PRIORITY, &d));
9430
9431   EXPECT_FALSE(req->response_info().network_accessed);
9432
9433   req->Start();
9434   base::RunLoop().Run();
9435
9436   EXPECT_EQ(1, default_network_delegate_.completed_requests());
9437   EXPECT_FALSE(req->response_info().network_accessed);
9438 }
9439
9440 TEST_F(URLRequestTest, NetworkAccessedSetOnHostResolutionFailure) {
9441   MockHostResolver host_resolver;
9442   TestNetworkDelegate network_delegate;  // Must outlive URLRequest.
9443   TestURLRequestContext context(true);
9444   context.set_network_delegate(&network_delegate);
9445   context.set_host_resolver(&host_resolver);
9446   host_resolver.rules()->AddSimulatedFailure("*");
9447   context.Init();
9448
9449   TestDelegate d;
9450   scoped_ptr<URLRequest> req(context.CreateRequest(
9451       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
9452
9453   EXPECT_FALSE(req->response_info().network_accessed);
9454
9455   req->Start();
9456   base::RunLoop().Run();
9457   EXPECT_TRUE(req->response_info().network_accessed);
9458 }
9459
9460 // Test that URLRequest is canceled correctly and with detached request
9461 // URLRequestRedirectJob does not crash in StartAsync.
9462 // See http://crbug.com/508900
9463 TEST_F(URLRequestTest, URLRequestRedirectJobDetachRequestNoCrash) {
9464   TestDelegate d;
9465   scoped_ptr<URLRequest> req(default_context_.CreateRequest(
9466       GURL("http://not-a-real-domain/"), DEFAULT_PRIORITY, &d));
9467
9468   URLRequestRedirectJob* job = new URLRequestRedirectJob(
9469       req.get(), &default_network_delegate_,
9470       GURL("http://this-should-never-be-navigated-to/"),
9471       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "Jumbo shrimp");
9472   AddTestInterceptor()->set_main_intercept_job(job);
9473
9474   req->Start();
9475   req->Cancel();
9476   job->DetachRequest();
9477   base::RunLoop().RunUntilIdle();
9478   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
9479   EXPECT_EQ(0, d.received_redirect_count());
9480 }
9481
9482 }  // namespace net