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