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