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