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