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 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading 6 7 #include "content/child/resource_dispatcher.h" 8 9 #include "base/basictypes.h" 10 #include "base/bind.h" 11 #include "base/compiler_specific.h" 12 #include "base/debug/alias.h" 13 #include "base/files/file_path.h" 14 #include "base/memory/shared_memory.h" 15 #include "base/message_loop/message_loop.h" 16 #include "base/metrics/histogram.h" 17 #include "base/strings/string_util.h" 18 #include "content/child/request_extra_data.h" 19 #include "content/child/request_info.h" 20 #include "content/child/resource_loader_bridge.h" 21 #include "content/child/site_isolation_policy.h" 22 #include "content/child/sync_load_response.h" 23 #include "content/child/threaded_data_provider.h" 24 #include "content/common/inter_process_time_ticks_converter.h" 25 #include "content/common/resource_messages.h" 26 #include "content/public/child/request_peer.h" 27 #include "content/public/child/resource_dispatcher_delegate.h" 28 #include "content/public/common/resource_response.h" 29 #include "content/public/common/resource_type.h" 30 #include "net/base/net_errors.h" 31 #include "net/base/net_util.h" 32 #include "net/base/request_priority.h" 33 #include "net/http/http_response_headers.h" 34 35 namespace content { 36 37 namespace { 38 39 // Converts |time| from a remote to local TimeTicks, overwriting the original 40 // value. 41 void RemoteToLocalTimeTicks( 42 const InterProcessTimeTicksConverter& converter, 43 base::TimeTicks* time) { 44 RemoteTimeTicks remote_time = RemoteTimeTicks::FromTimeTicks(*time); 45 *time = converter.ToLocalTimeTicks(remote_time).ToTimeTicks(); 46 } 47 48 void CrashOnMapFailure() { 49 #if defined(OS_WIN) 50 DWORD last_err = GetLastError(); 51 base::debug::Alias(&last_err); 52 #endif 53 CHECK(false); 54 } 55 56 // Each resource request is assigned an ID scoped to this process. 57 int MakeRequestID() { 58 // NOTE: The resource_dispatcher_host also needs probably unique 59 // request_ids, so they count down from -2 (-1 is a special we're 60 // screwed value), while the renderer process counts up. 61 static int next_request_id = 0; 62 return next_request_id++; 63 } 64 65 } // namespace 66 67 // ResourceLoaderBridge implementation ---------------------------------------- 68 69 class IPCResourceLoaderBridge : public ResourceLoaderBridge { 70 public: 71 IPCResourceLoaderBridge(ResourceDispatcher* dispatcher, 72 const RequestInfo& request_info); 73 virtual ~IPCResourceLoaderBridge(); 74 75 // ResourceLoaderBridge 76 virtual void SetRequestBody(ResourceRequestBody* request_body) OVERRIDE; 77 virtual bool Start(RequestPeer* peer) OVERRIDE; 78 virtual void Cancel() OVERRIDE; 79 virtual void SetDefersLoading(bool value) OVERRIDE; 80 virtual void DidChangePriority(net::RequestPriority new_priority, 81 int intra_priority_value) OVERRIDE; 82 virtual bool AttachThreadedDataReceiver( 83 blink::WebThreadedDataReceiver* threaded_data_receiver) OVERRIDE; 84 virtual void SyncLoad(SyncLoadResponse* response) OVERRIDE; 85 86 private: 87 // The resource dispatcher for this loader. The bridge doesn't own it, but 88 // it's guaranteed to outlive the bridge. 89 ResourceDispatcher* dispatcher_; 90 91 // The request to send, created on initialization for modification and 92 // appending data. 93 ResourceHostMsg_Request request_; 94 95 // ID for the request, valid once Start()ed, -1 if not valid yet. 96 int request_id_; 97 98 // The routing id used when sending IPC messages. 99 int routing_id_; 100 101 // The security origin of the frame that initiates this request. 102 GURL frame_origin_; 103 104 bool is_synchronous_request_; 105 }; 106 107 IPCResourceLoaderBridge::IPCResourceLoaderBridge( 108 ResourceDispatcher* dispatcher, 109 const RequestInfo& request_info) 110 : dispatcher_(dispatcher), 111 request_id_(-1), 112 routing_id_(request_info.routing_id), 113 is_synchronous_request_(false) { 114 DCHECK(dispatcher_) << "no resource dispatcher"; 115 request_.method = request_info.method; 116 request_.url = request_info.url; 117 request_.first_party_for_cookies = request_info.first_party_for_cookies; 118 request_.referrer = request_info.referrer; 119 request_.referrer_policy = request_info.referrer_policy; 120 request_.headers = request_info.headers; 121 request_.load_flags = request_info.load_flags; 122 request_.origin_pid = request_info.requestor_pid; 123 request_.resource_type = request_info.request_type; 124 request_.priority = request_info.priority; 125 request_.request_context = request_info.request_context; 126 request_.appcache_host_id = request_info.appcache_host_id; 127 request_.download_to_file = request_info.download_to_file; 128 request_.has_user_gesture = request_info.has_user_gesture; 129 request_.skip_service_worker = request_info.skip_service_worker; 130 request_.enable_load_timing = request_info.enable_load_timing; 131 132 const RequestExtraData kEmptyData; 133 const RequestExtraData* extra_data; 134 if (request_info.extra_data) 135 extra_data = static_cast<RequestExtraData*>(request_info.extra_data); 136 else 137 extra_data = &kEmptyData; 138 request_.visiblity_state = extra_data->visibility_state(); 139 request_.render_frame_id = extra_data->render_frame_id(); 140 request_.is_main_frame = extra_data->is_main_frame(); 141 request_.parent_is_main_frame = extra_data->parent_is_main_frame(); 142 request_.parent_render_frame_id = extra_data->parent_render_frame_id(); 143 request_.allow_download = extra_data->allow_download(); 144 request_.transition_type = extra_data->transition_type(); 145 request_.should_replace_current_entry = 146 extra_data->should_replace_current_entry(); 147 request_.transferred_request_child_id = 148 extra_data->transferred_request_child_id(); 149 request_.transferred_request_request_id = 150 extra_data->transferred_request_request_id(); 151 request_.service_worker_provider_id = 152 extra_data->service_worker_provider_id(); 153 frame_origin_ = extra_data->frame_origin(); 154 } 155 156 IPCResourceLoaderBridge::~IPCResourceLoaderBridge() { 157 // we remove our hook for the resource dispatcher only when going away, since 158 // it doesn't keep track of whether we've force terminated the request 159 if (request_id_ >= 0) { 160 // this operation may fail, as the dispatcher will have preemptively 161 // removed us when the renderer sends the ReceivedAllData message. 162 dispatcher_->RemovePendingRequest(request_id_); 163 } 164 } 165 166 void IPCResourceLoaderBridge::SetRequestBody( 167 ResourceRequestBody* request_body) { 168 DCHECK(request_id_ == -1) << "request already started"; 169 request_.request_body = request_body; 170 } 171 172 // Writes a footer on the message and sends it 173 bool IPCResourceLoaderBridge::Start(RequestPeer* peer) { 174 if (request_id_ != -1) { 175 NOTREACHED() << "Starting a request twice"; 176 return false; 177 } 178 179 // generate the request ID, and append it to the message 180 request_id_ = dispatcher_->AddPendingRequest(peer, 181 request_.resource_type, 182 request_.origin_pid, 183 frame_origin_, 184 request_.url, 185 request_.download_to_file); 186 187 return dispatcher_->message_sender()->Send( 188 new ResourceHostMsg_RequestResource(routing_id_, request_id_, request_)); 189 } 190 191 void IPCResourceLoaderBridge::Cancel() { 192 if (request_id_ < 0) { 193 NOTREACHED() << "Trying to cancel an unstarted request"; 194 return; 195 } 196 197 if (!is_synchronous_request_) { 198 // This also removes the the request from the dispatcher. 199 dispatcher_->CancelPendingRequest(request_id_); 200 } 201 } 202 203 void IPCResourceLoaderBridge::SetDefersLoading(bool value) { 204 if (request_id_ < 0) { 205 NOTREACHED() << "Trying to (un)defer an unstarted request"; 206 return; 207 } 208 209 dispatcher_->SetDefersLoading(request_id_, value); 210 } 211 212 void IPCResourceLoaderBridge::DidChangePriority( 213 net::RequestPriority new_priority, 214 int intra_priority_value) { 215 if (request_id_ < 0) { 216 NOTREACHED() << "Trying to change priority of an unstarted request"; 217 return; 218 } 219 220 dispatcher_->DidChangePriority( 221 request_id_, new_priority, intra_priority_value); 222 } 223 224 bool IPCResourceLoaderBridge::AttachThreadedDataReceiver( 225 blink::WebThreadedDataReceiver* threaded_data_receiver) { 226 if (request_id_ < 0) { 227 NOTREACHED() << "Trying to attach threaded receiver on unstarted request"; 228 return false; 229 } 230 231 return dispatcher_->AttachThreadedDataReceiver(request_id_, 232 threaded_data_receiver); 233 } 234 235 void IPCResourceLoaderBridge::SyncLoad(SyncLoadResponse* response) { 236 if (request_id_ != -1) { 237 NOTREACHED() << "Starting a request twice"; 238 response->error_code = net::ERR_FAILED; 239 return; 240 } 241 242 request_id_ = MakeRequestID(); 243 is_synchronous_request_ = true; 244 245 SyncLoadResult result; 246 IPC::SyncMessage* msg = new ResourceHostMsg_SyncLoad(routing_id_, request_id_, 247 request_, &result); 248 // NOTE: This may pump events (see RenderThread::Send). 249 if (!dispatcher_->message_sender()->Send(msg)) { 250 response->error_code = net::ERR_FAILED; 251 return; 252 } 253 254 response->error_code = result.error_code; 255 response->url = result.final_url; 256 response->headers = result.headers; 257 response->mime_type = result.mime_type; 258 response->charset = result.charset; 259 response->request_time = result.request_time; 260 response->response_time = result.response_time; 261 response->encoded_data_length = result.encoded_data_length; 262 response->load_timing = result.load_timing; 263 response->devtools_info = result.devtools_info; 264 response->data.swap(result.data); 265 response->download_file_path = result.download_file_path; 266 } 267 268 // ResourceDispatcher --------------------------------------------------------- 269 270 ResourceDispatcher::ResourceDispatcher(IPC::Sender* sender) 271 : message_sender_(sender), 272 delegate_(NULL), 273 io_timestamp_(base::TimeTicks()), 274 weak_factory_(this) { 275 } 276 277 ResourceDispatcher::~ResourceDispatcher() { 278 } 279 280 // ResourceDispatcher implementation ------------------------------------------ 281 282 bool ResourceDispatcher::OnMessageReceived(const IPC::Message& message) { 283 if (!IsResourceDispatcherMessage(message)) { 284 return false; 285 } 286 287 int request_id; 288 289 PickleIterator iter(message); 290 if (!message.ReadInt(&iter, &request_id)) { 291 NOTREACHED() << "malformed resource message"; 292 return true; 293 } 294 295 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 296 if (!request_info) { 297 // Release resources in the message if it is a data message. 298 ReleaseResourcesInDataMessage(message); 299 return true; 300 } 301 302 if (request_info->is_deferred) { 303 request_info->deferred_message_queue.push_back(new IPC::Message(message)); 304 return true; 305 } 306 // Make sure any deferred messages are dispatched before we dispatch more. 307 if (!request_info->deferred_message_queue.empty()) { 308 FlushDeferredMessages(request_id); 309 // The request could have been deferred now. If yes then the current 310 // message has to be queued up. The request_info instance should remain 311 // valid here as there are pending messages for it. 312 DCHECK(pending_requests_.find(request_id) != pending_requests_.end()); 313 if (request_info->is_deferred) { 314 request_info->deferred_message_queue.push_back(new IPC::Message(message)); 315 return true; 316 } 317 } 318 319 DispatchMessage(message); 320 return true; 321 } 322 323 ResourceDispatcher::PendingRequestInfo* 324 ResourceDispatcher::GetPendingRequestInfo(int request_id) { 325 PendingRequestList::iterator it = pending_requests_.find(request_id); 326 if (it == pending_requests_.end()) { 327 // This might happen for kill()ed requests on the webkit end. 328 return NULL; 329 } 330 return &(it->second); 331 } 332 333 void ResourceDispatcher::OnUploadProgress(int request_id, int64 position, 334 int64 size) { 335 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 336 if (!request_info) 337 return; 338 339 request_info->peer->OnUploadProgress(position, size); 340 341 // Acknowledge receipt 342 message_sender_->Send(new ResourceHostMsg_UploadProgress_ACK(request_id)); 343 } 344 345 void ResourceDispatcher::OnReceivedResponse( 346 int request_id, const ResourceResponseHead& response_head) { 347 TRACE_EVENT0("loader", "ResourceDispatcher::OnReceivedResponse"); 348 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 349 if (!request_info) 350 return; 351 request_info->response_start = ConsumeIOTimestamp(); 352 353 if (delegate_) { 354 RequestPeer* new_peer = 355 delegate_->OnReceivedResponse( 356 request_info->peer, response_head.mime_type, request_info->url); 357 if (new_peer) 358 request_info->peer = new_peer; 359 } 360 361 // Updates the response_url if the response was fetched by a ServiceWorker, 362 // and it was not generated inside the ServiceWorker. 363 if (response_head.was_fetched_via_service_worker && 364 !response_head.original_url_via_service_worker.is_empty()) { 365 request_info->response_url = response_head.original_url_via_service_worker; 366 } 367 368 ResourceResponseInfo renderer_response_info; 369 ToResourceResponseInfo(*request_info, response_head, &renderer_response_info); 370 request_info->site_isolation_metadata = 371 SiteIsolationPolicy::OnReceivedResponse(request_info->frame_origin, 372 request_info->response_url, 373 request_info->resource_type, 374 request_info->origin_pid, 375 renderer_response_info); 376 request_info->peer->OnReceivedResponse(renderer_response_info); 377 } 378 379 void ResourceDispatcher::OnReceivedCachedMetadata( 380 int request_id, const std::vector<char>& data) { 381 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 382 if (!request_info) 383 return; 384 385 if (data.size()) 386 request_info->peer->OnReceivedCachedMetadata(&data.front(), data.size()); 387 } 388 389 void ResourceDispatcher::OnSetDataBuffer(int request_id, 390 base::SharedMemoryHandle shm_handle, 391 int shm_size, 392 base::ProcessId renderer_pid) { 393 TRACE_EVENT0("loader", "ResourceDispatcher::OnSetDataBuffer"); 394 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 395 if (!request_info) 396 return; 397 398 bool shm_valid = base::SharedMemory::IsHandleValid(shm_handle); 399 CHECK((shm_valid && shm_size > 0) || (!shm_valid && !shm_size)); 400 401 request_info->buffer.reset( 402 new base::SharedMemory(shm_handle, true)); // read only 403 404 bool ok = request_info->buffer->Map(shm_size); 405 if (!ok) { 406 // Added to help debug crbug/160401. 407 base::ProcessId renderer_pid_copy = renderer_pid; 408 base::debug::Alias(&renderer_pid_copy); 409 410 base::SharedMemoryHandle shm_handle_copy = shm_handle; 411 base::debug::Alias(&shm_handle_copy); 412 413 CrashOnMapFailure(); 414 return; 415 } 416 417 request_info->buffer_size = shm_size; 418 } 419 420 void ResourceDispatcher::OnReceivedData(int request_id, 421 int data_offset, 422 int data_length, 423 int encoded_data_length) { 424 TRACE_EVENT0("loader", "ResourceDispatcher::OnReceivedData"); 425 DCHECK_GT(data_length, 0); 426 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 427 bool send_ack = true; 428 if (request_info && data_length > 0) { 429 CHECK(base::SharedMemory::IsHandleValid(request_info->buffer->handle())); 430 CHECK_GE(request_info->buffer_size, data_offset + data_length); 431 432 // Ensure that the SHM buffer remains valid for the duration of this scope. 433 // It is possible for CancelPendingRequest() to be called before we exit 434 // this scope. 435 linked_ptr<base::SharedMemory> retain_buffer(request_info->buffer); 436 437 base::TimeTicks time_start = base::TimeTicks::Now(); 438 439 const char* data_start = static_cast<char*>(request_info->buffer->memory()); 440 CHECK(data_start); 441 CHECK(data_start + data_offset); 442 const char* data_ptr = data_start + data_offset; 443 444 // Check whether this response data is compliant with our cross-site 445 // document blocking policy. We only do this for the first packet. 446 std::string alternative_data; 447 if (request_info->site_isolation_metadata.get()) { 448 request_info->blocked_response = 449 SiteIsolationPolicy::ShouldBlockResponse( 450 request_info->site_isolation_metadata, data_ptr, data_length, 451 &alternative_data); 452 request_info->site_isolation_metadata.reset(); 453 454 // When the response is blocked we may have any alternative data to 455 // send to the renderer. When |alternative_data| is zero-sized, we do not 456 // call peer's callback. 457 if (request_info->blocked_response && !alternative_data.empty()) { 458 data_ptr = alternative_data.data(); 459 data_length = alternative_data.size(); 460 encoded_data_length = alternative_data.size(); 461 } 462 } 463 464 if (!request_info->blocked_response || !alternative_data.empty()) { 465 if (request_info->threaded_data_provider) { 466 request_info->threaded_data_provider->OnReceivedDataOnForegroundThread( 467 data_ptr, data_length, encoded_data_length); 468 // A threaded data provider will take care of its own ACKing, as the 469 // data may be processed later on another thread. 470 send_ack = false; 471 } else { 472 request_info->peer->OnReceivedData( 473 data_ptr, data_length, encoded_data_length); 474 } 475 } 476 477 UMA_HISTOGRAM_TIMES("ResourceDispatcher.OnReceivedDataTime", 478 base::TimeTicks::Now() - time_start); 479 } 480 481 // Acknowledge the reception of this data. 482 if (send_ack) 483 message_sender_->Send(new ResourceHostMsg_DataReceived_ACK(request_id)); 484 } 485 486 void ResourceDispatcher::OnDownloadedData(int request_id, 487 int data_len, 488 int encoded_data_length) { 489 // Acknowledge the reception of this message. 490 message_sender_->Send(new ResourceHostMsg_DataDownloaded_ACK(request_id)); 491 492 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 493 if (!request_info) 494 return; 495 496 request_info->peer->OnDownloadedData(data_len, encoded_data_length); 497 } 498 499 void ResourceDispatcher::OnReceivedRedirect( 500 int request_id, 501 const net::RedirectInfo& redirect_info, 502 const ResourceResponseHead& response_head) { 503 TRACE_EVENT0("loader", "ResourceDispatcher::OnReceivedRedirect"); 504 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 505 if (!request_info) 506 return; 507 request_info->response_start = ConsumeIOTimestamp(); 508 509 ResourceResponseInfo renderer_response_info; 510 ToResourceResponseInfo(*request_info, response_head, &renderer_response_info); 511 if (request_info->peer->OnReceivedRedirect(redirect_info, 512 renderer_response_info)) { 513 // Double-check if the request is still around. The call above could 514 // potentially remove it. 515 request_info = GetPendingRequestInfo(request_id); 516 if (!request_info) 517 return; 518 // We update the response_url here so that we can send it to 519 // SiteIsolationPolicy later when OnReceivedResponse is called. 520 request_info->response_url = redirect_info.new_url; 521 request_info->pending_redirect_message.reset( 522 new ResourceHostMsg_FollowRedirect(request_id)); 523 if (!request_info->is_deferred) { 524 FollowPendingRedirect(request_id, *request_info); 525 } 526 } else { 527 CancelPendingRequest(request_id); 528 } 529 } 530 531 void ResourceDispatcher::FollowPendingRedirect( 532 int request_id, 533 PendingRequestInfo& request_info) { 534 IPC::Message* msg = request_info.pending_redirect_message.release(); 535 if (msg) 536 message_sender_->Send(msg); 537 } 538 539 void ResourceDispatcher::OnRequestComplete( 540 int request_id, 541 const ResourceMsg_RequestCompleteData& request_complete_data) { 542 TRACE_EVENT0("loader", "ResourceDispatcher::OnRequestComplete"); 543 544 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 545 if (!request_info) 546 return; 547 request_info->completion_time = ConsumeIOTimestamp(); 548 request_info->buffer.reset(); 549 request_info->buffer_size = 0; 550 551 RequestPeer* peer = request_info->peer; 552 553 if (delegate_) { 554 RequestPeer* new_peer = 555 delegate_->OnRequestComplete( 556 request_info->peer, request_info->resource_type, 557 request_complete_data.error_code); 558 if (new_peer) 559 request_info->peer = new_peer; 560 } 561 562 base::TimeTicks renderer_completion_time = ToRendererCompletionTime( 563 *request_info, request_complete_data.completion_time); 564 // The request ID will be removed from our pending list in the destructor. 565 // Normally, dispatching this message causes the reference-counted request to 566 // die immediately. 567 peer->OnCompletedRequest(request_complete_data.error_code, 568 request_complete_data.was_ignored_by_handler, 569 request_complete_data.exists_in_cache, 570 request_complete_data.security_info, 571 renderer_completion_time, 572 request_complete_data.encoded_data_length); 573 } 574 575 int ResourceDispatcher::AddPendingRequest(RequestPeer* callback, 576 ResourceType resource_type, 577 int origin_pid, 578 const GURL& frame_origin, 579 const GURL& request_url, 580 bool download_to_file) { 581 // Compute a unique request_id for this renderer process. 582 int id = MakeRequestID(); 583 pending_requests_[id] = PendingRequestInfo(callback, 584 resource_type, 585 origin_pid, 586 frame_origin, 587 request_url, 588 download_to_file); 589 return id; 590 } 591 592 bool ResourceDispatcher::RemovePendingRequest(int request_id) { 593 PendingRequestList::iterator it = pending_requests_.find(request_id); 594 if (it == pending_requests_.end()) 595 return false; 596 597 PendingRequestInfo& request_info = it->second; 598 599 bool release_downloaded_file = request_info.download_to_file; 600 601 ReleaseResourcesInMessageQueue(&request_info.deferred_message_queue); 602 pending_requests_.erase(it); 603 604 if (release_downloaded_file) { 605 message_sender_->Send( 606 new ResourceHostMsg_ReleaseDownloadedFile(request_id)); 607 } 608 609 return true; 610 } 611 612 void ResourceDispatcher::CancelPendingRequest(int request_id) { 613 PendingRequestList::iterator it = pending_requests_.find(request_id); 614 if (it == pending_requests_.end()) { 615 DVLOG(1) << "unknown request"; 616 return; 617 } 618 619 // Cancel the request, and clean it up so the bridge will receive no more 620 // messages. 621 message_sender_->Send(new ResourceHostMsg_CancelRequest(request_id)); 622 RemovePendingRequest(request_id); 623 } 624 625 void ResourceDispatcher::SetDefersLoading(int request_id, bool value) { 626 PendingRequestList::iterator it = pending_requests_.find(request_id); 627 if (it == pending_requests_.end()) { 628 DLOG(ERROR) << "unknown request"; 629 return; 630 } 631 PendingRequestInfo& request_info = it->second; 632 if (value) { 633 request_info.is_deferred = value; 634 } else if (request_info.is_deferred) { 635 request_info.is_deferred = false; 636 637 FollowPendingRedirect(request_id, request_info); 638 639 base::MessageLoop::current()->PostTask( 640 FROM_HERE, 641 base::Bind(&ResourceDispatcher::FlushDeferredMessages, 642 weak_factory_.GetWeakPtr(), 643 request_id)); 644 } 645 } 646 647 void ResourceDispatcher::DidChangePriority(int request_id, 648 net::RequestPriority new_priority, 649 int intra_priority_value) { 650 DCHECK(ContainsKey(pending_requests_, request_id)); 651 message_sender_->Send(new ResourceHostMsg_DidChangePriority( 652 request_id, new_priority, intra_priority_value)); 653 } 654 655 bool ResourceDispatcher::AttachThreadedDataReceiver( 656 int request_id, blink::WebThreadedDataReceiver* threaded_data_receiver) { 657 PendingRequestInfo* request_info = GetPendingRequestInfo(request_id); 658 DCHECK(request_info); 659 660 if (request_info->buffer != NULL) { 661 DCHECK(!request_info->threaded_data_provider); 662 request_info->threaded_data_provider = new ThreadedDataProvider( 663 request_id, threaded_data_receiver, request_info->buffer, 664 request_info->buffer_size); 665 return true; 666 } 667 668 return false; 669 } 670 671 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo() 672 : peer(NULL), 673 threaded_data_provider(NULL), 674 resource_type(RESOURCE_TYPE_SUB_RESOURCE), 675 is_deferred(false), 676 download_to_file(false), 677 blocked_response(false), 678 buffer_size(0) { 679 } 680 681 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo( 682 RequestPeer* peer, 683 ResourceType resource_type, 684 int origin_pid, 685 const GURL& frame_origin, 686 const GURL& request_url, 687 bool download_to_file) 688 : peer(peer), 689 threaded_data_provider(NULL), 690 resource_type(resource_type), 691 origin_pid(origin_pid), 692 is_deferred(false), 693 url(request_url), 694 frame_origin(frame_origin), 695 response_url(request_url), 696 download_to_file(download_to_file), 697 request_start(base::TimeTicks::Now()), 698 blocked_response(false) {} 699 700 ResourceDispatcher::PendingRequestInfo::~PendingRequestInfo() { 701 if (threaded_data_provider) 702 threaded_data_provider->Stop(); 703 } 704 705 void ResourceDispatcher::DispatchMessage(const IPC::Message& message) { 706 IPC_BEGIN_MESSAGE_MAP(ResourceDispatcher, message) 707 IPC_MESSAGE_HANDLER(ResourceMsg_UploadProgress, OnUploadProgress) 708 IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedResponse, OnReceivedResponse) 709 IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedCachedMetadata, 710 OnReceivedCachedMetadata) 711 IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedRedirect, OnReceivedRedirect) 712 IPC_MESSAGE_HANDLER(ResourceMsg_SetDataBuffer, OnSetDataBuffer) 713 IPC_MESSAGE_HANDLER(ResourceMsg_DataReceived, OnReceivedData) 714 IPC_MESSAGE_HANDLER(ResourceMsg_DataDownloaded, OnDownloadedData) 715 IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestComplete) 716 IPC_END_MESSAGE_MAP() 717 } 718 719 void ResourceDispatcher::FlushDeferredMessages(int request_id) { 720 PendingRequestList::iterator it = pending_requests_.find(request_id); 721 if (it == pending_requests_.end()) // The request could have become invalid. 722 return; 723 PendingRequestInfo& request_info = it->second; 724 if (request_info.is_deferred) 725 return; 726 // Because message handlers could result in request_info being destroyed, 727 // we need to work with a stack reference to the deferred queue. 728 MessageQueue q; 729 q.swap(request_info.deferred_message_queue); 730 while (!q.empty()) { 731 IPC::Message* m = q.front(); 732 q.pop_front(); 733 DispatchMessage(*m); 734 delete m; 735 // If this request is deferred in the context of the above message, then 736 // we should honor the same and stop dispatching further messages. 737 // We need to find the request again in the list as it may have completed 738 // by now and the request_info instance above may be invalid. 739 PendingRequestList::iterator index = pending_requests_.find(request_id); 740 if (index != pending_requests_.end()) { 741 PendingRequestInfo& pending_request = index->second; 742 if (pending_request.is_deferred) { 743 pending_request.deferred_message_queue.swap(q); 744 return; 745 } 746 } 747 } 748 } 749 750 ResourceLoaderBridge* ResourceDispatcher::CreateBridge( 751 const RequestInfo& request_info) { 752 return new IPCResourceLoaderBridge(this, request_info); 753 } 754 755 void ResourceDispatcher::ToResourceResponseInfo( 756 const PendingRequestInfo& request_info, 757 const ResourceResponseHead& browser_info, 758 ResourceResponseInfo* renderer_info) const { 759 *renderer_info = browser_info; 760 if (request_info.request_start.is_null() || 761 request_info.response_start.is_null() || 762 browser_info.request_start.is_null() || 763 browser_info.response_start.is_null() || 764 browser_info.load_timing.request_start.is_null()) { 765 return; 766 } 767 InterProcessTimeTicksConverter converter( 768 LocalTimeTicks::FromTimeTicks(request_info.request_start), 769 LocalTimeTicks::FromTimeTicks(request_info.response_start), 770 RemoteTimeTicks::FromTimeTicks(browser_info.request_start), 771 RemoteTimeTicks::FromTimeTicks(browser_info.response_start)); 772 773 net::LoadTimingInfo* load_timing = &renderer_info->load_timing; 774 RemoteToLocalTimeTicks(converter, &load_timing->request_start); 775 RemoteToLocalTimeTicks(converter, &load_timing->proxy_resolve_start); 776 RemoteToLocalTimeTicks(converter, &load_timing->proxy_resolve_end); 777 RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.dns_start); 778 RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.dns_end); 779 RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.connect_start); 780 RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.connect_end); 781 RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.ssl_start); 782 RemoteToLocalTimeTicks(converter, &load_timing->connect_timing.ssl_end); 783 RemoteToLocalTimeTicks(converter, &load_timing->send_start); 784 RemoteToLocalTimeTicks(converter, &load_timing->send_end); 785 RemoteToLocalTimeTicks(converter, &load_timing->receive_headers_end); 786 RemoteToLocalTimeTicks(converter, 787 &renderer_info->service_worker_fetch_start); 788 RemoteToLocalTimeTicks(converter, 789 &renderer_info->service_worker_fetch_ready); 790 RemoteToLocalTimeTicks(converter, 791 &renderer_info->service_worker_fetch_end); 792 793 // Collect UMA on the inter-process skew. 794 bool is_skew_additive = false; 795 if (converter.IsSkewAdditiveForMetrics()) { 796 is_skew_additive = true; 797 base::TimeDelta skew = converter.GetSkewForMetrics(); 798 if (skew >= base::TimeDelta()) { 799 UMA_HISTOGRAM_TIMES( 800 "InterProcessTimeTicks.BrowserAhead_BrowserToRenderer", skew); 801 } else { 802 UMA_HISTOGRAM_TIMES( 803 "InterProcessTimeTicks.BrowserBehind_BrowserToRenderer", -skew); 804 } 805 } 806 UMA_HISTOGRAM_BOOLEAN( 807 "InterProcessTimeTicks.IsSkewAdditive_BrowserToRenderer", 808 is_skew_additive); 809 } 810 811 base::TimeTicks ResourceDispatcher::ToRendererCompletionTime( 812 const PendingRequestInfo& request_info, 813 const base::TimeTicks& browser_completion_time) const { 814 if (request_info.completion_time.is_null()) { 815 return browser_completion_time; 816 } 817 818 // TODO(simonjam): The optimal lower bound should be the most recent value of 819 // TimeTicks::Now() returned to WebKit. Is it worth trying to cache that? 820 // Until then, |response_start| is used as it is the most recent value 821 // returned for this request. 822 int64 result = std::max(browser_completion_time.ToInternalValue(), 823 request_info.response_start.ToInternalValue()); 824 result = std::min(result, request_info.completion_time.ToInternalValue()); 825 return base::TimeTicks::FromInternalValue(result); 826 } 827 828 base::TimeTicks ResourceDispatcher::ConsumeIOTimestamp() { 829 if (io_timestamp_ == base::TimeTicks()) 830 return base::TimeTicks::Now(); 831 base::TimeTicks result = io_timestamp_; 832 io_timestamp_ = base::TimeTicks(); 833 return result; 834 } 835 836 // static 837 bool ResourceDispatcher::IsResourceDispatcherMessage( 838 const IPC::Message& message) { 839 switch (message.type()) { 840 case ResourceMsg_UploadProgress::ID: 841 case ResourceMsg_ReceivedResponse::ID: 842 case ResourceMsg_ReceivedCachedMetadata::ID: 843 case ResourceMsg_ReceivedRedirect::ID: 844 case ResourceMsg_SetDataBuffer::ID: 845 case ResourceMsg_DataReceived::ID: 846 case ResourceMsg_DataDownloaded::ID: 847 case ResourceMsg_RequestComplete::ID: 848 return true; 849 850 default: 851 break; 852 } 853 854 return false; 855 } 856 857 // static 858 void ResourceDispatcher::ReleaseResourcesInDataMessage( 859 const IPC::Message& message) { 860 PickleIterator iter(message); 861 int request_id; 862 if (!message.ReadInt(&iter, &request_id)) { 863 NOTREACHED() << "malformed resource message"; 864 return; 865 } 866 867 // If the message contains a shared memory handle, we should close the handle 868 // or there will be a memory leak. 869 if (message.type() == ResourceMsg_SetDataBuffer::ID) { 870 base::SharedMemoryHandle shm_handle; 871 if (IPC::ParamTraits<base::SharedMemoryHandle>::Read(&message, 872 &iter, 873 &shm_handle)) { 874 if (base::SharedMemory::IsHandleValid(shm_handle)) 875 base::SharedMemory::CloseHandle(shm_handle); 876 } 877 } 878 } 879 880 // static 881 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) { 882 while (!queue->empty()) { 883 IPC::Message* message = queue->front(); 884 ReleaseResourcesInDataMessage(*message); 885 queue->pop_front(); 886 delete message; 887 } 888 } 889 890 } // namespace content 891
