resource_dispatcher_host_unittest.cc revision cedac228d2dd51db4b79ea1e72c7f249408ee061
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 <vector> 6 7#include "base/basictypes.h" 8#include "base/bind.h" 9#include "base/file_util.h" 10#include "base/files/file_path.h" 11#include "base/memory/scoped_vector.h" 12#include "base/memory/shared_memory.h" 13#include "base/message_loop/message_loop.h" 14#include "base/pickle.h" 15#include "base/run_loop.h" 16#include "base/strings/string_number_conversions.h" 17#include "base/strings/string_split.h" 18#include "content/browser/browser_thread_impl.h" 19#include "content/browser/child_process_security_policy_impl.h" 20#include "content/browser/loader/cross_site_resource_handler.h" 21#include "content/browser/loader/detachable_resource_handler.h" 22#include "content/browser/loader/resource_dispatcher_host_impl.h" 23#include "content/browser/loader/resource_loader.h" 24#include "content/browser/loader/resource_message_filter.h" 25#include "content/browser/loader/resource_request_info_impl.h" 26#include "content/browser/worker_host/worker_service_impl.h" 27#include "content/common/child_process_host_impl.h" 28#include "content/common/resource_messages.h" 29#include "content/common/view_messages.h" 30#include "content/public/browser/global_request_id.h" 31#include "content/public/browser/resource_context.h" 32#include "content/public/browser/resource_dispatcher_host_delegate.h" 33#include "content/public/browser/resource_request_info.h" 34#include "content/public/browser/resource_throttle.h" 35#include "content/public/common/process_type.h" 36#include "content/public/common/resource_response.h" 37#include "content/public/test/test_browser_context.h" 38#include "content/public/test/test_browser_thread_bundle.h" 39#include "content/test/test_content_browser_client.h" 40#include "net/base/net_errors.h" 41#include "net/base/request_priority.h" 42#include "net/base/upload_bytes_element_reader.h" 43#include "net/base/upload_data_stream.h" 44#include "net/http/http_util.h" 45#include "net/url_request/url_request.h" 46#include "net/url_request/url_request_context.h" 47#include "net/url_request/url_request_job.h" 48#include "net/url_request/url_request_simple_job.h" 49#include "net/url_request/url_request_test_job.h" 50#include "net/url_request/url_request_test_util.h" 51#include "testing/gtest/include/gtest/gtest.h" 52#include "webkit/common/appcache/appcache_interfaces.h" 53#include "webkit/common/blob/shareable_file_reference.h" 54 55// TODO(eroman): Write unit tests for SafeBrowsing that exercise 56// SafeBrowsingResourceHandler. 57 58using webkit_blob::ShareableFileReference; 59 60namespace content { 61 62namespace { 63 64// Returns the resource response header structure for this request. 65void GetResponseHead(const std::vector<IPC::Message>& messages, 66 ResourceResponseHead* response_head) { 67 ASSERT_GE(messages.size(), 2U); 68 69 // The first messages should be received response. 70 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type()); 71 72 PickleIterator iter(messages[0]); 73 int request_id; 74 ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, &request_id)); 75 ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, response_head)); 76} 77 78void GenerateIPCMessage( 79 scoped_refptr<ResourceMessageFilter> filter, 80 scoped_ptr<IPC::Message> message) { 81 ResourceDispatcherHostImpl::Get()->OnMessageReceived( 82 *message, filter.get()); 83} 84 85// On Windows, ResourceMsg_SetDataBuffer supplies a HANDLE which is not 86// automatically released. 87// 88// See ResourceDispatcher::ReleaseResourcesInDataMessage. 89// 90// TODO(davidben): It would be nice if the behavior for base::SharedMemoryHandle 91// were more like it is in POSIX where the received fds are tracked in a 92// ref-counted core that closes them if not extracted. 93void ReleaseHandlesInMessage(const IPC::Message& message) { 94 if (message.type() == ResourceMsg_SetDataBuffer::ID) { 95 PickleIterator iter(message); 96 int request_id; 97 CHECK(message.ReadInt(&iter, &request_id)); 98 base::SharedMemoryHandle shm_handle; 99 if (IPC::ParamTraits<base::SharedMemoryHandle>::Read(&message, 100 &iter, 101 &shm_handle)) { 102 if (base::SharedMemory::IsHandleValid(shm_handle)) 103 base::SharedMemory::CloseHandle(shm_handle); 104 } 105 } 106} 107 108} // namespace 109 110static int RequestIDForMessage(const IPC::Message& msg) { 111 int request_id = -1; 112 switch (msg.type()) { 113 case ResourceMsg_UploadProgress::ID: 114 case ResourceMsg_ReceivedResponse::ID: 115 case ResourceMsg_ReceivedRedirect::ID: 116 case ResourceMsg_SetDataBuffer::ID: 117 case ResourceMsg_DataReceived::ID: 118 case ResourceMsg_DataDownloaded::ID: 119 case ResourceMsg_RequestComplete::ID: { 120 bool result = PickleIterator(msg).ReadInt(&request_id); 121 DCHECK(result); 122 break; 123 } 124 } 125 return request_id; 126} 127 128static ResourceHostMsg_Request CreateResourceRequest( 129 const char* method, 130 ResourceType::Type type, 131 const GURL& url) { 132 ResourceHostMsg_Request request; 133 request.method = std::string(method); 134 request.url = url; 135 request.first_party_for_cookies = url; // bypass third-party cookie blocking 136 request.referrer_policy = blink::WebReferrerPolicyDefault; 137 request.load_flags = 0; 138 request.origin_pid = 0; 139 request.resource_type = type; 140 request.request_context = 0; 141 request.appcache_host_id = appcache::kNoHostId; 142 request.download_to_file = false; 143 request.is_main_frame = true; 144 request.parent_is_main_frame = false; 145 request.parent_render_frame_id = -1; 146 request.transition_type = PAGE_TRANSITION_LINK; 147 request.allow_download = true; 148 return request; 149} 150 151// Spin up the message loop to kick off the request. 152static void KickOffRequest() { 153 base::MessageLoop::current()->RunUntilIdle(); 154} 155 156// We may want to move this to a shared space if it is useful for something else 157class ResourceIPCAccumulator { 158 public: 159 ~ResourceIPCAccumulator() { 160 for (size_t i = 0; i < messages_.size(); i++) { 161 ReleaseHandlesInMessage(messages_[i]); 162 } 163 } 164 165 // On Windows, takes ownership of SharedMemoryHandles in |msg|. 166 void AddMessage(const IPC::Message& msg) { 167 messages_.push_back(msg); 168 } 169 170 // This groups the messages by their request ID. The groups will be in order 171 // that the first message for each request ID was received, and the messages 172 // within the groups will be in the order that they appeared. 173 // Note that this clears messages_. The caller takes ownership of any 174 // SharedMemoryHandles in messages placed into |msgs|. 175 typedef std::vector< std::vector<IPC::Message> > ClassifiedMessages; 176 void GetClassifiedMessages(ClassifiedMessages* msgs); 177 178 private: 179 std::vector<IPC::Message> messages_; 180}; 181 182// This is very inefficient as a result of repeatedly extracting the ID, use 183// only for tests! 184void ResourceIPCAccumulator::GetClassifiedMessages(ClassifiedMessages* msgs) { 185 while (!messages_.empty()) { 186 // Ignore unknown message types as it is valid for code to generated other 187 // IPCs as side-effects that we are not testing here. 188 int cur_id = RequestIDForMessage(messages_[0]); 189 if (cur_id != -1) { 190 std::vector<IPC::Message> cur_requests; 191 cur_requests.push_back(messages_[0]); 192 // find all other messages with this ID 193 for (int i = 1; i < static_cast<int>(messages_.size()); i++) { 194 int id = RequestIDForMessage(messages_[i]); 195 if (id == cur_id) { 196 cur_requests.push_back(messages_[i]); 197 messages_.erase(messages_.begin() + i); 198 i--; 199 } 200 } 201 msgs->push_back(cur_requests); 202 } 203 messages_.erase(messages_.begin()); 204 } 205} 206 207// This is used to emulate different sub-processes, since this filter will 208// have a different ID than the original. 209class TestFilter : public ResourceMessageFilter { 210 public: 211 explicit TestFilter(ResourceContext* resource_context) 212 : ResourceMessageFilter( 213 ChildProcessHostImpl::GenerateChildProcessUniqueId(), 214 PROCESS_TYPE_RENDERER, NULL, NULL, NULL, NULL, 215 base::Bind(&TestFilter::GetContexts, base::Unretained(this))), 216 resource_context_(resource_context), 217 canceled_(false), 218 received_after_canceled_(0) { 219 ChildProcessSecurityPolicyImpl::GetInstance()->Add(child_id()); 220 set_peer_pid_for_testing(base::GetCurrentProcId()); 221 } 222 223 void set_canceled(bool canceled) { canceled_ = canceled; } 224 int received_after_canceled() const { return received_after_canceled_; } 225 226 // ResourceMessageFilter override 227 virtual bool Send(IPC::Message* msg) OVERRIDE { 228 // No messages should be received when the process has been canceled. 229 if (canceled_) 230 received_after_canceled_++; 231 ReleaseHandlesInMessage(*msg); 232 delete msg; 233 return true; 234 } 235 236 ResourceContext* resource_context() { return resource_context_; } 237 238 protected: 239 virtual ~TestFilter() {} 240 241 private: 242 void GetContexts(const ResourceHostMsg_Request& request, 243 ResourceContext** resource_context, 244 net::URLRequestContext** request_context) { 245 *resource_context = resource_context_; 246 *request_context = resource_context_->GetRequestContext(); 247 } 248 249 ResourceContext* resource_context_; 250 bool canceled_; 251 int received_after_canceled_; 252 253 DISALLOW_COPY_AND_ASSIGN(TestFilter); 254}; 255 256 257// This class forwards the incoming messages to the ResourceDispatcherHostTest. 258// For the test, we want all the incoming messages to go to the same place, 259// which is why this forwards. 260class ForwardingFilter : public TestFilter { 261 public: 262 explicit ForwardingFilter(IPC::Sender* dest, 263 ResourceContext* resource_context) 264 : TestFilter(resource_context), 265 dest_(dest) { 266 } 267 268 // TestFilter override 269 virtual bool Send(IPC::Message* msg) OVERRIDE { 270 return dest_->Send(msg); 271 } 272 273 private: 274 virtual ~ForwardingFilter() {} 275 276 IPC::Sender* dest_; 277 278 DISALLOW_COPY_AND_ASSIGN(ForwardingFilter); 279}; 280 281// This class is a variation on URLRequestTestJob that will call 282// URLRequest::OnBeforeNetworkStart before starting. 283class URLRequestTestDelayedNetworkJob : public net::URLRequestTestJob { 284 public: 285 URLRequestTestDelayedNetworkJob(net::URLRequest* request, 286 net::NetworkDelegate* network_delegate) 287 : net::URLRequestTestJob(request, network_delegate) {} 288 289 // Only start if not deferred for network start. 290 virtual void Start() OVERRIDE { 291 bool defer = false; 292 NotifyBeforeNetworkStart(&defer); 293 if (defer) 294 return; 295 net::URLRequestTestJob::Start(); 296 } 297 298 virtual void ResumeNetworkStart() OVERRIDE { 299 net::URLRequestTestJob::StartAsync(); 300 } 301 302 private: 303 virtual ~URLRequestTestDelayedNetworkJob() {} 304 305 DISALLOW_COPY_AND_ASSIGN(URLRequestTestDelayedNetworkJob); 306}; 307 308// This class is a variation on URLRequestTestJob in that it does 309// not complete start upon entry, only when specifically told to. 310class URLRequestTestDelayedStartJob : public net::URLRequestTestJob { 311 public: 312 URLRequestTestDelayedStartJob(net::URLRequest* request, 313 net::NetworkDelegate* network_delegate) 314 : net::URLRequestTestJob(request, network_delegate) { 315 Init(); 316 } 317 URLRequestTestDelayedStartJob(net::URLRequest* request, 318 net::NetworkDelegate* network_delegate, 319 bool auto_advance) 320 : net::URLRequestTestJob(request, network_delegate, auto_advance) { 321 Init(); 322 } 323 URLRequestTestDelayedStartJob(net::URLRequest* request, 324 net::NetworkDelegate* network_delegate, 325 const std::string& response_headers, 326 const std::string& response_data, 327 bool auto_advance) 328 : net::URLRequestTestJob(request, 329 network_delegate, 330 response_headers, 331 response_data, 332 auto_advance) { 333 Init(); 334 } 335 336 // Do nothing until you're told to. 337 virtual void Start() OVERRIDE {} 338 339 // Finish starting a URL request whose job is an instance of 340 // URLRequestTestDelayedStartJob. It is illegal to call this routine 341 // with a URLRequest that does not use URLRequestTestDelayedStartJob. 342 static void CompleteStart(net::URLRequest* request) { 343 for (URLRequestTestDelayedStartJob* job = list_head_; 344 job; 345 job = job->next_) { 346 if (job->request() == request) { 347 job->net::URLRequestTestJob::Start(); 348 return; 349 } 350 } 351 NOTREACHED(); 352 } 353 354 static bool DelayedStartQueueEmpty() { 355 return !list_head_; 356 } 357 358 static void ClearQueue() { 359 if (list_head_) { 360 LOG(ERROR) 361 << "Unreleased entries on URLRequestTestDelayedStartJob delay queue" 362 << "; may result in leaks."; 363 list_head_ = NULL; 364 } 365 } 366 367 protected: 368 virtual ~URLRequestTestDelayedStartJob() { 369 for (URLRequestTestDelayedStartJob** job = &list_head_; *job; 370 job = &(*job)->next_) { 371 if (*job == this) { 372 *job = (*job)->next_; 373 return; 374 } 375 } 376 NOTREACHED(); 377 } 378 379 private: 380 void Init() { 381 next_ = list_head_; 382 list_head_ = this; 383 } 384 385 static URLRequestTestDelayedStartJob* list_head_; 386 URLRequestTestDelayedStartJob* next_; 387}; 388 389URLRequestTestDelayedStartJob* 390URLRequestTestDelayedStartJob::list_head_ = NULL; 391 392// This class is a variation on URLRequestTestJob in that it 393// returns IO_pending errors before every read, not just the first one. 394class URLRequestTestDelayedCompletionJob : public net::URLRequestTestJob { 395 public: 396 URLRequestTestDelayedCompletionJob(net::URLRequest* request, 397 net::NetworkDelegate* network_delegate) 398 : net::URLRequestTestJob(request, network_delegate) {} 399 URLRequestTestDelayedCompletionJob(net::URLRequest* request, 400 net::NetworkDelegate* network_delegate, 401 bool auto_advance) 402 : net::URLRequestTestJob(request, network_delegate, auto_advance) {} 403 URLRequestTestDelayedCompletionJob(net::URLRequest* request, 404 net::NetworkDelegate* network_delegate, 405 const std::string& response_headers, 406 const std::string& response_data, 407 bool auto_advance) 408 : net::URLRequestTestJob(request, 409 network_delegate, 410 response_headers, 411 response_data, 412 auto_advance) {} 413 414 protected: 415 virtual ~URLRequestTestDelayedCompletionJob() {} 416 417 private: 418 virtual bool NextReadAsync() OVERRIDE { return true; } 419}; 420 421class URLRequestBigJob : public net::URLRequestSimpleJob { 422 public: 423 URLRequestBigJob(net::URLRequest* request, 424 net::NetworkDelegate* network_delegate) 425 : net::URLRequestSimpleJob(request, network_delegate) { 426 } 427 428 virtual int GetData(std::string* mime_type, 429 std::string* charset, 430 std::string* data, 431 const net::CompletionCallback& callback) const OVERRIDE { 432 *mime_type = "text/plain"; 433 *charset = "UTF-8"; 434 435 std::string text; 436 int count; 437 if (!ParseURL(request_->url(), &text, &count)) 438 return net::ERR_INVALID_URL; 439 440 data->reserve(text.size() * count); 441 for (int i = 0; i < count; ++i) 442 data->append(text); 443 444 return net::OK; 445 } 446 447 private: 448 virtual ~URLRequestBigJob() {} 449 450 // big-job:substring,N 451 static bool ParseURL(const GURL& url, std::string* text, int* count) { 452 std::vector<std::string> parts; 453 base::SplitString(url.path(), ',', &parts); 454 455 if (parts.size() != 2) 456 return false; 457 458 *text = parts[0]; 459 return base::StringToInt(parts[1], count); 460 } 461}; 462 463class TestURLRequestJobFactory : public net::URLRequestJobFactory { 464 public: 465 explicit TestURLRequestJobFactory(ResourceDispatcherHostTest* test_fixture) : 466 test_fixture_(test_fixture), 467 delay_start_(false), 468 delay_complete_(false), 469 network_start_notification_(false), 470 url_request_jobs_created_count_(0) { 471 } 472 473 void HandleScheme(const std::string& scheme) { 474 supported_schemes_.insert(scheme); 475 } 476 477 int url_request_jobs_created_count() const { 478 return url_request_jobs_created_count_; 479 } 480 481 void SetDelayedStartJobGeneration(bool delay_job_start) { 482 delay_start_ = delay_job_start; 483 } 484 485 void SetDelayedCompleteJobGeneration(bool delay_job_complete) { 486 delay_complete_ = delay_job_complete; 487 } 488 489 void SetNetworkStartNotificationJobGeneration(bool notification) { 490 network_start_notification_ = notification; 491 } 492 493 virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler( 494 const std::string& scheme, 495 net::URLRequest* request, 496 net::NetworkDelegate* network_delegate) const OVERRIDE; 497 498 virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE { 499 return supported_schemes_.count(scheme) > 0; 500 } 501 502 virtual bool IsHandledURL(const GURL& url) const OVERRIDE { 503 return supported_schemes_.count(url.scheme()) > 0; 504 } 505 506 virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE { 507 return false; 508 } 509 510 private: 511 ResourceDispatcherHostTest* test_fixture_; 512 bool delay_start_; 513 bool delay_complete_; 514 bool network_start_notification_; 515 mutable int url_request_jobs_created_count_; 516 std::set<std::string> supported_schemes_; 517 518 DISALLOW_COPY_AND_ASSIGN(TestURLRequestJobFactory); 519}; 520 521// Associated with an URLRequest to determine if the URLRequest gets deleted. 522class TestUserData : public base::SupportsUserData::Data { 523 public: 524 explicit TestUserData(bool* was_deleted) 525 : was_deleted_(was_deleted) { 526 } 527 528 virtual ~TestUserData() { 529 *was_deleted_ = true; 530 } 531 532 private: 533 bool* was_deleted_; 534}; 535 536class TransfersAllNavigationsContentBrowserClient 537 : public TestContentBrowserClient { 538 public: 539 virtual bool ShouldSwapProcessesForRedirect(ResourceContext* resource_context, 540 const GURL& current_url, 541 const GURL& new_url) OVERRIDE { 542 return true; 543 } 544}; 545 546enum GenericResourceThrottleFlags { 547 NONE = 0, 548 DEFER_STARTING_REQUEST = 1 << 0, 549 DEFER_PROCESSING_RESPONSE = 1 << 1, 550 CANCEL_BEFORE_START = 1 << 2, 551 DEFER_NETWORK_START = 1 << 3 552}; 553 554// Throttle that tracks the current throttle blocking a request. Only one 555// can throttle any request at a time. 556class GenericResourceThrottle : public ResourceThrottle { 557 public: 558 // The value is used to indicate that the throttle should not provide 559 // a error code when cancelling a request. net::OK is used, because this 560 // is not an error code. 561 static const int USE_DEFAULT_CANCEL_ERROR_CODE = net::OK; 562 563 GenericResourceThrottle(int flags, int code) 564 : flags_(flags), 565 error_code_for_cancellation_(code) { 566 } 567 568 virtual ~GenericResourceThrottle() { 569 if (active_throttle_ == this) 570 active_throttle_ = NULL; 571 } 572 573 // ResourceThrottle implementation: 574 virtual void WillStartRequest(bool* defer) OVERRIDE { 575 ASSERT_EQ(NULL, active_throttle_); 576 if (flags_ & DEFER_STARTING_REQUEST) { 577 active_throttle_ = this; 578 *defer = true; 579 } 580 581 if (flags_ & CANCEL_BEFORE_START) { 582 if (error_code_for_cancellation_ == USE_DEFAULT_CANCEL_ERROR_CODE) { 583 controller()->Cancel(); 584 } else { 585 controller()->CancelWithError(error_code_for_cancellation_); 586 } 587 } 588 } 589 590 virtual void WillProcessResponse(bool* defer) OVERRIDE { 591 ASSERT_EQ(NULL, active_throttle_); 592 if (flags_ & DEFER_PROCESSING_RESPONSE) { 593 active_throttle_ = this; 594 *defer = true; 595 } 596 } 597 598 virtual void OnBeforeNetworkStart(bool* defer) OVERRIDE { 599 ASSERT_EQ(NULL, active_throttle_); 600 601 if (flags_ & DEFER_NETWORK_START) { 602 active_throttle_ = this; 603 *defer = true; 604 } 605 } 606 607 virtual const char* GetNameForLogging() const OVERRIDE { 608 return "GenericResourceThrottle"; 609 } 610 611 void Resume() { 612 ASSERT_TRUE(this == active_throttle_); 613 active_throttle_ = NULL; 614 controller()->Resume(); 615 } 616 617 static GenericResourceThrottle* active_throttle() { 618 return active_throttle_; 619 } 620 621 private: 622 int flags_; // bit-wise union of GenericResourceThrottleFlags. 623 int error_code_for_cancellation_; 624 625 // The currently active throttle, if any. 626 static GenericResourceThrottle* active_throttle_; 627}; 628// static 629GenericResourceThrottle* GenericResourceThrottle::active_throttle_ = NULL; 630 631class TestResourceDispatcherHostDelegate 632 : public ResourceDispatcherHostDelegate { 633 public: 634 TestResourceDispatcherHostDelegate() 635 : create_two_throttles_(false), 636 flags_(NONE), 637 error_code_for_cancellation_( 638 GenericResourceThrottle::USE_DEFAULT_CANCEL_ERROR_CODE) { 639 } 640 641 void set_url_request_user_data(base::SupportsUserData::Data* user_data) { 642 user_data_.reset(user_data); 643 } 644 645 void set_flags(int value) { 646 flags_ = value; 647 } 648 649 void set_error_code_for_cancellation(int code) { 650 error_code_for_cancellation_ = code; 651 } 652 653 void set_create_two_throttles(bool create_two_throttles) { 654 create_two_throttles_ = create_two_throttles; 655 } 656 657 // ResourceDispatcherHostDelegate implementation: 658 659 virtual void RequestBeginning( 660 net::URLRequest* request, 661 ResourceContext* resource_context, 662 appcache::AppCacheService* appcache_service, 663 ResourceType::Type resource_type, 664 int child_id, 665 int route_id, 666 ScopedVector<ResourceThrottle>* throttles) OVERRIDE { 667 if (user_data_) { 668 const void* key = user_data_.get(); 669 request->SetUserData(key, user_data_.release()); 670 } 671 672 if (flags_ != NONE) { 673 throttles->push_back(new GenericResourceThrottle( 674 flags_, error_code_for_cancellation_)); 675 if (create_two_throttles_) 676 throttles->push_back(new GenericResourceThrottle( 677 flags_, error_code_for_cancellation_)); 678 } 679 } 680 681 private: 682 bool create_two_throttles_; 683 int flags_; 684 int error_code_for_cancellation_; 685 scoped_ptr<base::SupportsUserData::Data> user_data_; 686}; 687 688// Waits for a ShareableFileReference to be released. 689class ShareableFileReleaseWaiter { 690 public: 691 ShareableFileReleaseWaiter(const base::FilePath& path) { 692 scoped_refptr<ShareableFileReference> file = 693 ShareableFileReference::Get(path); 694 file->AddFinalReleaseCallback( 695 base::Bind(&ShareableFileReleaseWaiter::Released, 696 base::Unretained(this))); 697 } 698 699 void Wait() { 700 loop_.Run(); 701 } 702 703 private: 704 void Released(const base::FilePath& path) { 705 loop_.Quit(); 706 } 707 708 base::RunLoop loop_; 709 710 DISALLOW_COPY_AND_ASSIGN(ShareableFileReleaseWaiter); 711}; 712 713class ResourceDispatcherHostTest : public testing::Test, 714 public IPC::Sender { 715 public: 716 ResourceDispatcherHostTest() 717 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP), 718 old_factory_(NULL), 719 send_data_received_acks_(false) { 720 browser_context_.reset(new TestBrowserContext()); 721 BrowserContext::EnsureResourceContextInitialized(browser_context_.get()); 722 base::RunLoop().RunUntilIdle(); 723 filter_ = MakeForwardingFilter(); 724 // TODO(cbentzel): Better way to get URLRequestContext? 725 net::URLRequestContext* request_context = 726 browser_context_->GetResourceContext()->GetRequestContext(); 727 job_factory_.reset(new TestURLRequestJobFactory(this)); 728 request_context->set_job_factory(job_factory_.get()); 729 request_context->set_network_delegate(&network_delegate_); 730 } 731 732 // IPC::Sender implementation 733 virtual bool Send(IPC::Message* msg) OVERRIDE { 734 accum_.AddMessage(*msg); 735 736 if (send_data_received_acks_ && 737 msg->type() == ResourceMsg_DataReceived::ID) { 738 GenerateDataReceivedACK(*msg); 739 } 740 741 if (wait_for_request_complete_loop_ && 742 msg->type() == ResourceMsg_RequestComplete::ID) { 743 wait_for_request_complete_loop_->Quit(); 744 } 745 746 // Do not release handles in it yet; the accumulator owns them now. 747 delete msg; 748 return true; 749 } 750 751 protected: 752 friend class TestURLRequestJobFactory; 753 754 // testing::Test 755 virtual void SetUp() OVERRIDE { 756 ChildProcessSecurityPolicyImpl::GetInstance()->Add(0); 757 HandleScheme("test"); 758 } 759 760 virtual void TearDown() { 761 EXPECT_TRUE(URLRequestTestDelayedStartJob::DelayedStartQueueEmpty()); 762 URLRequestTestDelayedStartJob::ClearQueue(); 763 764 for (std::set<int>::iterator it = child_ids_.begin(); 765 it != child_ids_.end(); ++it) { 766 host_.CancelRequestsForProcess(*it); 767 } 768 769 host_.Shutdown(); 770 771 ChildProcessSecurityPolicyImpl::GetInstance()->Remove(0); 772 773 // Flush the message loop to make application verifiers happy. 774 if (ResourceDispatcherHostImpl::Get()) 775 ResourceDispatcherHostImpl::Get()->CancelRequestsForContext( 776 browser_context_->GetResourceContext()); 777 778 WorkerServiceImpl::GetInstance()->PerformTeardownForTesting(); 779 780 browser_context_.reset(); 781 base::RunLoop().RunUntilIdle(); 782 } 783 784 // Creates a new ForwardingFilter and registers it with |child_ids_| so as not 785 // to leak per-child state on test shutdown. 786 ForwardingFilter* MakeForwardingFilter() { 787 ForwardingFilter* filter = 788 new ForwardingFilter(this, browser_context_->GetResourceContext()); 789 child_ids_.insert(filter->child_id()); 790 return filter; 791 } 792 793 // Creates a request using the current test object as the filter and 794 // SubResource as the resource type. 795 void MakeTestRequest(int render_view_id, 796 int request_id, 797 const GURL& url); 798 799 // Generates a request using the given filter and resource type. 800 void MakeTestRequestWithResourceType(ResourceMessageFilter* filter, 801 int render_view_id, int request_id, 802 const GURL& url, 803 ResourceType::Type type); 804 805 void CancelRequest(int request_id); 806 void RendererCancelRequest(int request_id) { 807 ResourceMessageFilter* old_filter = SetFilter(filter_.get()); 808 host_.OnCancelRequest(request_id); 809 SetFilter(old_filter); 810 } 811 812 void CompleteStartRequest(int request_id); 813 void CompleteStartRequest(ResourceMessageFilter* filter, int request_id); 814 815 net::TestNetworkDelegate* network_delegate() { return &network_delegate_; } 816 817 void EnsureSchemeIsAllowed(const std::string& scheme) { 818 ChildProcessSecurityPolicyImpl* policy = 819 ChildProcessSecurityPolicyImpl::GetInstance(); 820 if (!policy->IsWebSafeScheme(scheme)) 821 policy->RegisterWebSafeScheme(scheme); 822 } 823 824 // Sets a particular response for any request from now on. To switch back to 825 // the default bahavior, pass an empty |headers|. |headers| should be raw- 826 // formatted (NULLs instead of EOLs). 827 void SetResponse(const std::string& headers, const std::string& data) { 828 response_headers_ = net::HttpUtil::AssembleRawHeaders(headers.data(), 829 headers.size()); 830 response_data_ = data; 831 } 832 void SetResponse(const std::string& headers) { 833 SetResponse(headers, std::string()); 834 } 835 836 void SendDataReceivedACKs(bool send_acks) { 837 send_data_received_acks_ = send_acks; 838 } 839 840 // Intercepts requests for the given protocol. 841 void HandleScheme(const std::string& scheme) { 842 job_factory_->HandleScheme(scheme); 843 EnsureSchemeIsAllowed(scheme); 844 } 845 846 void GenerateDataReceivedACK(const IPC::Message& msg) { 847 EXPECT_EQ(ResourceMsg_DataReceived::ID, msg.type()); 848 849 int request_id = -1; 850 bool result = PickleIterator(msg).ReadInt(&request_id); 851 DCHECK(result); 852 scoped_ptr<IPC::Message> ack( 853 new ResourceHostMsg_DataReceived_ACK(request_id)); 854 855 base::MessageLoop::current()->PostTask( 856 FROM_HERE, 857 base::Bind(&GenerateIPCMessage, filter_, base::Passed(&ack))); 858 } 859 860 // Setting filters for testing renderer messages. 861 // Returns the previous filter. 862 ResourceMessageFilter* SetFilter(ResourceMessageFilter* new_filter) { 863 ResourceMessageFilter* old_filter = host_.filter_; 864 host_.filter_ = new_filter; 865 return old_filter; 866 } 867 868 void WaitForRequestComplete() { 869 DCHECK(!wait_for_request_complete_loop_); 870 wait_for_request_complete_loop_.reset(new base::RunLoop); 871 wait_for_request_complete_loop_->Run(); 872 wait_for_request_complete_loop_.reset(); 873 } 874 875 content::TestBrowserThreadBundle thread_bundle_; 876 scoped_ptr<TestBrowserContext> browser_context_; 877 scoped_ptr<TestURLRequestJobFactory> job_factory_; 878 scoped_refptr<ForwardingFilter> filter_; 879 net::TestNetworkDelegate network_delegate_; 880 ResourceDispatcherHostImpl host_; 881 ResourceIPCAccumulator accum_; 882 std::string response_headers_; 883 std::string response_data_; 884 std::string scheme_; 885 net::URLRequest::ProtocolFactory* old_factory_; 886 bool send_data_received_acks_; 887 std::set<int> child_ids_; 888 scoped_ptr<base::RunLoop> wait_for_request_complete_loop_; 889}; 890 891void ResourceDispatcherHostTest::MakeTestRequest(int render_view_id, 892 int request_id, 893 const GURL& url) { 894 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 895 url, ResourceType::SUB_RESOURCE); 896} 897 898void ResourceDispatcherHostTest::MakeTestRequestWithResourceType( 899 ResourceMessageFilter* filter, 900 int render_view_id, 901 int request_id, 902 const GURL& url, 903 ResourceType::Type type) { 904 ResourceHostMsg_Request request = 905 CreateResourceRequest("GET", type, url); 906 ResourceHostMsg_RequestResource msg(render_view_id, request_id, request); 907 host_.OnMessageReceived(msg, filter); 908 KickOffRequest(); 909} 910 911void ResourceDispatcherHostTest::CancelRequest(int request_id) { 912 host_.CancelRequest(filter_->child_id(), request_id); 913} 914 915void ResourceDispatcherHostTest::CompleteStartRequest(int request_id) { 916 CompleteStartRequest(filter_.get(), request_id); 917} 918 919void ResourceDispatcherHostTest::CompleteStartRequest( 920 ResourceMessageFilter* filter, 921 int request_id) { 922 GlobalRequestID gid(filter->child_id(), request_id); 923 net::URLRequest* req = host_.GetURLRequest(gid); 924 EXPECT_TRUE(req); 925 if (req) 926 URLRequestTestDelayedStartJob::CompleteStart(req); 927} 928 929void CheckRequestCompleteErrorCode(const IPC::Message& message, 930 int expected_error_code) { 931 // Verify the expected error code was received. 932 int request_id; 933 int error_code; 934 935 ASSERT_EQ(ResourceMsg_RequestComplete::ID, message.type()); 936 937 PickleIterator iter(message); 938 ASSERT_TRUE(IPC::ReadParam(&message, &iter, &request_id)); 939 ASSERT_TRUE(IPC::ReadParam(&message, &iter, &error_code)); 940 ASSERT_EQ(expected_error_code, error_code); 941} 942 943testing::AssertionResult ExtractDataOffsetAndLength(const IPC::Message& message, 944 int* data_offset, 945 int* data_length) { 946 PickleIterator iter(message); 947 int request_id; 948 if (!IPC::ReadParam(&message, &iter, &request_id)) 949 return testing::AssertionFailure() << "Could not read request_id"; 950 if (!IPC::ReadParam(&message, &iter, data_offset)) 951 return testing::AssertionFailure() << "Could not read data_offset"; 952 if (!IPC::ReadParam(&message, &iter, data_length)) 953 return testing::AssertionFailure() << "Could not read data_length"; 954 return testing::AssertionSuccess(); 955} 956 957void CheckSuccessfulRequestWithErrorCode( 958 const std::vector<IPC::Message>& messages, 959 const std::string& reference_data, 960 int expected_error) { 961 // A successful request will have received 4 messages: 962 // ReceivedResponse (indicates headers received) 963 // SetDataBuffer (contains shared memory handle) 964 // DataReceived (data offset and length into shared memory) 965 // RequestComplete (request is done) 966 // 967 // This function verifies that we received 4 messages and that they are 968 // appropriate. It allows for an error code other than net::OK if the request 969 // should successfully receive data and then abort, e.g., on cancel. 970 ASSERT_EQ(4U, messages.size()); 971 972 // The first messages should be received response 973 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type()); 974 975 ASSERT_EQ(ResourceMsg_SetDataBuffer::ID, messages[1].type()); 976 977 PickleIterator iter(messages[1]); 978 int request_id; 979 ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &request_id)); 980 base::SharedMemoryHandle shm_handle; 981 ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_handle)); 982 int shm_size; 983 ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_size)); 984 985 // Followed by the data, currently we only do the data in one chunk, but 986 // should probably test multiple chunks later 987 ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[2].type()); 988 989 int data_offset; 990 int data_length; 991 ASSERT_TRUE( 992 ExtractDataOffsetAndLength(messages[2], &data_offset, &data_length)); 993 994 ASSERT_EQ(reference_data.size(), static_cast<size_t>(data_length)); 995 ASSERT_GE(shm_size, data_length); 996 997 base::SharedMemory shared_mem(shm_handle, true); // read only 998 shared_mem.Map(data_length); 999 const char* data = static_cast<char*>(shared_mem.memory()) + data_offset; 1000 ASSERT_EQ(0, memcmp(reference_data.c_str(), data, data_length)); 1001 1002 // The last message should be all data received. 1003 CheckRequestCompleteErrorCode(messages[3], expected_error); 1004} 1005 1006void CheckSuccessfulRequest(const std::vector<IPC::Message>& messages, 1007 const std::string& reference_data) { 1008 CheckSuccessfulRequestWithErrorCode(messages, reference_data, net::OK); 1009} 1010 1011void CheckSuccessfulRedirect(const std::vector<IPC::Message>& messages, 1012 const std::string& reference_data) { 1013 ASSERT_EQ(5U, messages.size()); 1014 ASSERT_EQ(ResourceMsg_ReceivedRedirect::ID, messages[0].type()); 1015 1016 const std::vector<IPC::Message> second_req_msgs = 1017 std::vector<IPC::Message>(messages.begin() + 1, messages.end()); 1018 CheckSuccessfulRequest(second_req_msgs, reference_data); 1019} 1020 1021void CheckFailedRequest(const std::vector<IPC::Message>& messages, 1022 const std::string& reference_data, 1023 int expected_error) { 1024 ASSERT_LT(0U, messages.size()); 1025 ASSERT_GE(2U, messages.size()); 1026 size_t failure_index = messages.size() - 1; 1027 1028 if (messages.size() == 2) { 1029 EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type()); 1030 } 1031 1032 CheckRequestCompleteErrorCode(messages[failure_index], expected_error); 1033} 1034 1035// Tests whether many messages get dispatched properly. 1036TEST_F(ResourceDispatcherHostTest, TestMany) { 1037 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1038 MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2()); 1039 MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3()); 1040 MakeTestRequestWithResourceType(filter_.get(), 0, 4, 1041 net::URLRequestTestJob::test_url_4(), 1042 ResourceType::PREFETCH); // detachable type 1043 MakeTestRequest(0, 5, net::URLRequestTestJob::test_url_redirect_to_url_2()); 1044 1045 // Finish the redirection 1046 ResourceHostMsg_FollowRedirect redirect_msg(5); 1047 host_.OnMessageReceived(redirect_msg, filter_.get()); 1048 base::MessageLoop::current()->RunUntilIdle(); 1049 1050 // flush all the pending requests 1051 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1052 1053 // sorts out all the messages we saw by request 1054 ResourceIPCAccumulator::ClassifiedMessages msgs; 1055 accum_.GetClassifiedMessages(&msgs); 1056 1057 // there are five requests, so we should have gotten them classified as such 1058 ASSERT_EQ(5U, msgs.size()); 1059 1060 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1061 CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_2()); 1062 CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3()); 1063 CheckSuccessfulRequest(msgs[3], net::URLRequestTestJob::test_data_4()); 1064 CheckSuccessfulRedirect(msgs[4], net::URLRequestTestJob::test_data_2()); 1065} 1066 1067// Tests whether messages get canceled properly. We issue four requests, 1068// cancel two of them, and make sure that each sent the proper notifications. 1069TEST_F(ResourceDispatcherHostTest, Cancel) { 1070 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1071 MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2()); 1072 MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3()); 1073 1074 MakeTestRequestWithResourceType(filter_.get(), 0, 4, 1075 net::URLRequestTestJob::test_url_4(), 1076 ResourceType::PREFETCH); // detachable type 1077 1078 CancelRequest(2); 1079 1080 // Cancel request must come from the renderer for a detachable resource to 1081 // delay. 1082 RendererCancelRequest(4); 1083 1084 // The handler should have been detached now. 1085 GlobalRequestID global_request_id(filter_->child_id(), 4); 1086 ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest( 1087 host_.GetURLRequest(global_request_id)); 1088 ASSERT_TRUE(info->detachable_handler()->is_detached()); 1089 1090 // flush all the pending requests 1091 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1092 base::MessageLoop::current()->RunUntilIdle(); 1093 1094 // Everything should be out now. 1095 EXPECT_EQ(0, host_.pending_requests()); 1096 1097 ResourceIPCAccumulator::ClassifiedMessages msgs; 1098 accum_.GetClassifiedMessages(&msgs); 1099 1100 // there are four requests, so we should have gotten them classified as such 1101 ASSERT_EQ(4U, msgs.size()); 1102 1103 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1104 CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3()); 1105 1106 // Check that request 2 and 4 got canceled, as far as the renderer is 1107 // concerned. Request 2 will have been deleted. 1108 ASSERT_EQ(1U, msgs[1].size()); 1109 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[1][0].type()); 1110 1111 ASSERT_EQ(2U, msgs[3].size()); 1112 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[3][0].type()); 1113 CheckRequestCompleteErrorCode(msgs[3][1], net::ERR_ABORTED); 1114 1115 // However, request 4 should have actually gone to completion. (Only request 2 1116 // was canceled.) 1117 EXPECT_EQ(4, network_delegate()->completed_requests()); 1118 EXPECT_EQ(1, network_delegate()->canceled_requests()); 1119 EXPECT_EQ(0, network_delegate()->error_count()); 1120} 1121 1122// Shows that detachable requests will timeout if the request takes too long to 1123// complete. 1124TEST_F(ResourceDispatcherHostTest, DetachedResourceTimesOut) { 1125 MakeTestRequestWithResourceType(filter_.get(), 0, 1, 1126 net::URLRequestTestJob::test_url_2(), 1127 ResourceType::PREFETCH); // detachable type 1128 GlobalRequestID global_request_id(filter_->child_id(), 1); 1129 ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest( 1130 host_.GetURLRequest(global_request_id)); 1131 ASSERT_TRUE(info->detachable_handler()); 1132 info->detachable_handler()->set_cancel_delay( 1133 base::TimeDelta::FromMilliseconds(200)); 1134 base::MessageLoop::current()->RunUntilIdle(); 1135 1136 RendererCancelRequest(1); 1137 1138 // From the renderer's perspective, the request was cancelled. 1139 ResourceIPCAccumulator::ClassifiedMessages msgs; 1140 accum_.GetClassifiedMessages(&msgs); 1141 ASSERT_EQ(1U, msgs.size()); 1142 ASSERT_EQ(2U, msgs[0].size()); 1143 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type()); 1144 CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED); 1145 1146 // But it continues detached. 1147 EXPECT_EQ(1, host_.pending_requests()); 1148 EXPECT_TRUE(info->detachable_handler()->is_detached()); 1149 1150 // Wait until after the delay timer times out before we start processing any 1151 // messages. 1152 base::OneShotTimer<base::MessageLoop> timer; 1153 timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(210), 1154 base::MessageLoop::current(), &base::MessageLoop::QuitWhenIdle); 1155 base::MessageLoop::current()->Run(); 1156 1157 // The prefetch should be cancelled by now. 1158 EXPECT_EQ(0, host_.pending_requests()); 1159 EXPECT_EQ(1, network_delegate()->completed_requests()); 1160 EXPECT_EQ(1, network_delegate()->canceled_requests()); 1161 EXPECT_EQ(0, network_delegate()->error_count()); 1162} 1163 1164// If the filter has disappeared then detachable resources should continue to 1165// load. 1166TEST_F(ResourceDispatcherHostTest, DeletedFilterDetached) { 1167 // test_url_1's data is available synchronously, so use 2 and 3. 1168 ResourceHostMsg_Request request_prefetch = CreateResourceRequest( 1169 "GET", ResourceType::PREFETCH, net::URLRequestTestJob::test_url_2()); 1170 ResourceHostMsg_Request request_ping = CreateResourceRequest( 1171 "GET", ResourceType::PING, net::URLRequestTestJob::test_url_3()); 1172 1173 ResourceHostMsg_RequestResource msg_prefetch(0, 1, request_prefetch); 1174 host_.OnMessageReceived(msg_prefetch, filter_); 1175 ResourceHostMsg_RequestResource msg_ping(0, 2, request_ping); 1176 host_.OnMessageReceived(msg_ping, filter_); 1177 1178 // Remove the filter before processing the requests by simulating channel 1179 // closure. 1180 ResourceRequestInfoImpl* info_prefetch = ResourceRequestInfoImpl::ForRequest( 1181 host_.GetURLRequest(GlobalRequestID(filter_->child_id(), 1))); 1182 ResourceRequestInfoImpl* info_ping = ResourceRequestInfoImpl::ForRequest( 1183 host_.GetURLRequest(GlobalRequestID(filter_->child_id(), 2))); 1184 DCHECK_EQ(filter_.get(), info_prefetch->filter()); 1185 DCHECK_EQ(filter_.get(), info_ping->filter()); 1186 filter_->OnChannelClosing(); 1187 info_prefetch->filter_.reset(); 1188 info_ping->filter_.reset(); 1189 1190 // From the renderer's perspective, the requests were cancelled. 1191 ResourceIPCAccumulator::ClassifiedMessages msgs; 1192 accum_.GetClassifiedMessages(&msgs); 1193 ASSERT_EQ(2U, msgs.size()); 1194 CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED); 1195 CheckRequestCompleteErrorCode(msgs[1][0], net::ERR_ABORTED); 1196 1197 // But it continues detached. 1198 EXPECT_EQ(2, host_.pending_requests()); 1199 EXPECT_TRUE(info_prefetch->detachable_handler()->is_detached()); 1200 EXPECT_TRUE(info_ping->detachable_handler()->is_detached()); 1201 1202 KickOffRequest(); 1203 1204 // Make sure the requests weren't canceled early. 1205 EXPECT_EQ(2, host_.pending_requests()); 1206 1207 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1208 base::MessageLoop::current()->RunUntilIdle(); 1209 1210 EXPECT_EQ(0, host_.pending_requests()); 1211 EXPECT_EQ(2, network_delegate()->completed_requests()); 1212 EXPECT_EQ(0, network_delegate()->canceled_requests()); 1213 EXPECT_EQ(0, network_delegate()->error_count()); 1214} 1215 1216// If the filter has disappeared (original process dies) then detachable 1217// resources should continue to load, even when redirected. 1218TEST_F(ResourceDispatcherHostTest, DeletedFilterDetachedRedirect) { 1219 ResourceHostMsg_Request request = CreateResourceRequest( 1220 "GET", ResourceType::PREFETCH, 1221 net::URLRequestTestJob::test_url_redirect_to_url_2()); 1222 1223 ResourceHostMsg_RequestResource msg(0, 1, request); 1224 host_.OnMessageReceived(msg, filter_); 1225 1226 // Remove the filter before processing the request by simulating channel 1227 // closure. 1228 GlobalRequestID global_request_id(filter_->child_id(), 1); 1229 ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest( 1230 host_.GetURLRequest(global_request_id)); 1231 info->filter_->OnChannelClosing(); 1232 info->filter_.reset(); 1233 1234 // From the renderer's perspective, the request was cancelled. 1235 ResourceIPCAccumulator::ClassifiedMessages msgs; 1236 accum_.GetClassifiedMessages(&msgs); 1237 ASSERT_EQ(1U, msgs.size()); 1238 CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED); 1239 1240 // But it continues detached. 1241 EXPECT_EQ(1, host_.pending_requests()); 1242 EXPECT_TRUE(info->detachable_handler()->is_detached()); 1243 1244 // Verify no redirects before resetting the filter. 1245 net::URLRequest* url_request = host_.GetURLRequest(global_request_id); 1246 EXPECT_EQ(1u, url_request->url_chain().size()); 1247 KickOffRequest(); 1248 1249 // Verify that a redirect was followed. 1250 EXPECT_EQ(2u, url_request->url_chain().size()); 1251 1252 // Make sure the request wasn't canceled early. 1253 EXPECT_EQ(1, host_.pending_requests()); 1254 1255 // Finish up the request. 1256 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1257 base::MessageLoop::current()->RunUntilIdle(); 1258 1259 EXPECT_EQ(0, host_.pending_requests()); 1260 EXPECT_EQ(1, network_delegate()->completed_requests()); 1261 EXPECT_EQ(0, network_delegate()->canceled_requests()); 1262 EXPECT_EQ(0, network_delegate()->error_count()); 1263} 1264 1265TEST_F(ResourceDispatcherHostTest, CancelWhileStartIsDeferred) { 1266 bool was_deleted = false; 1267 1268 // Arrange to have requests deferred before starting. 1269 TestResourceDispatcherHostDelegate delegate; 1270 delegate.set_flags(DEFER_STARTING_REQUEST); 1271 delegate.set_url_request_user_data(new TestUserData(&was_deleted)); 1272 host_.SetDelegate(&delegate); 1273 1274 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1275 // We cancel from the renderer because all non-renderer cancels delete 1276 // the request synchronously. 1277 RendererCancelRequest(1); 1278 1279 // Our TestResourceThrottle should not have been deleted yet. This is to 1280 // ensure that destruction of the URLRequest happens asynchronously to 1281 // calling CancelRequest. 1282 EXPECT_FALSE(was_deleted); 1283 1284 base::MessageLoop::current()->RunUntilIdle(); 1285 1286 EXPECT_TRUE(was_deleted); 1287} 1288 1289TEST_F(ResourceDispatcherHostTest, DetachWhileStartIsDeferred) { 1290 bool was_deleted = false; 1291 1292 // Arrange to have requests deferred before starting. 1293 TestResourceDispatcherHostDelegate delegate; 1294 delegate.set_flags(DEFER_STARTING_REQUEST); 1295 delegate.set_url_request_user_data(new TestUserData(&was_deleted)); 1296 host_.SetDelegate(&delegate); 1297 1298 MakeTestRequestWithResourceType(filter_.get(), 0, 1, 1299 net::URLRequestTestJob::test_url_1(), 1300 ResourceType::PREFETCH); // detachable type 1301 // Cancel request must come from the renderer for a detachable resource to 1302 // detach. 1303 RendererCancelRequest(1); 1304 1305 // Even after driving the event loop, the request has not been deleted. 1306 EXPECT_FALSE(was_deleted); 1307 1308 // However, it is still throttled because the defer happened above the 1309 // DetachableResourceHandler. 1310 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1311 base::MessageLoop::current()->RunUntilIdle(); 1312 EXPECT_FALSE(was_deleted); 1313 1314 // Resume the request. 1315 GenericResourceThrottle* throttle = 1316 GenericResourceThrottle::active_throttle(); 1317 ASSERT_TRUE(throttle); 1318 throttle->Resume(); 1319 1320 // Now, the request completes. 1321 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1322 base::MessageLoop::current()->RunUntilIdle(); 1323 EXPECT_TRUE(was_deleted); 1324 EXPECT_EQ(1, network_delegate()->completed_requests()); 1325 EXPECT_EQ(0, network_delegate()->canceled_requests()); 1326 EXPECT_EQ(0, network_delegate()->error_count()); 1327} 1328 1329// Tests if cancel is called in ResourceThrottle::WillStartRequest, then the 1330// URLRequest will not be started. 1331TEST_F(ResourceDispatcherHostTest, CancelInResourceThrottleWillStartRequest) { 1332 TestResourceDispatcherHostDelegate delegate; 1333 delegate.set_flags(CANCEL_BEFORE_START); 1334 host_.SetDelegate(&delegate); 1335 1336 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1337 1338 // flush all the pending requests 1339 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1340 base::MessageLoop::current()->RunUntilIdle(); 1341 1342 ResourceIPCAccumulator::ClassifiedMessages msgs; 1343 accum_.GetClassifiedMessages(&msgs); 1344 1345 // Check that request got canceled. 1346 ASSERT_EQ(1U, msgs[0].size()); 1347 CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ABORTED); 1348 1349 // Make sure URLRequest is never started. 1350 EXPECT_EQ(0, job_factory_->url_request_jobs_created_count()); 1351} 1352 1353TEST_F(ResourceDispatcherHostTest, PausedStartError) { 1354 // Arrange to have requests deferred before processing response headers. 1355 TestResourceDispatcherHostDelegate delegate; 1356 delegate.set_flags(DEFER_PROCESSING_RESPONSE); 1357 host_.SetDelegate(&delegate); 1358 1359 job_factory_->SetDelayedStartJobGeneration(true); 1360 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_error()); 1361 CompleteStartRequest(1); 1362 1363 // flush all the pending requests 1364 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1365 base::MessageLoop::current()->RunUntilIdle(); 1366 1367 EXPECT_EQ(0, host_.pending_requests()); 1368} 1369 1370// Test the OnBeforeNetworkStart throttle. 1371TEST_F(ResourceDispatcherHostTest, ThrottleNetworkStart) { 1372 // Arrange to have requests deferred before processing response headers. 1373 TestResourceDispatcherHostDelegate delegate; 1374 delegate.set_flags(DEFER_NETWORK_START); 1375 host_.SetDelegate(&delegate); 1376 1377 job_factory_->SetNetworkStartNotificationJobGeneration(true); 1378 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_2()); 1379 1380 // Should have deferred for network start. 1381 GenericResourceThrottle* first_throttle = 1382 GenericResourceThrottle::active_throttle(); 1383 ASSERT_TRUE(first_throttle); 1384 EXPECT_EQ(0, network_delegate()->completed_requests()); 1385 EXPECT_EQ(1, host_.pending_requests()); 1386 1387 first_throttle->Resume(); 1388 1389 // Flush all the pending requests. 1390 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1391 base::MessageLoop::current()->RunUntilIdle(); 1392 1393 EXPECT_EQ(1, network_delegate()->completed_requests()); 1394 EXPECT_EQ(0, host_.pending_requests()); 1395} 1396 1397TEST_F(ResourceDispatcherHostTest, ThrottleAndResumeTwice) { 1398 // Arrange to have requests deferred before starting. 1399 TestResourceDispatcherHostDelegate delegate; 1400 delegate.set_flags(DEFER_STARTING_REQUEST); 1401 delegate.set_create_two_throttles(true); 1402 host_.SetDelegate(&delegate); 1403 1404 // Make sure the first throttle blocked the request, and then resume. 1405 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1406 GenericResourceThrottle* first_throttle = 1407 GenericResourceThrottle::active_throttle(); 1408 ASSERT_TRUE(first_throttle); 1409 first_throttle->Resume(); 1410 1411 // Make sure the second throttle blocked the request, and then resume. 1412 ASSERT_TRUE(GenericResourceThrottle::active_throttle()); 1413 ASSERT_NE(first_throttle, GenericResourceThrottle::active_throttle()); 1414 GenericResourceThrottle::active_throttle()->Resume(); 1415 1416 ASSERT_FALSE(GenericResourceThrottle::active_throttle()); 1417 1418 // The request is started asynchronously. 1419 base::MessageLoop::current()->RunUntilIdle(); 1420 1421 // Flush all the pending requests. 1422 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1423 1424 EXPECT_EQ(0, host_.pending_requests()); 1425 1426 // Make sure the request completed successfully. 1427 ResourceIPCAccumulator::ClassifiedMessages msgs; 1428 accum_.GetClassifiedMessages(&msgs); 1429 ASSERT_EQ(1U, msgs.size()); 1430 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1431} 1432 1433 1434// Tests that the delegate can cancel a request and provide a error code. 1435TEST_F(ResourceDispatcherHostTest, CancelInDelegate) { 1436 TestResourceDispatcherHostDelegate delegate; 1437 delegate.set_flags(CANCEL_BEFORE_START); 1438 delegate.set_error_code_for_cancellation(net::ERR_ACCESS_DENIED); 1439 host_.SetDelegate(&delegate); 1440 1441 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1442 // The request will get cancelled by the throttle. 1443 1444 // flush all the pending requests 1445 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1446 base::MessageLoop::current()->RunUntilIdle(); 1447 1448 ResourceIPCAccumulator::ClassifiedMessages msgs; 1449 accum_.GetClassifiedMessages(&msgs); 1450 1451 // Check the cancellation 1452 ASSERT_EQ(1U, msgs.size()); 1453 ASSERT_EQ(1U, msgs[0].size()); 1454 1455 CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_ACCESS_DENIED); 1456} 1457 1458// Tests CancelRequestsForProcess 1459TEST_F(ResourceDispatcherHostTest, TestProcessCancel) { 1460 scoped_refptr<TestFilter> test_filter = new TestFilter( 1461 browser_context_->GetResourceContext()); 1462 child_ids_.insert(test_filter->child_id()); 1463 1464 // request 1 goes to the test delegate 1465 ResourceHostMsg_Request request = CreateResourceRequest( 1466 "GET", ResourceType::SUB_RESOURCE, net::URLRequestTestJob::test_url_1()); 1467 1468 MakeTestRequestWithResourceType(test_filter.get(), 0, 1, 1469 net::URLRequestTestJob::test_url_1(), 1470 ResourceType::SUB_RESOURCE); 1471 1472 // request 2 goes to us 1473 MakeTestRequest(0, 2, net::URLRequestTestJob::test_url_2()); 1474 1475 // request 3 goes to the test delegate 1476 MakeTestRequestWithResourceType(test_filter.get(), 0, 3, 1477 net::URLRequestTestJob::test_url_3(), 1478 ResourceType::SUB_RESOURCE); 1479 1480 // request 4 goes to us 1481 MakeTestRequestWithResourceType(filter_.get(), 0, 4, 1482 net::URLRequestTestJob::test_url_4(), 1483 ResourceType::PREFETCH); // detachable type 1484 1485 1486 // Make sure all requests have finished stage one. test_url_1 will have 1487 // finished. 1488 base::MessageLoop::current()->RunUntilIdle(); 1489 1490 // TODO(mbelshe): 1491 // Now that the async IO path is in place, the IO always completes on the 1492 // initial call; so the requests have already completed. This basically 1493 // breaks the whole test. 1494 //EXPECT_EQ(3, host_.pending_requests()); 1495 1496 // Process test_url_2 and test_url_3 for one level so one callback is called. 1497 // We'll cancel test_url_4 (detachable) before processing it to verify that it 1498 // delays the cancel. 1499 for (int i = 0; i < 2; i++) 1500 EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage()); 1501 1502 // Cancel the requests to the test process. 1503 host_.CancelRequestsForProcess(filter_->child_id()); 1504 test_filter->set_canceled(true); 1505 1506 // The requests should all be cancelled, except request 4, which is detached. 1507 EXPECT_EQ(1, host_.pending_requests()); 1508 GlobalRequestID global_request_id(filter_->child_id(), 4); 1509 ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest( 1510 host_.GetURLRequest(global_request_id)); 1511 ASSERT_TRUE(info->detachable_handler()->is_detached()); 1512 1513 // Flush all the pending requests. 1514 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1515 1516 EXPECT_EQ(0, host_.pending_requests()); 1517 1518 // The test delegate should not have gotten any messages after being canceled. 1519 ASSERT_EQ(0, test_filter->received_after_canceled()); 1520 1521 // There should be two results. 1522 ResourceIPCAccumulator::ClassifiedMessages msgs; 1523 accum_.GetClassifiedMessages(&msgs); 1524 ASSERT_EQ(2U, msgs.size()); 1525 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_2()); 1526 // The detachable request was cancelled by the renderer before it 1527 // finished. From the perspective of the renderer, it should have cancelled. 1528 ASSERT_EQ(2U, msgs[1].size()); 1529 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[1][0].type()); 1530 CheckRequestCompleteErrorCode(msgs[1][1], net::ERR_ABORTED); 1531 // But it completed anyway. For the network stack, no requests were canceled. 1532 EXPECT_EQ(4, network_delegate()->completed_requests()); 1533 EXPECT_EQ(0, network_delegate()->canceled_requests()); 1534 EXPECT_EQ(0, network_delegate()->error_count()); 1535} 1536 1537TEST_F(ResourceDispatcherHostTest, TestProcessCancelDetachedTimesOut) { 1538 MakeTestRequestWithResourceType(filter_.get(), 0, 1, 1539 net::URLRequestTestJob::test_url_4(), 1540 ResourceType::PREFETCH); // detachable type 1541 GlobalRequestID global_request_id(filter_->child_id(), 1); 1542 ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest( 1543 host_.GetURLRequest(global_request_id)); 1544 ASSERT_TRUE(info->detachable_handler()); 1545 info->detachable_handler()->set_cancel_delay( 1546 base::TimeDelta::FromMilliseconds(200)); 1547 base::MessageLoop::current()->RunUntilIdle(); 1548 1549 // Cancel the requests to the test process. 1550 host_.CancelRequestsForProcess(filter_->child_id()); 1551 EXPECT_EQ(1, host_.pending_requests()); 1552 1553 // Wait until after the delay timer times out before we start processing any 1554 // messages. 1555 base::OneShotTimer<base::MessageLoop> timer; 1556 timer.Start(FROM_HERE, base::TimeDelta::FromMilliseconds(210), 1557 base::MessageLoop::current(), &base::MessageLoop::QuitWhenIdle); 1558 base::MessageLoop::current()->Run(); 1559 1560 // The prefetch should be cancelled by now. 1561 EXPECT_EQ(0, host_.pending_requests()); 1562 1563 // In case any messages are still to be processed. 1564 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1565 base::MessageLoop::current()->RunUntilIdle(); 1566 1567 ResourceIPCAccumulator::ClassifiedMessages msgs; 1568 accum_.GetClassifiedMessages(&msgs); 1569 1570 ASSERT_EQ(1U, msgs.size()); 1571 1572 // The request should have cancelled. 1573 ASSERT_EQ(2U, msgs[0].size()); 1574 ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type()); 1575 CheckRequestCompleteErrorCode(msgs[0][1], net::ERR_ABORTED); 1576 // And not run to completion. 1577 EXPECT_EQ(1, network_delegate()->completed_requests()); 1578 EXPECT_EQ(1, network_delegate()->canceled_requests()); 1579 EXPECT_EQ(0, network_delegate()->error_count()); 1580} 1581 1582// Tests blocking and resuming requests. 1583TEST_F(ResourceDispatcherHostTest, TestBlockingResumingRequests) { 1584 host_.BlockRequestsForRoute(filter_->child_id(), 1); 1585 host_.BlockRequestsForRoute(filter_->child_id(), 2); 1586 host_.BlockRequestsForRoute(filter_->child_id(), 3); 1587 1588 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1589 MakeTestRequest(1, 2, net::URLRequestTestJob::test_url_2()); 1590 MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3()); 1591 MakeTestRequest(1, 4, net::URLRequestTestJob::test_url_1()); 1592 MakeTestRequest(2, 5, net::URLRequestTestJob::test_url_2()); 1593 MakeTestRequest(3, 6, net::URLRequestTestJob::test_url_3()); 1594 1595 // Flush all the pending requests 1596 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1597 1598 // Sort out all the messages we saw by request 1599 ResourceIPCAccumulator::ClassifiedMessages msgs; 1600 accum_.GetClassifiedMessages(&msgs); 1601 1602 // All requests but the 2 for the RVH 0 should have been blocked. 1603 ASSERT_EQ(2U, msgs.size()); 1604 1605 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1606 CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3()); 1607 1608 // Resume requests for RVH 1 and flush pending requests. 1609 host_.ResumeBlockedRequestsForRoute(filter_->child_id(), 1); 1610 KickOffRequest(); 1611 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1612 1613 msgs.clear(); 1614 accum_.GetClassifiedMessages(&msgs); 1615 ASSERT_EQ(2U, msgs.size()); 1616 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_2()); 1617 CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_1()); 1618 1619 // Test that new requests are not blocked for RVH 1. 1620 MakeTestRequest(1, 7, net::URLRequestTestJob::test_url_1()); 1621 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1622 msgs.clear(); 1623 accum_.GetClassifiedMessages(&msgs); 1624 ASSERT_EQ(1U, msgs.size()); 1625 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1626 1627 // Now resumes requests for all RVH (2 and 3). 1628 host_.ResumeBlockedRequestsForRoute(filter_->child_id(), 2); 1629 host_.ResumeBlockedRequestsForRoute(filter_->child_id(), 3); 1630 KickOffRequest(); 1631 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1632 1633 msgs.clear(); 1634 accum_.GetClassifiedMessages(&msgs); 1635 ASSERT_EQ(2U, msgs.size()); 1636 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_2()); 1637 CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3()); 1638} 1639 1640// Tests blocking and canceling requests. 1641TEST_F(ResourceDispatcherHostTest, TestBlockingCancelingRequests) { 1642 host_.BlockRequestsForRoute(filter_->child_id(), 1); 1643 1644 MakeTestRequest(0, 1, net::URLRequestTestJob::test_url_1()); 1645 MakeTestRequest(1, 2, net::URLRequestTestJob::test_url_2()); 1646 MakeTestRequest(0, 3, net::URLRequestTestJob::test_url_3()); 1647 MakeTestRequest(1, 4, net::URLRequestTestJob::test_url_1()); 1648 // Blocked detachable resources should not delay cancellation. 1649 MakeTestRequestWithResourceType(filter_.get(), 1, 5, 1650 net::URLRequestTestJob::test_url_4(), 1651 ResourceType::PREFETCH); // detachable type 1652 1653 // Flush all the pending requests. 1654 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1655 1656 // Sort out all the messages we saw by request. 1657 ResourceIPCAccumulator::ClassifiedMessages msgs; 1658 accum_.GetClassifiedMessages(&msgs); 1659 1660 // The 2 requests for the RVH 0 should have been processed. 1661 ASSERT_EQ(2U, msgs.size()); 1662 1663 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1664 CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3()); 1665 1666 // Cancel requests for RVH 1. 1667 host_.CancelBlockedRequestsForRoute(filter_->child_id(), 1); 1668 KickOffRequest(); 1669 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1670 1671 msgs.clear(); 1672 accum_.GetClassifiedMessages(&msgs); 1673 ASSERT_EQ(0U, msgs.size()); 1674} 1675 1676// Tests that blocked requests are canceled if their associated process dies. 1677TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsProcessDies) { 1678 // This second filter is used to emulate a second process. 1679 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 1680 1681 host_.BlockRequestsForRoute(second_filter->child_id(), 0); 1682 1683 MakeTestRequestWithResourceType(filter_.get(), 0, 1, 1684 net::URLRequestTestJob::test_url_1(), 1685 ResourceType::SUB_RESOURCE); 1686 MakeTestRequestWithResourceType(second_filter.get(), 0, 2, 1687 net::URLRequestTestJob::test_url_2(), 1688 ResourceType::SUB_RESOURCE); 1689 MakeTestRequestWithResourceType(filter_.get(), 0, 3, 1690 net::URLRequestTestJob::test_url_3(), 1691 ResourceType::SUB_RESOURCE); 1692 MakeTestRequestWithResourceType(second_filter.get(), 0, 4, 1693 net::URLRequestTestJob::test_url_1(), 1694 ResourceType::SUB_RESOURCE); 1695 MakeTestRequestWithResourceType(second_filter.get(), 0, 5, 1696 net::URLRequestTestJob::test_url_4(), 1697 ResourceType::PREFETCH); // detachable type 1698 1699 // Simulate process death. 1700 host_.CancelRequestsForProcess(second_filter->child_id()); 1701 1702 // Flush all the pending requests. 1703 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1704 1705 // Sort out all the messages we saw by request. 1706 ResourceIPCAccumulator::ClassifiedMessages msgs; 1707 accum_.GetClassifiedMessages(&msgs); 1708 1709 // The 2 requests for the RVH 0 should have been processed. Note that 1710 // blocked detachable requests are canceled without delay. 1711 ASSERT_EQ(2U, msgs.size()); 1712 1713 CheckSuccessfulRequest(msgs[0], net::URLRequestTestJob::test_data_1()); 1714 CheckSuccessfulRequest(msgs[1], net::URLRequestTestJob::test_data_3()); 1715 1716 EXPECT_TRUE(host_.blocked_loaders_map_.empty()); 1717} 1718 1719// Tests that blocked requests don't leak when the ResourceDispatcherHost goes 1720// away. Note that we rely on Purify for finding the leaks if any. 1721// If this test turns the Purify bot red, check the ResourceDispatcherHost 1722// destructor to make sure the blocked requests are deleted. 1723TEST_F(ResourceDispatcherHostTest, TestBlockedRequestsDontLeak) { 1724 // This second filter is used to emulate a second process. 1725 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 1726 1727 host_.BlockRequestsForRoute(filter_->child_id(), 1); 1728 host_.BlockRequestsForRoute(filter_->child_id(), 2); 1729 host_.BlockRequestsForRoute(second_filter->child_id(), 1); 1730 1731 MakeTestRequestWithResourceType(filter_.get(), 0, 1, 1732 net::URLRequestTestJob::test_url_1(), 1733 ResourceType::SUB_RESOURCE); 1734 MakeTestRequestWithResourceType(filter_.get(), 1, 2, 1735 net::URLRequestTestJob::test_url_2(), 1736 ResourceType::SUB_RESOURCE); 1737 MakeTestRequestWithResourceType(filter_.get(), 0, 3, 1738 net::URLRequestTestJob::test_url_3(), 1739 ResourceType::SUB_RESOURCE); 1740 MakeTestRequestWithResourceType(second_filter.get(), 1, 4, 1741 net::URLRequestTestJob::test_url_1(), 1742 ResourceType::SUB_RESOURCE); 1743 MakeTestRequestWithResourceType(filter_.get(), 2, 5, 1744 net::URLRequestTestJob::test_url_2(), 1745 ResourceType::SUB_RESOURCE); 1746 MakeTestRequestWithResourceType(filter_.get(), 2, 6, 1747 net::URLRequestTestJob::test_url_3(), 1748 ResourceType::SUB_RESOURCE); 1749 MakeTestRequestWithResourceType(filter_.get(), 0, 7, 1750 net::URLRequestTestJob::test_url_4(), 1751 ResourceType::PREFETCH); // detachable type 1752 MakeTestRequestWithResourceType(second_filter.get(), 1, 8, 1753 net::URLRequestTestJob::test_url_4(), 1754 ResourceType::PREFETCH); // detachable type 1755 1756 host_.CancelRequestsForProcess(filter_->child_id()); 1757 host_.CancelRequestsForProcess(second_filter->child_id()); 1758 1759 // Flush all the pending requests. 1760 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1761} 1762 1763// Test the private helper method "CalculateApproximateMemoryCost()". 1764TEST_F(ResourceDispatcherHostTest, CalculateApproximateMemoryCost) { 1765 net::URLRequestContext context; 1766 net::URLRequest req( 1767 GURL("http://www.google.com"), net::DEFAULT_PRIORITY, NULL, &context); 1768 EXPECT_EQ(4427, 1769 ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(&req)); 1770 1771 // Add 9 bytes of referrer. 1772 req.SetReferrer("123456789"); 1773 EXPECT_EQ(4436, 1774 ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(&req)); 1775 1776 // Add 33 bytes of upload content. 1777 std::string upload_content; 1778 upload_content.resize(33); 1779 std::fill(upload_content.begin(), upload_content.end(), 'x'); 1780 scoped_ptr<net::UploadElementReader> reader(new net::UploadBytesElementReader( 1781 upload_content.data(), upload_content.size())); 1782 req.set_upload(make_scoped_ptr( 1783 net::UploadDataStream::CreateWithReader(reader.Pass(), 0))); 1784 1785 // Since the upload throttling is disabled, this has no effect on the cost. 1786 EXPECT_EQ(4436, 1787 ResourceDispatcherHostImpl::CalculateApproximateMemoryCost(&req)); 1788} 1789 1790// Test that too much memory for outstanding requests for a particular 1791// render_process_host_id causes requests to fail. 1792TEST_F(ResourceDispatcherHostTest, TooMuchOutstandingRequestsMemory) { 1793 // Expected cost of each request as measured by 1794 // ResourceDispatcherHost::CalculateApproximateMemoryCost(). 1795 int kMemoryCostOfTest2Req = 1796 ResourceDispatcherHostImpl::kAvgBytesPerOutstandingRequest + 1797 std::string("GET").size() + 1798 net::URLRequestTestJob::test_url_2().spec().size(); 1799 1800 // Tighten the bound on the ResourceDispatcherHost, to speed things up. 1801 int kMaxCostPerProcess = 440000; 1802 host_.set_max_outstanding_requests_cost_per_process(kMaxCostPerProcess); 1803 1804 // Determine how many instance of test_url_2() we can request before 1805 // throttling kicks in. 1806 size_t kMaxRequests = kMaxCostPerProcess / kMemoryCostOfTest2Req; 1807 1808 // This second filter is used to emulate a second process. 1809 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 1810 1811 // Saturate the number of outstanding requests for our process. 1812 for (size_t i = 0; i < kMaxRequests; ++i) { 1813 MakeTestRequestWithResourceType(filter_.get(), 0, i + 1, 1814 net::URLRequestTestJob::test_url_2(), 1815 ResourceType::SUB_RESOURCE); 1816 } 1817 1818 // Issue two more requests for our process -- these should fail immediately. 1819 MakeTestRequestWithResourceType(filter_.get(), 0, kMaxRequests + 1, 1820 net::URLRequestTestJob::test_url_2(), 1821 ResourceType::SUB_RESOURCE); 1822 MakeTestRequestWithResourceType(filter_.get(), 0, kMaxRequests + 2, 1823 net::URLRequestTestJob::test_url_2(), 1824 ResourceType::SUB_RESOURCE); 1825 1826 // Issue two requests for the second process -- these should succeed since 1827 // it is just process 0 that is saturated. 1828 MakeTestRequestWithResourceType(second_filter.get(), 0, kMaxRequests + 3, 1829 net::URLRequestTestJob::test_url_2(), 1830 ResourceType::SUB_RESOURCE); 1831 MakeTestRequestWithResourceType(second_filter.get(), 0, kMaxRequests + 4, 1832 net::URLRequestTestJob::test_url_2(), 1833 ResourceType::SUB_RESOURCE); 1834 1835 // Flush all the pending requests. 1836 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1837 base::MessageLoop::current()->RunUntilIdle(); 1838 1839 // Sorts out all the messages we saw by request. 1840 ResourceIPCAccumulator::ClassifiedMessages msgs; 1841 accum_.GetClassifiedMessages(&msgs); 1842 1843 // We issued (kMaxRequests + 4) total requests. 1844 ASSERT_EQ(kMaxRequests + 4, msgs.size()); 1845 1846 // Check that the first kMaxRequests succeeded. 1847 for (size_t i = 0; i < kMaxRequests; ++i) 1848 CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2()); 1849 1850 // Check that the subsequent two requests (kMaxRequests + 1) and 1851 // (kMaxRequests + 2) were failed, since the per-process bound was reached. 1852 for (int i = 0; i < 2; ++i) { 1853 // Should have sent a single RequestComplete message. 1854 int index = kMaxRequests + i; 1855 CheckFailedRequest(msgs[index], net::URLRequestTestJob::test_data_2(), 1856 net::ERR_INSUFFICIENT_RESOURCES); 1857 } 1858 1859 // The final 2 requests should have succeeded. 1860 CheckSuccessfulRequest(msgs[kMaxRequests + 2], 1861 net::URLRequestTestJob::test_data_2()); 1862 CheckSuccessfulRequest(msgs[kMaxRequests + 3], 1863 net::URLRequestTestJob::test_data_2()); 1864} 1865 1866// Test that when too many requests are outstanding for a particular 1867// render_process_host_id, any subsequent request from it fails. Also verify 1868// that the global limit is honored. 1869TEST_F(ResourceDispatcherHostTest, TooManyOutstandingRequests) { 1870 // Tighten the bound on the ResourceDispatcherHost, to speed things up. 1871 const size_t kMaxRequestsPerProcess = 2; 1872 host_.set_max_num_in_flight_requests_per_process(kMaxRequestsPerProcess); 1873 const size_t kMaxRequests = 3; 1874 host_.set_max_num_in_flight_requests(kMaxRequests); 1875 1876 // Needed to emulate additional processes. 1877 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 1878 scoped_refptr<ForwardingFilter> third_filter = MakeForwardingFilter(); 1879 1880 // Saturate the number of outstanding requests for our process. 1881 for (size_t i = 0; i < kMaxRequestsPerProcess; ++i) { 1882 MakeTestRequestWithResourceType(filter_.get(), 0, i + 1, 1883 net::URLRequestTestJob::test_url_2(), 1884 ResourceType::SUB_RESOURCE); 1885 } 1886 1887 // Issue another request for our process -- this should fail immediately. 1888 MakeTestRequestWithResourceType(filter_.get(), 0, kMaxRequestsPerProcess + 1, 1889 net::URLRequestTestJob::test_url_2(), 1890 ResourceType::SUB_RESOURCE); 1891 1892 // Issue a request for the second process -- this should succeed, because it 1893 // is just process 0 that is saturated. 1894 MakeTestRequestWithResourceType( 1895 second_filter.get(), 0, kMaxRequestsPerProcess + 2, 1896 net::URLRequestTestJob::test_url_2(), ResourceType::SUB_RESOURCE); 1897 1898 // Issue a request for the third process -- this should fail, because the 1899 // global limit has been reached. 1900 MakeTestRequestWithResourceType( 1901 third_filter.get(), 0, kMaxRequestsPerProcess + 3, 1902 net::URLRequestTestJob::test_url_2(), ResourceType::SUB_RESOURCE); 1903 1904 // Flush all the pending requests. 1905 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1906 base::MessageLoop::current()->RunUntilIdle(); 1907 1908 // Sorts out all the messages we saw by request. 1909 ResourceIPCAccumulator::ClassifiedMessages msgs; 1910 accum_.GetClassifiedMessages(&msgs); 1911 1912 // The processes issued the following requests: 1913 // #1 issued kMaxRequestsPerProcess that passed + 1 that failed 1914 // #2 issued 1 request that passed 1915 // #3 issued 1 request that failed 1916 ASSERT_EQ((kMaxRequestsPerProcess + 1) + 1 + 1, msgs.size()); 1917 1918 for (size_t i = 0; i < kMaxRequestsPerProcess; ++i) 1919 CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2()); 1920 1921 CheckFailedRequest(msgs[kMaxRequestsPerProcess + 0], 1922 net::URLRequestTestJob::test_data_2(), 1923 net::ERR_INSUFFICIENT_RESOURCES); 1924 CheckSuccessfulRequest(msgs[kMaxRequestsPerProcess + 1], 1925 net::URLRequestTestJob::test_data_2()); 1926 CheckFailedRequest(msgs[kMaxRequestsPerProcess + 2], 1927 net::URLRequestTestJob::test_data_2(), 1928 net::ERR_INSUFFICIENT_RESOURCES); 1929} 1930 1931// Tests that we sniff the mime type for a simple request. 1932TEST_F(ResourceDispatcherHostTest, MimeSniffed) { 1933 std::string raw_headers("HTTP/1.1 200 OK\n\n"); 1934 std::string response_data("<html><title>Test One</title></html>"); 1935 SetResponse(raw_headers, response_data); 1936 1937 HandleScheme("http"); 1938 MakeTestRequest(0, 1, GURL("http:bla")); 1939 1940 // Flush all pending requests. 1941 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1942 1943 // Sorts out all the messages we saw by request. 1944 ResourceIPCAccumulator::ClassifiedMessages msgs; 1945 accum_.GetClassifiedMessages(&msgs); 1946 ASSERT_EQ(1U, msgs.size()); 1947 1948 ResourceResponseHead response_head; 1949 GetResponseHead(msgs[0], &response_head); 1950 ASSERT_EQ("text/html", response_head.mime_type); 1951} 1952 1953// Tests that we don't sniff the mime type when the server provides one. 1954TEST_F(ResourceDispatcherHostTest, MimeNotSniffed) { 1955 std::string raw_headers("HTTP/1.1 200 OK\n" 1956 "Content-type: image/jpeg\n\n"); 1957 std::string response_data("<html><title>Test One</title></html>"); 1958 SetResponse(raw_headers, response_data); 1959 1960 HandleScheme("http"); 1961 MakeTestRequest(0, 1, GURL("http:bla")); 1962 1963 // Flush all pending requests. 1964 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1965 1966 // Sorts out all the messages we saw by request. 1967 ResourceIPCAccumulator::ClassifiedMessages msgs; 1968 accum_.GetClassifiedMessages(&msgs); 1969 ASSERT_EQ(1U, msgs.size()); 1970 1971 ResourceResponseHead response_head; 1972 GetResponseHead(msgs[0], &response_head); 1973 ASSERT_EQ("image/jpeg", response_head.mime_type); 1974} 1975 1976// Tests that we don't sniff the mime type when there is no message body. 1977TEST_F(ResourceDispatcherHostTest, MimeNotSniffed2) { 1978 SetResponse("HTTP/1.1 304 Not Modified\n\n"); 1979 1980 HandleScheme("http"); 1981 MakeTestRequest(0, 1, GURL("http:bla")); 1982 1983 // Flush all pending requests. 1984 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 1985 1986 // Sorts out all the messages we saw by request. 1987 ResourceIPCAccumulator::ClassifiedMessages msgs; 1988 accum_.GetClassifiedMessages(&msgs); 1989 ASSERT_EQ(1U, msgs.size()); 1990 1991 ResourceResponseHead response_head; 1992 GetResponseHead(msgs[0], &response_head); 1993 ASSERT_EQ("", response_head.mime_type); 1994} 1995 1996TEST_F(ResourceDispatcherHostTest, MimeSniff204) { 1997 SetResponse("HTTP/1.1 204 No Content\n\n"); 1998 1999 HandleScheme("http"); 2000 MakeTestRequest(0, 1, GURL("http:bla")); 2001 2002 // Flush all pending requests. 2003 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2004 2005 // Sorts out all the messages we saw by request. 2006 ResourceIPCAccumulator::ClassifiedMessages msgs; 2007 accum_.GetClassifiedMessages(&msgs); 2008 ASSERT_EQ(1U, msgs.size()); 2009 2010 ResourceResponseHead response_head; 2011 GetResponseHead(msgs[0], &response_head); 2012 ASSERT_EQ("text/plain", response_head.mime_type); 2013} 2014 2015TEST_F(ResourceDispatcherHostTest, MimeSniffEmpty) { 2016 SetResponse("HTTP/1.1 200 OK\n\n"); 2017 2018 HandleScheme("http"); 2019 MakeTestRequest(0, 1, GURL("http:bla")); 2020 2021 // Flush all pending requests. 2022 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2023 2024 // Sorts out all the messages we saw by request. 2025 ResourceIPCAccumulator::ClassifiedMessages msgs; 2026 accum_.GetClassifiedMessages(&msgs); 2027 ASSERT_EQ(1U, msgs.size()); 2028 2029 ResourceResponseHead response_head; 2030 GetResponseHead(msgs[0], &response_head); 2031 ASSERT_EQ("text/plain", response_head.mime_type); 2032} 2033 2034// Tests for crbug.com/31266 (Non-2xx + application/octet-stream). 2035TEST_F(ResourceDispatcherHostTest, ForbiddenDownload) { 2036 std::string raw_headers("HTTP/1.1 403 Forbidden\n" 2037 "Content-disposition: attachment; filename=blah\n" 2038 "Content-type: application/octet-stream\n\n"); 2039 std::string response_data("<html><title>Test One</title></html>"); 2040 SetResponse(raw_headers, response_data); 2041 2042 HandleScheme("http"); 2043 2044 // Only MAIN_FRAMEs can trigger a download. 2045 MakeTestRequestWithResourceType(filter_.get(), 0, 1, GURL("http:bla"), 2046 ResourceType::MAIN_FRAME); 2047 2048 // Flush all pending requests. 2049 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2050 base::MessageLoop::current()->RunUntilIdle(); 2051 2052 // Sorts out all the messages we saw by request. 2053 ResourceIPCAccumulator::ClassifiedMessages msgs; 2054 accum_.GetClassifiedMessages(&msgs); 2055 2056 // We should have gotten one RequestComplete message. 2057 ASSERT_EQ(1U, msgs.size()); 2058 ASSERT_EQ(1U, msgs[0].size()); 2059 EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type()); 2060 2061 // The RequestComplete message should have had the error code of 2062 // ERR_INVALID_RESPONSE. 2063 CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_INVALID_RESPONSE); 2064} 2065 2066// Test for http://crbug.com/76202 . We don't want to destroy a 2067// download request prematurely when processing a cancellation from 2068// the renderer. 2069TEST_F(ResourceDispatcherHostTest, IgnoreCancelForDownloads) { 2070 EXPECT_EQ(0, host_.pending_requests()); 2071 2072 int render_view_id = 0; 2073 int request_id = 1; 2074 2075 std::string raw_headers("HTTP\n" 2076 "Content-disposition: attachment; filename=foo\n\n"); 2077 std::string response_data("01234567890123456789\x01foobar"); 2078 2079 // Get past sniffing metrics in the BufferedResourceHandler. Note that 2080 // if we don't get past the sniffing metrics, the result will be that 2081 // the BufferedResourceHandler won't have figured out that it's a download, 2082 // won't have constructed a DownloadResourceHandler, and and the request 2083 // will be successfully canceled below, failing the test. 2084 response_data.resize(1025, ' '); 2085 2086 SetResponse(raw_headers, response_data); 2087 job_factory_->SetDelayedCompleteJobGeneration(true); 2088 HandleScheme("http"); 2089 2090 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2091 GURL("http://example.com/blah"), 2092 ResourceType::MAIN_FRAME); 2093 // Return some data so that the request is identified as a download 2094 // and the proper resource handlers are created. 2095 EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage()); 2096 2097 // And now simulate a cancellation coming from the renderer. 2098 ResourceHostMsg_CancelRequest msg(request_id); 2099 host_.OnMessageReceived(msg, filter_.get()); 2100 2101 // Since the request had already started processing as a download, 2102 // the cancellation above should have been ignored and the request 2103 // should still be alive. 2104 EXPECT_EQ(1, host_.pending_requests()); 2105 2106 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2107} 2108 2109TEST_F(ResourceDispatcherHostTest, CancelRequestsForContext) { 2110 EXPECT_EQ(0, host_.pending_requests()); 2111 2112 int render_view_id = 0; 2113 int request_id = 1; 2114 2115 std::string raw_headers("HTTP\n" 2116 "Content-disposition: attachment; filename=foo\n\n"); 2117 std::string response_data("01234567890123456789\x01foobar"); 2118 // Get past sniffing metrics. 2119 response_data.resize(1025, ' '); 2120 2121 SetResponse(raw_headers, response_data); 2122 job_factory_->SetDelayedCompleteJobGeneration(true); 2123 HandleScheme("http"); 2124 2125 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2126 GURL("http://example.com/blah"), 2127 ResourceType::MAIN_FRAME); 2128 // Return some data so that the request is identified as a download 2129 // and the proper resource handlers are created. 2130 EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage()); 2131 2132 // And now simulate a cancellation coming from the renderer. 2133 ResourceHostMsg_CancelRequest msg(request_id); 2134 host_.OnMessageReceived(msg, filter_.get()); 2135 2136 // Since the request had already started processing as a download, 2137 // the cancellation above should have been ignored and the request 2138 // should still be alive. 2139 EXPECT_EQ(1, host_.pending_requests()); 2140 2141 // Cancelling by other methods shouldn't work either. 2142 host_.CancelRequestsForProcess(render_view_id); 2143 EXPECT_EQ(1, host_.pending_requests()); 2144 2145 // Cancelling by context should work. 2146 host_.CancelRequestsForContext(filter_->resource_context()); 2147 EXPECT_EQ(0, host_.pending_requests()); 2148} 2149 2150TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextDetached) { 2151 EXPECT_EQ(0, host_.pending_requests()); 2152 2153 int render_view_id = 0; 2154 int request_id = 1; 2155 2156 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2157 net::URLRequestTestJob::test_url_4(), 2158 ResourceType::PREFETCH); // detachable type 2159 2160 // Simulate a cancel coming from the renderer. 2161 RendererCancelRequest(request_id); 2162 2163 // Since the request had already started processing as detachable, 2164 // the cancellation above should have been ignored and the request 2165 // should have been detached. 2166 EXPECT_EQ(1, host_.pending_requests()); 2167 2168 // Cancelling by other methods should also leave it detached. 2169 host_.CancelRequestsForProcess(render_view_id); 2170 EXPECT_EQ(1, host_.pending_requests()); 2171 2172 // Cancelling by context should work. 2173 host_.CancelRequestsForContext(filter_->resource_context()); 2174 EXPECT_EQ(0, host_.pending_requests()); 2175} 2176 2177// Test the cancelling of requests that are being transferred to a new renderer 2178// due to a redirection. 2179TEST_F(ResourceDispatcherHostTest, CancelRequestsForContextTransferred) { 2180 EXPECT_EQ(0, host_.pending_requests()); 2181 2182 int render_view_id = 0; 2183 int request_id = 1; 2184 2185 std::string raw_headers("HTTP/1.1 200 OK\n" 2186 "Content-Type: text/html; charset=utf-8\n\n"); 2187 std::string response_data("<html>foobar</html>"); 2188 2189 SetResponse(raw_headers, response_data); 2190 HandleScheme("http"); 2191 2192 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2193 GURL("http://example.com/blah"), 2194 ResourceType::MAIN_FRAME); 2195 2196 2197 GlobalRequestID global_request_id(filter_->child_id(), request_id); 2198 host_.MarkAsTransferredNavigation(global_request_id); 2199 2200 // And now simulate a cancellation coming from the renderer. 2201 ResourceHostMsg_CancelRequest msg(request_id); 2202 host_.OnMessageReceived(msg, filter_.get()); 2203 2204 // Since the request is marked as being transferred, 2205 // the cancellation above should have been ignored and the request 2206 // should still be alive. 2207 EXPECT_EQ(1, host_.pending_requests()); 2208 2209 // Cancelling by other methods shouldn't work either. 2210 host_.CancelRequestsForProcess(render_view_id); 2211 EXPECT_EQ(1, host_.pending_requests()); 2212 2213 // Cancelling by context should work. 2214 host_.CancelRequestsForContext(filter_->resource_context()); 2215 EXPECT_EQ(0, host_.pending_requests()); 2216} 2217 2218// Test transferred navigations with text/html, which doesn't trigger any 2219// content sniffing. 2220TEST_F(ResourceDispatcherHostTest, TransferNavigationHtml) { 2221 // This test expects the cross site request to be leaked, so it can transfer 2222 // the request directly. 2223 CrossSiteResourceHandler::SetLeakRequestsForTesting(true); 2224 2225 EXPECT_EQ(0, host_.pending_requests()); 2226 2227 int render_view_id = 0; 2228 int request_id = 1; 2229 2230 // Configure initial request. 2231 SetResponse("HTTP/1.1 302 Found\n" 2232 "Location: http://other.com/blech\n\n"); 2233 2234 HandleScheme("http"); 2235 2236 // Temporarily replace ContentBrowserClient with one that will trigger the 2237 // transfer navigation code paths. 2238 TransfersAllNavigationsContentBrowserClient new_client; 2239 ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client); 2240 2241 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2242 GURL("http://example.com/blah"), 2243 ResourceType::MAIN_FRAME); 2244 2245 // Now that we're blocked on the redirect, update the response and unblock by 2246 // telling the AsyncResourceHandler to follow the redirect. 2247 const std::string kResponseBody = "hello world"; 2248 SetResponse("HTTP/1.1 200 OK\n" 2249 "Content-Type: text/html\n\n", 2250 kResponseBody); 2251 ResourceHostMsg_FollowRedirect redirect_msg(request_id); 2252 host_.OnMessageReceived(redirect_msg, filter_.get()); 2253 base::MessageLoop::current()->RunUntilIdle(); 2254 2255 // Flush all the pending requests to get the response through the 2256 // BufferedResourceHandler. 2257 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2258 2259 // Restore, now that we've set up a transfer. 2260 SetBrowserClientForTesting(old_client); 2261 2262 // This second filter is used to emulate a second process. 2263 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 2264 2265 int new_render_view_id = 1; 2266 int new_request_id = 2; 2267 2268 ResourceHostMsg_Request request = 2269 CreateResourceRequest("GET", ResourceType::MAIN_FRAME, 2270 GURL("http://other.com/blech")); 2271 request.transferred_request_child_id = filter_->child_id(); 2272 request.transferred_request_request_id = request_id; 2273 2274 ResourceHostMsg_RequestResource transfer_request_msg( 2275 new_render_view_id, new_request_id, request); 2276 host_.OnMessageReceived(transfer_request_msg, second_filter.get()); 2277 base::MessageLoop::current()->RunUntilIdle(); 2278 2279 // Check generated messages. 2280 ResourceIPCAccumulator::ClassifiedMessages msgs; 2281 accum_.GetClassifiedMessages(&msgs); 2282 2283 ASSERT_EQ(2U, msgs.size()); 2284 EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type()); 2285 CheckSuccessfulRequest(msgs[1], kResponseBody); 2286} 2287 2288// Test transferred navigations with text/plain, which causes 2289// BufferedResourceHandler to buffer the response to sniff the content 2290// before the transfer occurs. 2291TEST_F(ResourceDispatcherHostTest, TransferNavigationText) { 2292 // This test expects the cross site request to be leaked, so it can transfer 2293 // the request directly. 2294 CrossSiteResourceHandler::SetLeakRequestsForTesting(true); 2295 2296 EXPECT_EQ(0, host_.pending_requests()); 2297 2298 int render_view_id = 0; 2299 int request_id = 1; 2300 2301 // Configure initial request. 2302 SetResponse("HTTP/1.1 302 Found\n" 2303 "Location: http://other.com/blech\n\n"); 2304 2305 HandleScheme("http"); 2306 2307 // Temporarily replace ContentBrowserClient with one that will trigger the 2308 // transfer navigation code paths. 2309 TransfersAllNavigationsContentBrowserClient new_client; 2310 ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client); 2311 2312 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2313 GURL("http://example.com/blah"), 2314 ResourceType::MAIN_FRAME); 2315 2316 // Now that we're blocked on the redirect, update the response and unblock by 2317 // telling the AsyncResourceHandler to follow the redirect. Use a text/plain 2318 // MIME type, which causes BufferedResourceHandler to buffer it before the 2319 // transfer occurs. 2320 const std::string kResponseBody = "hello world"; 2321 SetResponse("HTTP/1.1 200 OK\n" 2322 "Content-Type: text/plain\n\n", 2323 kResponseBody); 2324 ResourceHostMsg_FollowRedirect redirect_msg(request_id); 2325 host_.OnMessageReceived(redirect_msg, filter_.get()); 2326 base::MessageLoop::current()->RunUntilIdle(); 2327 2328 // Flush all the pending requests to get the response through the 2329 // BufferedResourceHandler. 2330 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2331 2332 // Restore, now that we've set up a transfer. 2333 SetBrowserClientForTesting(old_client); 2334 2335 // This second filter is used to emulate a second process. 2336 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 2337 2338 int new_render_view_id = 1; 2339 int new_request_id = 2; 2340 2341 ResourceHostMsg_Request request = 2342 CreateResourceRequest("GET", ResourceType::MAIN_FRAME, 2343 GURL("http://other.com/blech")); 2344 request.transferred_request_child_id = filter_->child_id(); 2345 request.transferred_request_request_id = request_id; 2346 2347 ResourceHostMsg_RequestResource transfer_request_msg( 2348 new_render_view_id, new_request_id, request); 2349 host_.OnMessageReceived(transfer_request_msg, second_filter.get()); 2350 base::MessageLoop::current()->RunUntilIdle(); 2351 2352 // Check generated messages. 2353 ResourceIPCAccumulator::ClassifiedMessages msgs; 2354 accum_.GetClassifiedMessages(&msgs); 2355 2356 ASSERT_EQ(2U, msgs.size()); 2357 EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type()); 2358 CheckSuccessfulRequest(msgs[1], kResponseBody); 2359} 2360 2361TEST_F(ResourceDispatcherHostTest, TransferNavigationWithProcessCrash) { 2362 // This test expects the cross site request to be leaked, so it can transfer 2363 // the request directly. 2364 CrossSiteResourceHandler::SetLeakRequestsForTesting(true); 2365 2366 EXPECT_EQ(0, host_.pending_requests()); 2367 2368 int render_view_id = 0; 2369 int request_id = 1; 2370 int first_child_id = -1; 2371 2372 // Configure initial request. 2373 SetResponse("HTTP/1.1 302 Found\n" 2374 "Location: http://other.com/blech\n\n"); 2375 const std::string kResponseBody = "hello world"; 2376 2377 HandleScheme("http"); 2378 2379 // Temporarily replace ContentBrowserClient with one that will trigger the 2380 // transfer navigation code paths. 2381 TransfersAllNavigationsContentBrowserClient new_client; 2382 ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client); 2383 2384 // Create a first filter that can be deleted before the second one starts. 2385 { 2386 scoped_refptr<ForwardingFilter> first_filter = MakeForwardingFilter(); 2387 first_child_id = first_filter->child_id(); 2388 2389 ResourceHostMsg_Request first_request = 2390 CreateResourceRequest("GET", ResourceType::MAIN_FRAME, 2391 GURL("http://example.com/blah")); 2392 2393 ResourceHostMsg_RequestResource first_request_msg( 2394 render_view_id, request_id, first_request); 2395 host_.OnMessageReceived(first_request_msg, first_filter.get()); 2396 base::MessageLoop::current()->RunUntilIdle(); 2397 2398 // Now that we're blocked on the redirect, update the response and unblock 2399 // by telling the AsyncResourceHandler to follow the redirect. 2400 SetResponse("HTTP/1.1 200 OK\n" 2401 "Content-Type: text/html\n\n", 2402 kResponseBody); 2403 ResourceHostMsg_FollowRedirect redirect_msg(request_id); 2404 host_.OnMessageReceived(redirect_msg, first_filter.get()); 2405 base::MessageLoop::current()->RunUntilIdle(); 2406 2407 // Flush all the pending requests to get the response through the 2408 // BufferedResourceHandler. 2409 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2410 } 2411 // The first filter is now deleted, as if the child process died. 2412 2413 // Restore. 2414 SetBrowserClientForTesting(old_client); 2415 2416 // Make sure we don't hold onto the ResourceMessageFilter after it is deleted. 2417 GlobalRequestID first_global_request_id(first_child_id, request_id); 2418 2419 // This second filter is used to emulate a second process. 2420 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 2421 2422 int new_render_view_id = 1; 2423 int new_request_id = 2; 2424 2425 ResourceHostMsg_Request request = 2426 CreateResourceRequest("GET", ResourceType::MAIN_FRAME, 2427 GURL("http://other.com/blech")); 2428 request.transferred_request_child_id = first_child_id; 2429 request.transferred_request_request_id = request_id; 2430 2431 // For cleanup. 2432 child_ids_.insert(second_filter->child_id()); 2433 ResourceHostMsg_RequestResource transfer_request_msg( 2434 new_render_view_id, new_request_id, request); 2435 host_.OnMessageReceived(transfer_request_msg, second_filter.get()); 2436 base::MessageLoop::current()->RunUntilIdle(); 2437 2438 // Check generated messages. 2439 ResourceIPCAccumulator::ClassifiedMessages msgs; 2440 accum_.GetClassifiedMessages(&msgs); 2441 2442 ASSERT_EQ(2U, msgs.size()); 2443 EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type()); 2444 CheckSuccessfulRequest(msgs[1], kResponseBody); 2445} 2446 2447TEST_F(ResourceDispatcherHostTest, TransferNavigationWithTwoRedirects) { 2448 // This test expects the cross site request to be leaked, so it can transfer 2449 // the request directly. 2450 CrossSiteResourceHandler::SetLeakRequestsForTesting(true); 2451 2452 EXPECT_EQ(0, host_.pending_requests()); 2453 2454 int render_view_id = 0; 2455 int request_id = 1; 2456 2457 // Configure initial request. 2458 SetResponse("HTTP/1.1 302 Found\n" 2459 "Location: http://other.com/blech\n\n"); 2460 2461 HandleScheme("http"); 2462 2463 // Temporarily replace ContentBrowserClient with one that will trigger the 2464 // transfer navigation code paths. 2465 TransfersAllNavigationsContentBrowserClient new_client; 2466 ContentBrowserClient* old_client = SetBrowserClientForTesting(&new_client); 2467 2468 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2469 GURL("http://example.com/blah"), 2470 ResourceType::MAIN_FRAME); 2471 2472 // Now that we're blocked on the redirect, simulate hitting another redirect. 2473 SetResponse("HTTP/1.1 302 Found\n" 2474 "Location: http://other.com/blerg\n\n"); 2475 ResourceHostMsg_FollowRedirect redirect_msg(request_id); 2476 host_.OnMessageReceived(redirect_msg, filter_.get()); 2477 base::MessageLoop::current()->RunUntilIdle(); 2478 2479 // Now that we're blocked on the second redirect, update the response and 2480 // unblock by telling the AsyncResourceHandler to follow the redirect. 2481 // Again, use text/plain to force BufferedResourceHandler to buffer before 2482 // the transfer. 2483 const std::string kResponseBody = "hello world"; 2484 SetResponse("HTTP/1.1 200 OK\n" 2485 "Content-Type: text/plain\n\n", 2486 kResponseBody); 2487 ResourceHostMsg_FollowRedirect redirect_msg2(request_id); 2488 host_.OnMessageReceived(redirect_msg2, filter_.get()); 2489 base::MessageLoop::current()->RunUntilIdle(); 2490 2491 // Flush all the pending requests to get the response through the 2492 // BufferedResourceHandler. 2493 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2494 2495 // Restore. 2496 SetBrowserClientForTesting(old_client); 2497 2498 // This second filter is used to emulate a second process. 2499 scoped_refptr<ForwardingFilter> second_filter = MakeForwardingFilter(); 2500 2501 int new_render_view_id = 1; 2502 int new_request_id = 2; 2503 2504 ResourceHostMsg_Request request = 2505 CreateResourceRequest("GET", ResourceType::MAIN_FRAME, 2506 GURL("http://other.com/blech")); 2507 request.transferred_request_child_id = filter_->child_id(); 2508 request.transferred_request_request_id = request_id; 2509 2510 // For cleanup. 2511 child_ids_.insert(second_filter->child_id()); 2512 ResourceHostMsg_RequestResource transfer_request_msg( 2513 new_render_view_id, new_request_id, request); 2514 host_.OnMessageReceived(transfer_request_msg, second_filter.get()); 2515 2516 // Verify that we update the ResourceRequestInfo. 2517 GlobalRequestID global_request_id(second_filter->child_id(), new_request_id); 2518 const ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest( 2519 host_.GetURLRequest(global_request_id)); 2520 EXPECT_EQ(second_filter->child_id(), info->GetChildID()); 2521 EXPECT_EQ(new_render_view_id, info->GetRouteID()); 2522 EXPECT_EQ(new_request_id, info->GetRequestID()); 2523 EXPECT_EQ(second_filter, info->filter()); 2524 2525 // Let request complete. 2526 base::MessageLoop::current()->RunUntilIdle(); 2527 2528 // Check generated messages. 2529 ResourceIPCAccumulator::ClassifiedMessages msgs; 2530 accum_.GetClassifiedMessages(&msgs); 2531 2532 ASSERT_EQ(2U, msgs.size()); 2533 EXPECT_EQ(ResourceMsg_ReceivedRedirect::ID, msgs[0][0].type()); 2534 CheckSuccessfulRequest(msgs[1], kResponseBody); 2535} 2536 2537TEST_F(ResourceDispatcherHostTest, UnknownURLScheme) { 2538 EXPECT_EQ(0, host_.pending_requests()); 2539 2540 HandleScheme("http"); 2541 2542 MakeTestRequestWithResourceType(filter_.get(), 0, 1, GURL("foo://bar"), 2543 ResourceType::MAIN_FRAME); 2544 2545 // Flush all pending requests. 2546 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2547 2548 // Sort all the messages we saw by request. 2549 ResourceIPCAccumulator::ClassifiedMessages msgs; 2550 accum_.GetClassifiedMessages(&msgs); 2551 2552 // We should have gotten one RequestComplete message. 2553 ASSERT_EQ(1U, msgs[0].size()); 2554 EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type()); 2555 2556 // The RequestComplete message should have the error code of 2557 // ERR_UNKNOWN_URL_SCHEME. 2558 CheckRequestCompleteErrorCode(msgs[0][0], net::ERR_UNKNOWN_URL_SCHEME); 2559} 2560 2561TEST_F(ResourceDispatcherHostTest, DataReceivedACKs) { 2562 EXPECT_EQ(0, host_.pending_requests()); 2563 2564 SendDataReceivedACKs(true); 2565 2566 HandleScheme("big-job"); 2567 MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000")); 2568 2569 // Sort all the messages we saw by request. 2570 ResourceIPCAccumulator::ClassifiedMessages msgs; 2571 accum_.GetClassifiedMessages(&msgs); 2572 2573 size_t size = msgs[0].size(); 2574 2575 EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type()); 2576 EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type()); 2577 for (size_t i = 2; i < size - 1; ++i) 2578 EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type()); 2579 EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][size - 1].type()); 2580} 2581 2582// Request a very large detachable resource and cancel part way. Some of the 2583// data should have been sent to the renderer, but not all. 2584TEST_F(ResourceDispatcherHostTest, DataSentBeforeDetach) { 2585 EXPECT_EQ(0, host_.pending_requests()); 2586 2587 int render_view_id = 0; 2588 int request_id = 1; 2589 2590 std::string raw_headers("HTTP\n" 2591 "Content-type: image/jpeg\n\n"); 2592 std::string response_data("01234567890123456789\x01foobar"); 2593 2594 // Create a response larger than kMaxAllocationSize (currently 32K). Note 2595 // that if this increase beyond 512K we'll need to make the response longer. 2596 const int kAllocSize = 1024*512; 2597 response_data.resize(kAllocSize, ' '); 2598 2599 SetResponse(raw_headers, response_data); 2600 job_factory_->SetDelayedCompleteJobGeneration(true); 2601 HandleScheme("http"); 2602 2603 MakeTestRequestWithResourceType(filter_.get(), render_view_id, request_id, 2604 GURL("http://example.com/blah"), 2605 ResourceType::PREFETCH); 2606 2607 // Get a bit of data before cancelling. 2608 EXPECT_TRUE(net::URLRequestTestJob::ProcessOnePendingMessage()); 2609 2610 // Simulate a cancellation coming from the renderer. 2611 ResourceHostMsg_CancelRequest msg(request_id); 2612 host_.OnMessageReceived(msg, filter_.get()); 2613 2614 EXPECT_EQ(1, host_.pending_requests()); 2615 2616 while (net::URLRequestTestJob::ProcessOnePendingMessage()) {} 2617 2618 // Sort all the messages we saw by request. 2619 ResourceIPCAccumulator::ClassifiedMessages msgs; 2620 accum_.GetClassifiedMessages(&msgs); 2621 2622 EXPECT_EQ(4U, msgs[0].size()); 2623 2624 // Figure out how many bytes were received by the renderer. 2625 int data_offset; 2626 int data_length; 2627 ASSERT_TRUE( 2628 ExtractDataOffsetAndLength(msgs[0][2], &data_offset, &data_length)); 2629 EXPECT_LT(0, data_length); 2630 EXPECT_GT(kAllocSize, data_length); 2631 2632 // Verify the data that was received before cancellation. The request should 2633 // have appeared to cancel, however. 2634 CheckSuccessfulRequestWithErrorCode( 2635 msgs[0], 2636 std::string(response_data.begin(), response_data.begin() + data_length), 2637 net::ERR_ABORTED); 2638} 2639 2640TEST_F(ResourceDispatcherHostTest, DelayedDataReceivedACKs) { 2641 EXPECT_EQ(0, host_.pending_requests()); 2642 2643 HandleScheme("big-job"); 2644 MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000")); 2645 2646 // Sort all the messages we saw by request. 2647 ResourceIPCAccumulator::ClassifiedMessages msgs; 2648 accum_.GetClassifiedMessages(&msgs); 2649 2650 // We expect 1x ReceivedResponse, 1x SetDataBuffer, Nx ReceivedData messages. 2651 EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type()); 2652 EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type()); 2653 for (size_t i = 2; i < msgs[0].size(); ++i) 2654 EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type()); 2655 2656 // NOTE: If we fail the above checks then it means that we probably didn't 2657 // load a big enough response to trigger the delay mechanism we are trying to 2658 // test! 2659 2660 msgs[0].erase(msgs[0].begin()); 2661 msgs[0].erase(msgs[0].begin()); 2662 2663 // ACK all DataReceived messages until we find a RequestComplete message. 2664 bool complete = false; 2665 while (!complete) { 2666 for (size_t i = 0; i < msgs[0].size(); ++i) { 2667 if (msgs[0][i].type() == ResourceMsg_RequestComplete::ID) { 2668 complete = true; 2669 break; 2670 } 2671 2672 EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type()); 2673 2674 ResourceHostMsg_DataReceived_ACK msg(1); 2675 host_.OnMessageReceived(msg, filter_.get()); 2676 } 2677 2678 base::MessageLoop::current()->RunUntilIdle(); 2679 2680 msgs.clear(); 2681 accum_.GetClassifiedMessages(&msgs); 2682 } 2683} 2684 2685// Flakyness of this test might indicate memory corruption issues with 2686// for example the ResourceBuffer of AsyncResourceHandler. 2687TEST_F(ResourceDispatcherHostTest, DataReceivedUnexpectedACKs) { 2688 EXPECT_EQ(0, host_.pending_requests()); 2689 2690 HandleScheme("big-job"); 2691 MakeTestRequest(0, 1, GURL("big-job:0123456789,1000000")); 2692 2693 // Sort all the messages we saw by request. 2694 ResourceIPCAccumulator::ClassifiedMessages msgs; 2695 accum_.GetClassifiedMessages(&msgs); 2696 2697 // We expect 1x ReceivedResponse, 1x SetDataBuffer, Nx ReceivedData messages. 2698 EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type()); 2699 EXPECT_EQ(ResourceMsg_SetDataBuffer::ID, msgs[0][1].type()); 2700 for (size_t i = 2; i < msgs[0].size(); ++i) 2701 EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type()); 2702 2703 // NOTE: If we fail the above checks then it means that we probably didn't 2704 // load a big enough response to trigger the delay mechanism. 2705 2706 // Send some unexpected ACKs. 2707 for (size_t i = 0; i < 128; ++i) { 2708 ResourceHostMsg_DataReceived_ACK msg(1); 2709 host_.OnMessageReceived(msg, filter_.get()); 2710 } 2711 2712 msgs[0].erase(msgs[0].begin()); 2713 msgs[0].erase(msgs[0].begin()); 2714 2715 // ACK all DataReceived messages until we find a RequestComplete message. 2716 bool complete = false; 2717 while (!complete) { 2718 for (size_t i = 0; i < msgs[0].size(); ++i) { 2719 if (msgs[0][i].type() == ResourceMsg_RequestComplete::ID) { 2720 complete = true; 2721 break; 2722 } 2723 2724 EXPECT_EQ(ResourceMsg_DataReceived::ID, msgs[0][i].type()); 2725 2726 ResourceHostMsg_DataReceived_ACK msg(1); 2727 host_.OnMessageReceived(msg, filter_.get()); 2728 } 2729 2730 base::MessageLoop::current()->RunUntilIdle(); 2731 2732 msgs.clear(); 2733 accum_.GetClassifiedMessages(&msgs); 2734 } 2735} 2736 2737// Tests the dispatcher host's temporary file management. 2738TEST_F(ResourceDispatcherHostTest, RegisterDownloadedTempFile) { 2739 const int kRequestID = 1; 2740 2741 // Create a temporary file. 2742 base::FilePath file_path; 2743 ASSERT_TRUE(base::CreateTemporaryFile(&file_path)); 2744 scoped_refptr<ShareableFileReference> deletable_file = 2745 ShareableFileReference::GetOrCreate( 2746 file_path, 2747 ShareableFileReference::DELETE_ON_FINAL_RELEASE, 2748 BrowserThread::GetMessageLoopProxyForThread( 2749 BrowserThread::FILE).get()); 2750 2751 // Not readable. 2752 EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2753 filter_->child_id(), file_path)); 2754 2755 // Register it for a resource request. 2756 host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path); 2757 2758 // Should be readable now. 2759 EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2760 filter_->child_id(), file_path)); 2761 2762 // The child releases from the request. 2763 ResourceHostMsg_ReleaseDownloadedFile release_msg(kRequestID); 2764 host_.OnMessageReceived(release_msg, filter_); 2765 2766 // Still readable because there is another reference to the file. (The child 2767 // may take additional blob references.) 2768 EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2769 filter_->child_id(), file_path)); 2770 2771 // Release extra references and wait for the file to be deleted. (This relies 2772 // on the delete happening on the FILE thread which is mapped to main thread 2773 // in this test.) 2774 deletable_file = NULL; 2775 base::RunLoop().RunUntilIdle(); 2776 2777 // The file is no longer readable to the child and has been deleted. 2778 EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2779 filter_->child_id(), file_path)); 2780 EXPECT_FALSE(base::PathExists(file_path)); 2781} 2782 2783// Tests that temporary files held on behalf of child processes are released 2784// when the child process dies. 2785TEST_F(ResourceDispatcherHostTest, ReleaseTemporiesOnProcessExit) { 2786 const int kRequestID = 1; 2787 2788 // Create a temporary file. 2789 base::FilePath file_path; 2790 ASSERT_TRUE(base::CreateTemporaryFile(&file_path)); 2791 scoped_refptr<ShareableFileReference> deletable_file = 2792 ShareableFileReference::GetOrCreate( 2793 file_path, 2794 ShareableFileReference::DELETE_ON_FINAL_RELEASE, 2795 BrowserThread::GetMessageLoopProxyForThread( 2796 BrowserThread::FILE).get()); 2797 2798 // Register it for a resource request. 2799 host_.RegisterDownloadedTempFile(filter_->child_id(), kRequestID, file_path); 2800 deletable_file = NULL; 2801 2802 // Should be readable now. 2803 EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2804 filter_->child_id(), file_path)); 2805 2806 // Let the process die. 2807 filter_->OnChannelClosing(); 2808 base::RunLoop().RunUntilIdle(); 2809 2810 // The file is no longer readable to the child and has been deleted. 2811 EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2812 filter_->child_id(), file_path)); 2813 EXPECT_FALSE(base::PathExists(file_path)); 2814} 2815 2816TEST_F(ResourceDispatcherHostTest, DownloadToFile) { 2817 // Make a request which downloads to file. 2818 ResourceHostMsg_Request request = CreateResourceRequest( 2819 "GET", ResourceType::SUB_RESOURCE, net::URLRequestTestJob::test_url_1()); 2820 request.download_to_file = true; 2821 ResourceHostMsg_RequestResource request_msg(0, 1, request); 2822 host_.OnMessageReceived(request_msg, filter_); 2823 2824 // Running the message loop until idle does not work because 2825 // RedirectToFileResourceHandler posts things to base::WorkerPool. Instead, 2826 // wait for the ResourceMsg_RequestComplete to go out. Then run the event loop 2827 // until idle so the loader is gone. 2828 WaitForRequestComplete(); 2829 base::RunLoop().RunUntilIdle(); 2830 EXPECT_EQ(0, host_.pending_requests()); 2831 2832 ResourceIPCAccumulator::ClassifiedMessages msgs; 2833 accum_.GetClassifiedMessages(&msgs); 2834 2835 ASSERT_EQ(1U, msgs.size()); 2836 const std::vector<IPC::Message>& messages = msgs[0]; 2837 2838 // The request should contain the following messages: 2839 // ReceivedResponse (indicates headers received and filename) 2840 // DataDownloaded* (bytes downloaded and total length) 2841 // RequestComplete (request is done) 2842 2843 // ReceivedResponse 2844 ResourceResponseHead response_head; 2845 GetResponseHead(messages, &response_head); 2846 ASSERT_FALSE(response_head.download_file_path.empty()); 2847 2848 // DataDownloaded 2849 size_t total_len = 0; 2850 for (size_t i = 1; i < messages.size() - 1; i++) { 2851 ASSERT_EQ(ResourceMsg_DataDownloaded::ID, messages[i].type()); 2852 PickleIterator iter(messages[i]); 2853 int request_id, data_len; 2854 ASSERT_TRUE(IPC::ReadParam(&messages[i], &iter, &request_id)); 2855 ASSERT_TRUE(IPC::ReadParam(&messages[i], &iter, &data_len)); 2856 total_len += data_len; 2857 } 2858 EXPECT_EQ(net::URLRequestTestJob::test_data_1().size(), total_len); 2859 2860 // RequestComplete 2861 CheckRequestCompleteErrorCode(messages.back(), net::OK); 2862 2863 // Verify that the data ended up in the temporary file. 2864 std::string contents; 2865 ASSERT_TRUE(base::ReadFileToString(response_head.download_file_path, 2866 &contents)); 2867 EXPECT_EQ(net::URLRequestTestJob::test_data_1(), contents); 2868 2869 // The file should be readable by the child. 2870 EXPECT_TRUE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2871 filter_->child_id(), response_head.download_file_path)); 2872 2873 // When the renderer releases the file, it should be deleted. Again, 2874 // RunUntilIdle doesn't work because base::WorkerPool is involved. 2875 ShareableFileReleaseWaiter waiter(response_head.download_file_path); 2876 ResourceHostMsg_ReleaseDownloadedFile release_msg(1); 2877 host_.OnMessageReceived(release_msg, filter_); 2878 waiter.Wait(); 2879 // The release callback runs before the delete is scheduled, so pump the 2880 // message loop for the delete itself. (This relies on the delete happening on 2881 // the FILE thread which is mapped to main thread in this test.) 2882 base::RunLoop().RunUntilIdle(); 2883 2884 EXPECT_FALSE(base::PathExists(response_head.download_file_path)); 2885 EXPECT_FALSE(ChildProcessSecurityPolicyImpl::GetInstance()->CanReadFile( 2886 filter_->child_id(), response_head.download_file_path)); 2887} 2888 2889net::URLRequestJob* TestURLRequestJobFactory::MaybeCreateJobWithProtocolHandler( 2890 const std::string& scheme, 2891 net::URLRequest* request, 2892 net::NetworkDelegate* network_delegate) const { 2893 url_request_jobs_created_count_++; 2894 if (test_fixture_->response_headers_.empty()) { 2895 if (delay_start_) { 2896 return new URLRequestTestDelayedStartJob(request, network_delegate); 2897 } else if (delay_complete_) { 2898 return new URLRequestTestDelayedCompletionJob(request, 2899 network_delegate); 2900 } else if (network_start_notification_) { 2901 return new URLRequestTestDelayedNetworkJob(request, network_delegate); 2902 } else if (scheme == "big-job") { 2903 return new URLRequestBigJob(request, network_delegate); 2904 } else { 2905 return new net::URLRequestTestJob(request, network_delegate); 2906 } 2907 } else { 2908 if (delay_start_) { 2909 return new URLRequestTestDelayedStartJob( 2910 request, network_delegate, 2911 test_fixture_->response_headers_, test_fixture_->response_data_, 2912 false); 2913 } else if (delay_complete_) { 2914 return new URLRequestTestDelayedCompletionJob( 2915 request, network_delegate, 2916 test_fixture_->response_headers_, test_fixture_->response_data_, 2917 false); 2918 } else { 2919 return new net::URLRequestTestJob( 2920 request, network_delegate, 2921 test_fixture_->response_headers_, test_fixture_->response_data_, 2922 false); 2923 } 2924 } 2925} 2926 2927} // namespace content 2928