Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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" |
Ben Murdoch | 9ab5563 | 2013-07-18 11:57:30 +0100 | [diff] [blame] | 9 | #include "base/message_loop/message_loop.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 10 | #include "base/threading/thread.h" |
| 11 | #include "base/threading/worker_pool.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 12 | #include "net/base/host_port_pair.h" |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 13 | #include "net/cert/cert_verifier.h" |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 14 | #include "net/dns/mock_host_resolver.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 15 | #include "net/http/http_network_session.h" |
Ben Murdoch | effb81e | 2014-03-31 11:51:25 +0100 | [diff] [blame] | 16 | #include "net/http/http_response_headers.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 17 | #include "net/http/http_server_properties_impl.h" |
Torne (Richard Coles) | 7d4cd47 | 2013-06-19 11:58:07 +0100 | [diff] [blame] | 18 | #include "net/http/transport_security_state.h" |
Torne (Richard Coles) | 5f1c943 | 2014-08-12 13:47:38 +0100 | [diff] [blame] | 19 | #include "net/ssl/channel_id_service.h" |
| 20 | #include "net/ssl/default_channel_id_store.h" |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 25 | namespace net { |
| 26 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 27 | namespace { |
| 28 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 29 | // These constants put the NetworkDelegate events of TestNetworkDelegate |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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), |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 49 | client_socket_factory_(NULL), |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 50 | context_storage_(this) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 51 | Init(); |
| 52 | } |
| 53 | |
| 54 | TestURLRequestContext::TestURLRequestContext(bool delay_initialization) |
| 55 | : initialized_(false), |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 56 | client_socket_factory_(NULL), |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 57 | context_storage_(this) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 58 | if (!delay_initialization) |
| 59 | Init(); |
| 60 | } |
| 61 | |
| 62 | TestURLRequestContext::~TestURLRequestContext() { |
| 63 | DCHECK(initialized_); |
Torne (Richard Coles) | 5f1c943 | 2014-08-12 13:47:38 +0100 | [diff] [blame] | 64 | AssertNoURLRequests(); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | void TestURLRequestContext::Init() { |
| 68 | DCHECK(!initialized_); |
| 69 | initialized_ = true; |
| 70 | |
| 71 | if (!host_resolver()) |
| 72 | context_storage_.set_host_resolver( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 73 | scoped_ptr<HostResolver>(new MockCachingHostResolver())); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 74 | if (!proxy_service()) |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 75 | context_storage_.set_proxy_service(ProxyService::CreateDirect()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 76 | if (!cert_verifier()) |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 77 | context_storage_.set_cert_verifier(CertVerifier::CreateDefault()); |
Torne (Richard Coles) | 7d4cd47 | 2013-06-19 11:58:07 +0100 | [diff] [blame] | 78 | if (!transport_security_state()) |
| 79 | context_storage_.set_transport_security_state(new TransportSecurityState); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 80 | if (!ssl_config_service()) |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 81 | context_storage_.set_ssl_config_service(new SSLConfigServiceDefaults); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 82 | if (!http_auth_handler_factory()) { |
| 83 | context_storage_.set_http_auth_handler_factory( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 84 | HttpAuthHandlerFactory::CreateDefault(host_resolver())); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 85 | } |
| 86 | if (!http_server_properties()) { |
| 87 | context_storage_.set_http_server_properties( |
Ben Murdoch | ca12bfa | 2013-07-23 11:17:05 +0100 | [diff] [blame] | 88 | scoped_ptr<HttpServerProperties>(new HttpServerPropertiesImpl())); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 89 | } |
| 90 | if (!transport_security_state()) { |
| 91 | context_storage_.set_transport_security_state( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 92 | new TransportSecurityState()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 93 | } |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 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; |
Torne (Richard Coles) | 46d4c2b | 2014-06-09 12:00:27 +0100 | [diff] [blame] | 99 | if (http_network_session_params_) |
| 100 | params = *http_network_session_params_; |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 101 | params.client_socket_factory = client_socket_factory(); |
| 102 | params.host_resolver = host_resolver(); |
| 103 | params.cert_verifier = cert_verifier(); |
Torne (Richard Coles) | 7d4cd47 | 2013-06-19 11:58:07 +0100 | [diff] [blame] | 104 | params.transport_security_state = transport_security_state(); |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 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))); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 114 | } |
| 115 | // In-memory cookie store. |
| 116 | if (!cookie_store()) |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 117 | context_storage_.set_cookie_store(new CookieMonster(NULL, NULL)); |
Torne (Richard Coles) | 5f1c943 | 2014-08-12 13:47:38 +0100 | [diff] [blame] | 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), |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 123 | base::WorkerPool::GetTaskRunner(true))); |
| 124 | } |
| 125 | if (!http_user_agent_settings()) { |
| 126 | context_storage_.set_http_user_agent_settings( |
Torne (Richard Coles) | a3f6a49 | 2013-12-18 16:25:09 +0000 | [diff] [blame] | 127 | new StaticHttpUserAgentSettings("en-us,fr", std::string())); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 128 | } |
| 129 | if (!job_factory()) |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 130 | context_storage_.set_job_factory(new URLRequestJobFactoryImpl); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 131 | } |
| 132 | |
| 133 | TestURLRequest::TestURLRequest(const GURL& url, |
Torne (Richard Coles) | 0f1bc08 | 2013-11-06 12:27:47 +0000 | [diff] [blame] | 134 | RequestPriority priority, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 135 | Delegate* delegate, |
Torne (Richard Coles) | 0f1bc08 | 2013-11-06 12:27:47 +0000 | [diff] [blame] | 136 | TestURLRequestContext* context) |
Torne (Richard Coles) | 03b57e0 | 2014-08-28 12:05:23 +0100 | [diff] [blame] | 137 | : URLRequest(url, priority, delegate, context, NULL, NULL) {} |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 138 | |
| 139 | TestURLRequest::~TestURLRequest() { |
| 140 | } |
| 141 | |
| 142 | TestURLRequestContextGetter::TestURLRequestContextGetter( |
| 143 | const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner) |
| 144 | : network_task_runner_(network_task_runner) { |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 145 | DCHECK(network_task_runner_.get()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 146 | } |
| 147 | |
| 148 | TestURLRequestContextGetter::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()) { |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 152 | DCHECK(network_task_runner_.get()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 153 | } |
| 154 | |
| 155 | TestURLRequestContextGetter::~TestURLRequestContextGetter() {} |
| 156 | |
| 157 | TestURLRequestContext* TestURLRequestContextGetter::GetURLRequestContext() { |
| 158 | if (!context_.get()) |
| 159 | context_.reset(new TestURLRequestContext); |
| 160 | return context_.get(); |
| 161 | } |
| 162 | |
| 163 | scoped_refptr<base::SingleThreadTaskRunner> |
| 164 | TestURLRequestContextGetter::GetNetworkTaskRunner() const { |
| 165 | return network_task_runner_; |
| 166 | } |
| 167 | |
| 168 | TestDelegate::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), |
Torne (Richard Coles) | 5d1f7b1 | 2014-02-21 12:16:55 +0000 | [diff] [blame] | 175 | quit_on_before_network_start_(false), |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 176 | allow_certificate_errors_(false), |
| 177 | response_started_count_(0), |
| 178 | received_bytes_count_(0), |
| 179 | received_redirect_count_(0), |
Torne (Richard Coles) | 5d1f7b1 | 2014-02-21 12:16:55 +0000 | [diff] [blame] | 180 | received_before_network_start_count_(0), |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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), |
Ben Murdoch | eb525c5 | 2013-07-10 11:40:50 +0100 | [diff] [blame] | 186 | have_full_request_headers_(false), |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 187 | buf_(new IOBuffer(kBufferSize)) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | TestDelegate::~TestDelegate() {} |
| 191 | |
Ben Murdoch | eb525c5 | 2013-07-10 11:40:50 +0100 | [diff] [blame] | 192 | void TestDelegate::ClearFullRequestHeaders() { |
| 193 | full_request_headers_.Clear(); |
| 194 | have_full_request_headers_ = false; |
| 195 | } |
| 196 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 197 | void TestDelegate::OnReceivedRedirect(URLRequest* request, |
Torne (Richard Coles) | 6e8cce6 | 2014-08-19 13:00:08 +0100 | [diff] [blame] | 198 | const RedirectInfo& redirect_info, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 199 | bool* defer_redirect) { |
| 200 | EXPECT_TRUE(request->is_redirecting()); |
Ben Murdoch | eb525c5 | 2013-07-10 11:40:50 +0100 | [diff] [blame] | 201 | |
| 202 | have_full_request_headers_ = |
| 203 | request->GetFullRequestHeaders(&full_request_headers_); |
| 204 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 205 | received_redirect_count_++; |
| 206 | if (quit_on_redirect_) { |
| 207 | *defer_redirect = true; |
Torne (Richard Coles) | 90dce4d | 2013-05-29 14:40:03 +0100 | [diff] [blame] | 208 | base::MessageLoop::current()->PostTask(FROM_HERE, |
| 209 | base::MessageLoop::QuitClosure()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 210 | } else if (cancel_in_rr_) { |
| 211 | request->Cancel(); |
| 212 | } |
| 213 | } |
| 214 | |
Torne (Richard Coles) | 5d1f7b1 | 2014-02-21 12:16:55 +0000 | [diff] [blame] | 215 | void 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 224 | void TestDelegate::OnAuthRequired(URLRequest* request, |
| 225 | AuthChallengeInfo* auth_info) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 226 | auth_required_ = true; |
| 227 | if (!credentials_.Empty()) { |
| 228 | request->SetAuth(credentials_); |
| 229 | } else { |
| 230 | request->CancelAuth(); |
| 231 | } |
| 232 | } |
| 233 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 234 | void TestDelegate::OnSSLCertificateError(URLRequest* request, |
| 235 | const SSLInfo& ssl_info, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 248 | void TestDelegate::OnResponseStarted(URLRequest* request) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Ben Murdoch | eb525c5 | 2013-07-10 11:40:50 +0100 | [diff] [blame] | 253 | have_full_request_headers_ = |
| 254 | request->GetFullRequestHeaders(&full_request_headers_); |
| 255 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 256 | response_started_count_++; |
| 257 | if (cancel_in_rs_) { |
| 258 | request->Cancel(); |
| 259 | OnResponseCompleted(request); |
| 260 | } else if (!request->status().is_success()) { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 261 | DCHECK(request->status().status() == URLRequestStatus::FAILED || |
| 262 | request->status().status() == URLRequestStatus::CANCELED); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 263 | request_failed_ = true; |
| 264 | OnResponseCompleted(request); |
| 265 | } else { |
| 266 | // Initiate the first read. |
| 267 | int bytes_read = 0; |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 268 | if (request->Read(buf_.get(), kBufferSize, &bytes_read)) |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 269 | OnReadCompleted(request, bytes_read); |
| 270 | else if (!request->status().is_io_pending()) |
| 271 | OnResponseCompleted(request); |
| 272 | } |
| 273 | } |
| 274 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 275 | void TestDelegate::OnReadCompleted(URLRequest* request, int bytes_read) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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; |
Torne (Richard Coles) | 868fa2f | 2013-06-11 10:57:03 +0100 | [diff] [blame] | 296 | while (request->Read(buf_.get(), kBufferSize, &bytes_read)) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 311 | void TestDelegate::OnResponseCompleted(URLRequest* request) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 312 | if (quit_on_complete_) |
Torne (Richard Coles) | 90dce4d | 2013-05-29 14:40:03 +0100 | [diff] [blame] | 313 | base::MessageLoop::current()->PostTask(FROM_HERE, |
| 314 | base::MessageLoop::QuitClosure()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 315 | } |
| 316 | |
| 317 | TestNetworkDelegate::TestNetworkDelegate() |
| 318 | : last_error_(0), |
| 319 | error_count_(0), |
| 320 | created_requests_(0), |
| 321 | destroyed_requests_(0), |
| 322 | completed_requests_(0), |
Torne (Richard Coles) | f2477e0 | 2013-11-28 11:55:43 +0000 | [diff] [blame] | 323 | canceled_requests_(0), |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 324 | cookie_options_bit_mask_(0), |
| 325 | blocked_get_cookies_count_(0), |
| 326 | blocked_set_cookie_count_(0), |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 327 | set_cookie_count_(0), |
Ben Murdoch | 116680a | 2014-07-20 18:25:52 -0700 | [diff] [blame] | 328 | observed_before_proxy_headers_sent_callbacks_(0), |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 329 | has_load_timing_info_before_redirect_(false), |
Torne (Richard Coles) | f2477e0 | 2013-11-28 11:55:43 +0000 | [diff] [blame] | 330 | has_load_timing_info_before_auth_(false), |
| 331 | can_access_files_(true), |
| 332 | can_throttle_requests_(true) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 333 | } |
| 334 | |
| 335 | TestNetworkDelegate::~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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 343 | bool 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 | |
| 349 | bool 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 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 355 | void TestNetworkDelegate::InitRequestStatesIfNew(int request_id) { |
| 356 | if (next_states_.find(request_id) == next_states_.end()) { |
Torne (Richard Coles) | f2477e0 | 2013-11-28 11:55:43 +0000 | [diff] [blame] | 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; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 362 | event_order_[request_id] = ""; |
| 363 | } |
| 364 | } |
| 365 | |
| 366 | int TestNetworkDelegate::OnBeforeURLRequest( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 367 | URLRequest* request, |
| 368 | const CompletionCallback& callback, |
Torne (Richard Coles) | 6e8cce6 | 2014-08-19 13:00:08 +0100 | [diff] [blame] | 369 | GURL* new_url) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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_++; |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 382 | return OK; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 383 | } |
| 384 | |
| 385 | int TestNetworkDelegate::OnBeforeSendHeaders( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 386 | URLRequest* request, |
| 387 | const CompletionCallback& callback, |
| 388 | HttpRequestHeaders* headers) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 398 | return OK; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 399 | } |
| 400 | |
Ben Murdoch | 116680a | 2014-07-20 18:25:52 -0700 | [diff] [blame] | 401 | void 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 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 409 | void TestNetworkDelegate::OnSendHeaders( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 410 | URLRequest* request, |
| 411 | const HttpRequestHeaders& headers) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
| 422 | int TestNetworkDelegate::OnHeadersReceived( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 423 | URLRequest* request, |
| 424 | const CompletionCallback& callback, |
| 425 | const HttpResponseHeaders* original_response_headers, |
Ben Murdoch | effb81e | 2014-03-31 11:51:25 +0100 | [diff] [blame] | 426 | scoped_refptr<HttpResponseHeaders>* override_response_headers, |
| 427 | GURL* allowed_unsafe_redirect_url) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Ben Murdoch | effb81e | 2014-03-31 11:51:25 +0100 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 457 | return OK; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 458 | } |
| 459 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 460 | void TestNetworkDelegate::OnBeforeRedirect(URLRequest* request, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 461 | const GURL& new_location) { |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 484 | void 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 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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; |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 496 | if (request->status().status() == URLRequestStatus::FAILED) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 497 | error_count_++; |
| 498 | last_error_ = request->status().error(); |
| 499 | } |
| 500 | } |
| 501 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 502 | void TestNetworkDelegate::OnRawBytesRead(const URLRequest& request, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 503 | int bytes_read) { |
| 504 | } |
| 505 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 506 | void TestNetworkDelegate::OnCompleted(URLRequest* request, bool started) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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_++; |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 521 | if (request->status().status() == URLRequestStatus::FAILED) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 522 | error_count_++; |
| 523 | last_error_ = request->status().error(); |
Torne (Richard Coles) | f2477e0 | 2013-11-28 11:55:43 +0000 | [diff] [blame] | 524 | } else if (request->status().status() == URLRequestStatus::CANCELED) { |
| 525 | canceled_requests_++; |
| 526 | } else { |
| 527 | DCHECK_EQ(URLRequestStatus::SUCCESS, request->status().status()); |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 528 | } |
| 529 | } |
| 530 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 531 | void TestNetworkDelegate::OnURLRequestDestroyed(URLRequest* request) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
| 541 | void TestNetworkDelegate::OnPACScriptError(int line_number, |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 542 | const base::string16& error) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 543 | } |
| 544 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 545 | NetworkDelegate::AuthRequiredResponse TestNetworkDelegate::OnAuthRequired( |
| 546 | URLRequest* request, |
| 547 | const AuthChallengeInfo& auth_info, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 548 | const AuthCallback& callback, |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | c2e0dbd | 2013-05-09 18:35:53 +0100 | [diff] [blame] | 562 | kStageAuthRequired | // For example, proxy auth followed by server auth. |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 568 | return NetworkDelegate::AUTH_REQUIRED_RESPONSE_NO_ACTION; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 569 | } |
| 570 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 571 | bool TestNetworkDelegate::OnCanGetCookies(const URLRequest& request, |
| 572 | const CookieList& cookie_list) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 584 | bool TestNetworkDelegate::OnCanSetCookie(const URLRequest& request, |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 585 | const std::string& cookie_line, |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 586 | CookieOptions* options) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 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 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 600 | bool TestNetworkDelegate::OnCanAccessFile(const URLRequest& request, |
| 601 | const base::FilePath& path) const { |
Torne (Richard Coles) | f2477e0 | 2013-11-28 11:55:43 +0000 | [diff] [blame] | 602 | return can_access_files_; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 603 | } |
| 604 | |
| 605 | bool TestNetworkDelegate::OnCanThrottleRequest( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 606 | const URLRequest& request) const { |
Torne (Richard Coles) | f2477e0 | 2013-11-28 11:55:43 +0000 | [diff] [blame] | 607 | return can_throttle_requests_; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 608 | } |
| 609 | |
| 610 | int TestNetworkDelegate::OnBeforeSocketStreamConnect( |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 611 | SocketStream* socket, |
| 612 | const CompletionCallback& callback) { |
| 613 | return OK; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 614 | } |
| 615 | |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 616 | // static |
| 617 | std::string ScopedCustomUrlRequestTestHttpHost::value_("127.0.0.1"); |
| 618 | |
| 619 | ScopedCustomUrlRequestTestHttpHost::ScopedCustomUrlRequestTestHttpHost( |
| 620 | const std::string& new_value) |
| 621 | : old_value_(value_), |
| 622 | new_value_(new_value) { |
| 623 | value_ = new_value_; |
| 624 | } |
| 625 | |
| 626 | ScopedCustomUrlRequestTestHttpHost::~ScopedCustomUrlRequestTestHttpHost() { |
| 627 | DCHECK_EQ(value_, new_value_); |
| 628 | value_ = old_value_; |
| 629 | } |
| 630 | |
| 631 | // static |
| 632 | const std::string& ScopedCustomUrlRequestTestHttpHost::value() { |
| 633 | return value_; |
| 634 | } |
| 635 | |
| 636 | TestJobInterceptor::TestJobInterceptor() : main_intercept_job_(NULL) { |
| 637 | } |
| 638 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 639 | URLRequestJob* TestJobInterceptor::MaybeCreateJob( |
| 640 | URLRequest* request, |
| 641 | NetworkDelegate* network_delegate) const { |
| 642 | URLRequestJob* job = main_intercept_job_; |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 643 | main_intercept_job_ = NULL; |
| 644 | return job; |
| 645 | } |
| 646 | |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 647 | void TestJobInterceptor::set_main_intercept_job(URLRequestJob* job) { |
Torne (Richard Coles) | 5821806 | 2012-11-14 11:43:16 +0000 | [diff] [blame] | 648 | main_intercept_job_ = job; |
| 649 | } |
Torne (Richard Coles) | 2a99a7e | 2013-03-28 15:31:22 +0000 | [diff] [blame] | 650 | |
| 651 | } // namespace net |