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