net/url_request/url_request_test_util.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/url_request/url_request_test_util.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/location.h"
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/single_thread_task_runner.h"
  12 #include "base/thread_task_runner_handle.h"
  13 #include "base/threading/thread.h"
  14 #include "base/threading/worker_pool.h"
  15 #include "net/base/host_port_pair.h"
  16 #include "net/cert/cert_verifier.h"
  17 #include "net/dns/mock_host_resolver.h"
  18 #include "net/http/http_network_session.h"
  19 #include "net/http/http_response_headers.h"
  20 #include "net/http/http_server_properties_impl.h"
  21 #include "net/http/transport_security_state.h"
  22 #include "net/ssl/channel_id_service.h"
  23 #include "net/ssl/default_channel_id_store.h"
  24 #include "net/url_request/static_http_user_agent_settings.h"
  25 #include "net/url_request/url_request_job_factory_impl.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 namespace net {
  29
  30 namespace {
  31
  32 // These constants put the NetworkDelegate events of TestNetworkDelegate
  33 // into an order. They are used in conjunction with
  34 // |TestNetworkDelegate::next_states_| to check that we do not send
  35 // events in the wrong order.
  36 const int kStageBeforeURLRequest = 1 << 0;
  37 const int kStageBeforeSendHeaders = 1 << 1;
  38 const int kStageSendHeaders = 1 << 2;
  39 const int kStageHeadersReceived = 1 << 3;
  40 const int kStageAuthRequired = 1 << 4;
  41 const int kStageBeforeRedirect = 1 << 5;
  42 const int kStageResponseStarted = 1 << 6;
  43 const int kStageCompletedSuccess = 1 << 7;
  44 const int kStageCompletedError = 1 << 8;
  45 const int kStageURLRequestDestroyed = 1 << 9;
  46 const int kStageDestruction = 1 << 10;
  47
  48 }  // namespace
  49
  50 TestURLRequestContext::TestURLRequestContext()
  51     : initialized_(false),
  52       client_socket_factory_(NULL),
  53       context_storage_(this) {
  54   Init();
  55 }
  56
  57 TestURLRequestContext::TestURLRequestContext(bool delay_initialization)
  58     : initialized_(false),
  59       client_socket_factory_(NULL),
  60       context_storage_(this) {
  61   if (!delay_initialization)
  62     Init();
  63 }
  64
  65 TestURLRequestContext::~TestURLRequestContext() {
  66   DCHECK(initialized_);
  67   AssertNoURLRequests();
  68 }
  69
  70 void TestURLRequestContext::Init() {
  71   DCHECK(!initialized_);
  72   initialized_ = true;
  73
  74   if (!host_resolver())
  75     context_storage_.set_host_resolver(
  76         scoped_ptr<HostResolver>(new MockCachingHostResolver()));
  77   if (!proxy_service())
  78     context_storage_.set_proxy_service(ProxyService::CreateDirect());
  79   if (!cert_verifier())
  80     context_storage_.set_cert_verifier(CertVerifier::CreateDefault());
  81   if (!transport_security_state())
  82     context_storage_.set_transport_security_state(
  83         make_scoped_ptr(new TransportSecurityState()));
  84   if (!ssl_config_service())
  85     context_storage_.set_ssl_config_service(new SSLConfigServiceDefaults());
  86   if (!http_auth_handler_factory()) {
  87     context_storage_.set_http_auth_handler_factory(
  88         HttpAuthHandlerFactory::CreateDefault(host_resolver()));
  89   }
  90   if (!http_server_properties()) {
  91     context_storage_.set_http_server_properties(
  92         scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl()));
  93   }
  94   if (http_transaction_factory()) {
  95     // Make sure we haven't been passed an object we're not going to use.
  96     EXPECT_FALSE(client_socket_factory_);
  97   } else {
  98     HttpNetworkSession::Params params;
  99     if (http_network_session_params_)
 100       params = *http_network_session_params_;
 101     params.client_socket_factory = client_socket_factory();
 102     params.host_resolver = host_resolver();
 103     params.cert_verifier = cert_verifier();
 104     params.transport_security_state = transport_security_state();
 105     params.proxy_service = proxy_service();
 106     params.ssl_config_service = ssl_config_service();
 107     params.http_auth_handler_factory = http_auth_handler_factory();
 108     params.network_delegate = network_delegate();
 109     params.http_server_properties = http_server_properties();
 110     params.net_log = net_log();
 111     context_storage_.set_http_transaction_factory(
 112         make_scoped_ptr(new HttpCache(new HttpNetworkSession(params),
 113                                       HttpCache::DefaultBackend::InMemory(0)))
 114             .Pass());
 115   }
 116   // In-memory cookie store.
 117   if (!cookie_store())
 118     context_storage_.set_cookie_store(new CookieMonster(NULL, NULL));
 119   // In-memory Channel ID service.
 120   if (!channel_id_service()) {
 121     context_storage_.set_channel_id_service(make_scoped_ptr(
 122         new ChannelIDService(new DefaultChannelIDStore(NULL),
 123                              base::WorkerPool::GetTaskRunner(true))));
 124   }
 125   if (!http_user_agent_settings()) {
 126     context_storage_.set_http_user_agent_settings(
 127         make_scoped_ptr(
 128             new StaticHttpUserAgentSettings("en-us,fr", std::string()))
 129             .Pass());
 130   }
 131   if (!job_factory()) {
 132     context_storage_.set_job_factory(
 133         make_scoped_ptr(new URLRequestJobFactoryImpl()).Pass());
 134   }
 135 }
 136
 137 TestURLRequestContextGetter::TestURLRequestContextGetter(
 138     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner)
 139     : network_task_runner_(network_task_runner) {
 140   DCHECK(network_task_runner_.get());
 141 }
 142
 143 TestURLRequestContextGetter::TestURLRequestContextGetter(
 144     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
 145     scoped_ptr<TestURLRequestContext> context)
 146     : network_task_runner_(network_task_runner), context_(context.Pass()) {
 147   DCHECK(network_task_runner_.get());
 148 }
 149
 150 TestURLRequestContextGetter::~TestURLRequestContextGetter() {}
 151
 152 TestURLRequestContext* TestURLRequestContextGetter::GetURLRequestContext() {
 153   if (!context_.get())
 154     context_.reset(new TestURLRequestContext);
 155   return context_.get();
 156 }
 157
 158 scoped_refptr<base::SingleThreadTaskRunner>
 159 TestURLRequestContextGetter::GetNetworkTaskRunner() const {
 160   return network_task_runner_;
 161 }
 162
 163 TestDelegate::TestDelegate()
 164     : cancel_in_rr_(false),
 165       cancel_in_rs_(false),
 166       cancel_in_rd_(false),
 167       cancel_in_rd_pending_(false),
 168       quit_on_complete_(true),
 169       quit_on_redirect_(false),
 170       quit_on_auth_required_(false),
 171       quit_on_before_network_start_(false),
 172       allow_certificate_errors_(false),
 173       response_started_count_(0),
 174       received_bytes_count_(0),
 175       received_redirect_count_(0),
 176       received_before_network_start_count_(0),
 177       received_data_before_response_(false),
 178       request_failed_(false),
 179       have_certificate_errors_(false),
 180       certificate_errors_are_fatal_(false),
 181       auth_required_(false),
 182       have_full_request_headers_(false),
 183       buf_(new IOBuffer(kBufferSize)) {
 184 }
 185
 186 TestDelegate::~TestDelegate() {}
 187
 188 void TestDelegate::ClearFullRequestHeaders() {
 189   full_request_headers_.Clear();
 190   have_full_request_headers_ = false;
 191 }
 192
 193 void TestDelegate::OnReceivedRedirect(URLRequest* request,
 194                                       const RedirectInfo& redirect_info,
 195                                       bool* defer_redirect) {
 196   EXPECT_TRUE(request->is_redirecting());
 197
 198   have_full_request_headers_ =
 199       request->GetFullRequestHeaders(&full_request_headers_);
 200
 201   received_redirect_count_++;
 202   if (quit_on_redirect_) {
 203     *defer_redirect = true;
 204     base::ThreadTaskRunnerHandle::Get()->PostTask(
 205         FROM_HERE, base::MessageLoop::QuitClosure());
 206   } else if (cancel_in_rr_) {
 207     request->Cancel();
 208   }
 209 }
 210
 211 void TestDelegate::OnBeforeNetworkStart(URLRequest* request, bool* defer) {
 212   received_before_network_start_count_++;
 213   if (quit_on_before_network_start_) {
 214     *defer = true;
 215     base::ThreadTaskRunnerHandle::Get()->PostTask(
 216         FROM_HERE, base::MessageLoop::QuitClosure());
 217   }
 218 }
 219
 220 void TestDelegate::OnAuthRequired(URLRequest* request,
 221                                   AuthChallengeInfo* auth_info) {
 222   auth_required_ = true;
 223   if (quit_on_auth_required_) {
 224     base::ThreadTaskRunnerHandle::Get()->PostTask(
 225         FROM_HERE, base::MessageLoop::QuitClosure());
 226     return;
 227   }
 228   if (!credentials_.Empty()) {
 229     request->SetAuth(credentials_);
 230   } else {
 231     request->CancelAuth();
 232   }
 233 }
 234
 235 void TestDelegate::OnSSLCertificateError(URLRequest* request,
 236                                          const SSLInfo& ssl_info,
 237                                          bool fatal) {
 238   // The caller can control whether it needs all SSL requests to go through,
 239   // independent of any possible errors, or whether it wants SSL errors to
 240   // cancel the request.
 241   have_certificate_errors_ = true;
 242   certificate_errors_are_fatal_ = fatal;
 243   if (allow_certificate_errors_)
 244     request->ContinueDespiteLastError();
 245   else
 246     request->Cancel();
 247 }
 248
 249 void TestDelegate::OnResponseStarted(URLRequest* request) {
 250   // It doesn't make sense for the request to have IO pending at this point.
 251   DCHECK(!request->status().is_io_pending());
 252   EXPECT_FALSE(request->is_redirecting());
 253
 254   have_full_request_headers_ =
 255       request->GetFullRequestHeaders(&full_request_headers_);
 256
 257   response_started_count_++;
 258   if (cancel_in_rs_) {
 259     request->Cancel();
 260     OnResponseCompleted(request);
 261   } else if (!request->status().is_success()) {
 262     DCHECK(request->status().status() == URLRequestStatus::FAILED ||
 263            request->status().status() == URLRequestStatus::CANCELED);
 264     request_failed_ = true;
 265     OnResponseCompleted(request);
 266   } else {
 267     // Initiate the first read.
 268     int bytes_read = 0;
 269     if (request->Read(buf_.get(), kBufferSize, &bytes_read))
 270       OnReadCompleted(request, bytes_read);
 271     else if (!request->status().is_io_pending())
 272       OnResponseCompleted(request);
 273   }
 274 }
 275
 276 void TestDelegate::OnReadCompleted(URLRequest* request, int bytes_read) {
 277   // It doesn't make sense for the request to have IO pending at this point.
 278   DCHECK(!request->status().is_io_pending());
 279
 280   if (response_started_count_ == 0)
 281     received_data_before_response_ = true;
 282
 283   if (cancel_in_rd_)
 284     request->Cancel();
 285
 286   if (bytes_read >= 0) {
 287     // There is data to read.
 288     received_bytes_count_ += bytes_read;
 289
 290     // consume the data
 291     data_received_.append(buf_->data(), bytes_read);
 292   }
 293
 294   // If it was not end of stream, request to read more.
 295   if (request->status().is_success() && bytes_read > 0) {
 296     bytes_read = 0;
 297     while (request->Read(buf_.get(), kBufferSize, &bytes_read)) {
 298       if (bytes_read > 0) {
 299         data_received_.append(buf_->data(), bytes_read);
 300         received_bytes_count_ += bytes_read;
 301       } else {
 302         break;
 303       }
 304     }
 305   }
 306   if (!request->status().is_io_pending())
 307     OnResponseCompleted(request);
 308   else if (cancel_in_rd_pending_)
 309     request->Cancel();
 310 }
 311
 312 void TestDelegate::OnResponseCompleted(URLRequest* request) {
 313   if (quit_on_complete_)
 314     base::ThreadTaskRunnerHandle::Get()->PostTask(
 315         FROM_HERE, base::MessageLoop::QuitClosure());
 316 }
 317
 318 TestNetworkDelegate::TestNetworkDelegate()
 319     : last_error_(0),
 320       error_count_(0),
 321       created_requests_(0),
 322       destroyed_requests_(0),
 323       completed_requests_(0),
 324       canceled_requests_(0),
 325       cookie_options_bit_mask_(0),
 326       blocked_get_cookies_count_(0),
 327       blocked_set_cookie_count_(0),
 328       set_cookie_count_(0),
 329       observed_before_proxy_headers_sent_callbacks_(0),
 330       before_send_headers_count_(0),
 331       headers_received_count_(0),
 332       total_network_bytes_received_(0),
 333       has_load_timing_info_before_redirect_(false),
 334       has_load_timing_info_before_auth_(false),
 335       can_access_files_(true),
 336       first_party_only_cookies_enabled_(false),
 337       cancel_request_with_policy_violating_referrer_(false),
 338       will_be_intercepted_on_next_error_(false) {}
 339
 340 TestNetworkDelegate::~TestNetworkDelegate() {
 341   for (std::map<int, int>::iterator i = next_states_.begin();
 342        i != next_states_.end(); ++i) {
 343     event_order_[i->first] += "~TestNetworkDelegate\n";
 344     EXPECT_TRUE(i->second & kStageDestruction) << event_order_[i->first];
 345   }
 346 }
 347
 348 bool TestNetworkDelegate::GetLoadTimingInfoBeforeRedirect(
 349     LoadTimingInfo* load_timing_info_before_redirect) const {
 350   *load_timing_info_before_redirect = load_timing_info_before_redirect_;
 351   return has_load_timing_info_before_redirect_;
 352 }
 353
 354 bool TestNetworkDelegate::GetLoadTimingInfoBeforeAuth(
 355     LoadTimingInfo* load_timing_info_before_auth) const {
 356   *load_timing_info_before_auth = load_timing_info_before_auth_;
 357   return has_load_timing_info_before_auth_;
 358 }
 359
 360 void TestNetworkDelegate::InitRequestStatesIfNew(int request_id) {
 361   if (next_states_.find(request_id) == next_states_.end()) {
 362     // TODO(davidben): Although the URLRequest documentation does not allow
 363     // calling Cancel() before Start(), the ResourceLoader does so. URLRequest's
 364     // destructor also calls Cancel. Either officially support this or fix the
 365     // ResourceLoader code.
 366     next_states_[request_id] = kStageBeforeURLRequest | kStageCompletedError;
 367     event_order_[request_id] = "";
 368   }
 369 }
 370
 371 int TestNetworkDelegate::OnBeforeURLRequest(
 372     URLRequest* request,
 373     const CompletionCallback& callback,
 374     GURL* new_url) {
 375   int req_id = request->identifier();
 376   InitRequestStatesIfNew(req_id);
 377   event_order_[req_id] += "OnBeforeURLRequest\n";
 378   EXPECT_TRUE(next_states_[req_id] & kStageBeforeURLRequest) <<
 379       event_order_[req_id];
 380   next_states_[req_id] =
 381       kStageBeforeSendHeaders |
 382       kStageResponseStarted |  // data: URLs do not trigger sending headers
 383       kStageBeforeRedirect |  // a delegate can trigger a redirection
 384       kStageCompletedError |  // request canceled by delegate
 385       kStageAuthRequired;  // Auth can come next for FTP requests
 386   created_requests_++;
 387   return OK;
 388 }
 389
 390 int TestNetworkDelegate::OnBeforeSendHeaders(
 391     URLRequest* request,
 392     const CompletionCallback& callback,
 393     HttpRequestHeaders* headers) {
 394   int req_id = request->identifier();
 395   InitRequestStatesIfNew(req_id);
 396   event_order_[req_id] += "OnBeforeSendHeaders\n";
 397   EXPECT_TRUE(next_states_[req_id] & kStageBeforeSendHeaders) <<
 398       event_order_[req_id];
 399   next_states_[req_id] =
 400       kStageSendHeaders |
 401       kStageCompletedError;  // request canceled by delegate
 402   before_send_headers_count_++;
 403   return OK;
 404 }
 405
 406 void TestNetworkDelegate::OnBeforeSendProxyHeaders(
 407     URLRequest* request,
 408     const ProxyInfo& proxy_info,
 409     HttpRequestHeaders* headers) {
 410   ++observed_before_proxy_headers_sent_callbacks_;
 411   last_observed_proxy_ = proxy_info.proxy_server().host_port_pair();
 412 }
 413
 414 void TestNetworkDelegate::OnSendHeaders(
 415     URLRequest* request,
 416     const HttpRequestHeaders& headers) {
 417   int req_id = request->identifier();
 418   InitRequestStatesIfNew(req_id);
 419   event_order_[req_id] += "OnSendHeaders\n";
 420   EXPECT_TRUE(next_states_[req_id] & kStageSendHeaders) <<
 421       event_order_[req_id];
 422   if (!will_be_intercepted_on_next_error_)
 423     next_states_[req_id] = kStageHeadersReceived | kStageCompletedError;
 424   else
 425     next_states_[req_id] = kStageResponseStarted;
 426   will_be_intercepted_on_next_error_ = false;
 427 }
 428
 429 int TestNetworkDelegate::OnHeadersReceived(
 430     URLRequest* request,
 431     const CompletionCallback& callback,
 432     const HttpResponseHeaders* original_response_headers,
 433     scoped_refptr<HttpResponseHeaders>* override_response_headers,
 434     GURL* allowed_unsafe_redirect_url) {
 435   int req_id = request->identifier();
 436   event_order_[req_id] += "OnHeadersReceived\n";
 437   InitRequestStatesIfNew(req_id);
 438   EXPECT_TRUE(next_states_[req_id] & kStageHeadersReceived) <<
 439       event_order_[req_id];
 440   next_states_[req_id] =
 441       kStageBeforeRedirect |
 442       kStageResponseStarted |
 443       kStageAuthRequired |
 444       kStageCompletedError;  // e.g. proxy resolution problem
 445
 446   // Basic authentication sends a second request from the URLRequestHttpJob
 447   // layer before the URLRequest reports that a response has started.
 448   next_states_[req_id] |= kStageBeforeSendHeaders;
 449
 450   if (!redirect_on_headers_received_url_.is_empty()) {
 451     *override_response_headers =
 452         new HttpResponseHeaders(original_response_headers->raw_headers());
 453     (*override_response_headers)->ReplaceStatusLine("HTTP/1.1 302 Found");
 454     (*override_response_headers)->RemoveHeader("Location");
 455     (*override_response_headers)->AddHeader(
 456         "Location: " + redirect_on_headers_received_url_.spec());
 457
 458     redirect_on_headers_received_url_ = GURL();
 459
 460     if (!allowed_unsafe_redirect_url_.is_empty())
 461       *allowed_unsafe_redirect_url = allowed_unsafe_redirect_url_;
 462   }
 463   headers_received_count_++;
 464   return OK;
 465 }
 466
 467 void TestNetworkDelegate::OnBeforeRedirect(URLRequest* request,
 468                                            const GURL& new_location) {
 469   load_timing_info_before_redirect_ = LoadTimingInfo();
 470   request->GetLoadTimingInfo(&load_timing_info_before_redirect_);
 471   has_load_timing_info_before_redirect_ = true;
 472   EXPECT_FALSE(load_timing_info_before_redirect_.request_start_time.is_null());
 473   EXPECT_FALSE(load_timing_info_before_redirect_.request_start.is_null());
 474
 475   int req_id = request->identifier();
 476   InitRequestStatesIfNew(req_id);
 477   event_order_[req_id] += "OnBeforeRedirect\n";
 478   EXPECT_TRUE(next_states_[req_id] & kStageBeforeRedirect) <<
 479       event_order_[req_id];
 480   next_states_[req_id] =
 481       kStageBeforeURLRequest |  // HTTP redirects trigger this.
 482       kStageBeforeSendHeaders |  // Redirects from the network delegate do not
 483                                  // trigger onBeforeURLRequest.
 484       kStageCompletedError;
 485
 486   // A redirect can lead to a file or a data URL. In this case, we do not send
 487   // headers.
 488   next_states_[req_id] |= kStageResponseStarted;
 489 }
 490
 491 void TestNetworkDelegate::OnResponseStarted(URLRequest* request) {
 492   LoadTimingInfo load_timing_info;
 493   request->GetLoadTimingInfo(&load_timing_info);
 494   EXPECT_FALSE(load_timing_info.request_start_time.is_null());
 495   EXPECT_FALSE(load_timing_info.request_start.is_null());
 496
 497   int req_id = request->identifier();
 498   InitRequestStatesIfNew(req_id);
 499   event_order_[req_id] += "OnResponseStarted\n";
 500   EXPECT_TRUE(next_states_[req_id] & kStageResponseStarted) <<
 501       event_order_[req_id];
 502   next_states_[req_id] = kStageCompletedSuccess | kStageCompletedError;
 503   if (request->status().status() == URLRequestStatus::FAILED) {
 504     error_count_++;
 505     last_error_ = request->status().error();
 506   }
 507 }
 508
 509 void TestNetworkDelegate::OnNetworkBytesReceived(const URLRequest& request,
 510                                                  int64_t bytes_received) {
 511   event_order_[request.identifier()] += "OnNetworkBytesReceived\n";
 512   total_network_bytes_received_ += bytes_received;
 513 }
 514
 515 void TestNetworkDelegate::OnCompleted(URLRequest* request, bool started) {
 516   int req_id = request->identifier();
 517   InitRequestStatesIfNew(req_id);
 518   event_order_[req_id] += "OnCompleted\n";
 519   // Expect "Success -> (next_states_ & kStageCompletedSuccess)"
 520   // is logically identical to
 521   // Expect "!(Success) || (next_states_ & kStageCompletedSuccess)"
 522   EXPECT_TRUE(!request->status().is_success() ||
 523               (next_states_[req_id] & kStageCompletedSuccess)) <<
 524       event_order_[req_id];
 525   EXPECT_TRUE(request->status().is_success() ||
 526               (next_states_[req_id] & kStageCompletedError)) <<
 527       event_order_[req_id];
 528   next_states_[req_id] = kStageURLRequestDestroyed;
 529   completed_requests_++;
 530   if (request->status().status() == URLRequestStatus::FAILED) {
 531     error_count_++;
 532     last_error_ = request->status().error();
 533   } else if (request->status().status() == URLRequestStatus::CANCELED) {
 534     canceled_requests_++;
 535   } else {
 536     DCHECK_EQ(URLRequestStatus::SUCCESS, request->status().status());
 537   }
 538 }
 539
 540 void TestNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) {
 541   int req_id = request->identifier();
 542   InitRequestStatesIfNew(req_id);
 543   event_order_[req_id] += "OnURLRequestDestroyed\n";
 544   EXPECT_TRUE(next_states_[req_id] & kStageURLRequestDestroyed) <<
 545       event_order_[req_id];
 546   next_states_[req_id] = kStageDestruction;
 547   destroyed_requests_++;
 548 }
 549
 550 void TestNetworkDelegate::OnPACScriptError(int line_number,
 551                                            const base::string16& error) {
 552 }
 553
 554 NetworkDelegate::AuthRequiredResponse TestNetworkDelegate::OnAuthRequired(
 555     URLRequest* request,
 556     const AuthChallengeInfo& auth_info,
 557     const AuthCallback& callback,
 558     AuthCredentials* credentials) {
 559   load_timing_info_before_auth_ = LoadTimingInfo();
 560   request->GetLoadTimingInfo(&load_timing_info_before_auth_);
 561   has_load_timing_info_before_auth_ = true;
 562   EXPECT_FALSE(load_timing_info_before_auth_.request_start_time.is_null());
 563   EXPECT_FALSE(load_timing_info_before_auth_.request_start.is_null());
 564
 565   int req_id = request->identifier();
 566   InitRequestStatesIfNew(req_id);
 567   event_order_[req_id] += "OnAuthRequired\n";
 568   EXPECT_TRUE(next_states_[req_id] & kStageAuthRequired) <<
 569       event_order_[req_id];
 570   next_states_[req_id] = kStageBeforeSendHeaders |
 571       kStageAuthRequired |  // For example, proxy auth followed by server auth.
 572       kStageHeadersReceived |  // Request canceled by delegate simulates empty
 573                                // response.
 574       kStageResponseStarted |  // data: URLs do not trigger sending headers
 575       kStageBeforeRedirect |   // a delegate can trigger a redirection
 576       kStageCompletedError;    // request cancelled before callback
 577   return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION;
 578 }
 579
 580 bool TestNetworkDelegate::OnCanGetCookies(const URLRequest& request,
 581                                           const CookieList& cookie_list) {
 582   bool allow = true;
 583   if (cookie_options_bit_mask_ & NO_GET_COOKIES)
 584     allow = false;
 585
 586   if (!allow) {
 587     blocked_get_cookies_count_++;
 588   }
 589
 590   return allow;
 591 }
 592
 593 bool TestNetworkDelegate::OnCanSetCookie(const URLRequest& request,
 594                                          const std::string& cookie_line,
 595                                          CookieOptions* options) {
 596   bool allow = true;
 597   if (cookie_options_bit_mask_ & NO_SET_COOKIE)
 598     allow = false;
 599
 600   if (!allow) {
 601     blocked_set_cookie_count_++;
 602   } else {
 603     set_cookie_count_++;
 604   }
 605
 606   return allow;
 607 }
 608
 609 bool TestNetworkDelegate::OnCanAccessFile(const URLRequest& request,
 610                                           const base::FilePath& path) const {
 611   return can_access_files_;
 612 }
 613
 614 bool TestNetworkDelegate::OnFirstPartyOnlyCookieExperimentEnabled() const {
 615   return first_party_only_cookies_enabled_;
 616 }
 617
 618 bool TestNetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
 619     const URLRequest& request,
 620     const GURL& target_url,
 621     const GURL& referrer_url) const {
 622   return cancel_request_with_policy_violating_referrer_;
 623 }
 624
 625 TestJobInterceptor::TestJobInterceptor() : main_intercept_job_(NULL) {
 626 }
 627
 628 URLRequestJob* TestJobInterceptor::MaybeCreateJob(
 629     URLRequest* request,
 630     NetworkDelegate* network_delegate) const {
 631   URLRequestJob* job = main_intercept_job_;
 632   main_intercept_job_ = NULL;
 633   return job;
 634 }
 635
 636 void TestJobInterceptor::set_main_intercept_job(URLRequestJob* job) {
 637   main_intercept_job_ = job;
 638 }
 639
 640 }  // namespace net