| // Copyright 2019 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "content/renderer/loader/resource_load_stats.h" |
| |
| #include "base/metrics/histogram_macros.h" |
| #include "content/common/net/record_load_histograms.h" |
| #include "content/public/common/resource_load_info.mojom.h" |
| #include "content/renderer/render_frame_impl.h" |
| #include "content/renderer/render_thread_impl.h" |
| #include "services/network/public/cpp/resource_response.h" |
| #include "services/network/public/cpp/url_loader_completion_status.h" |
| |
| namespace content { |
| |
| namespace { |
| |
| #if defined(OS_ANDROID) |
| void UpdateUserGestureCarryoverInfo(int render_frame_id) { |
| RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(render_frame_id); |
| if (frame) |
| frame->GetFrameHost()->UpdateUserGestureCarryoverInfo(); |
| } |
| #endif |
| |
| void ResourceLoadStarted(int render_frame_id, |
| int request_id, |
| const GURL& response_url, |
| const network::ResourceResponseHead& response_head, |
| content::ResourceType resource_type) { |
| RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(render_frame_id); |
| if (!frame) |
| return; |
| if (!IsResourceTypeFrame(resource_type)) { |
| frame->GetFrameHost()->SubresourceResponseStarted( |
| response_url, response_head.cert_status); |
| } |
| frame->DidStartResponse(response_url, request_id, response_head, |
| resource_type); |
| } |
| |
| void ResourceTransferSizeUpdated(int render_frame_id, |
| int request_id, |
| int transfer_size_diff) { |
| RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(render_frame_id); |
| if (frame) |
| frame->DidReceiveTransferSizeUpdate(request_id, transfer_size_diff); |
| } |
| |
| void ResourceLoadCompleted(int render_frame_id, |
| mojom::ResourceLoadInfoPtr resource_load_info, |
| const network::URLLoaderCompletionStatus& status) { |
| RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(render_frame_id); |
| if (!frame) |
| return; |
| frame->DidCompleteResponse(resource_load_info->request_id, status); |
| frame->GetFrameHost()->ResourceLoadComplete(std::move(resource_load_info)); |
| } |
| |
| void ResourceLoadCanceled(int render_frame_id, int request_id) { |
| RenderFrameImpl* frame = RenderFrameImpl::FromRoutingID(render_frame_id); |
| if (frame) |
| frame->DidCancelResponse(request_id); |
| } |
| |
| } // namespace |
| |
| #if defined(OS_ANDROID) |
| void NotifyUpdateUserGestureCarryoverInfo(int render_frame_id) { |
| auto task_runner = RenderThreadImpl::DeprecatedGetMainTaskRunner(); |
| if (!task_runner) |
| return; |
| if (task_runner->BelongsToCurrentThread()) { |
| UpdateUserGestureCarryoverInfo(render_frame_id); |
| return; |
| } |
| task_runner->PostTask( |
| FROM_HERE, |
| base::BindOnce(UpdateUserGestureCarryoverInfo, render_frame_id)); |
| } |
| #endif |
| |
| void NotifyResourceLoadStarted( |
| int render_frame_id, |
| int request_id, |
| const GURL& response_url, |
| const network::ResourceResponseHead& response_head, |
| content::ResourceType resource_type) { |
| if (response_head.network_accessed) { |
| if (resource_type == RESOURCE_TYPE_MAIN_FRAME) { |
| UMA_HISTOGRAM_ENUMERATION("Net.ConnectionInfo.MainFrame", |
| response_head.connection_info, |
| net::HttpResponseInfo::NUM_OF_CONNECTION_INFOS); |
| } else { |
| UMA_HISTOGRAM_ENUMERATION("Net.ConnectionInfo.SubResource", |
| response_head.connection_info, |
| net::HttpResponseInfo::NUM_OF_CONNECTION_INFOS); |
| } |
| } |
| |
| auto task_runner = RenderThreadImpl::DeprecatedGetMainTaskRunner(); |
| if (!task_runner) |
| return; |
| if (task_runner->BelongsToCurrentThread()) { |
| ResourceLoadStarted(render_frame_id, request_id, response_url, |
| response_head, resource_type); |
| return; |
| } |
| |
| // Make a deep copy of ResourceResponseHead before passing it cross-thread. |
| auto resource_response = base::MakeRefCounted<network::ResourceResponse>(); |
| resource_response->head = response_head; |
| auto deep_copied_response = resource_response->DeepCopy(); |
| task_runner->PostTask( |
| FROM_HERE, |
| base::BindOnce(ResourceLoadStarted, render_frame_id, request_id, |
| response_url, deep_copied_response->head, resource_type)); |
| } |
| |
| void NotifyResourceTransferSizeUpdated(int render_frame_id, |
| int request_id, |
| int transfer_size_diff) { |
| auto task_runner = RenderThreadImpl::DeprecatedGetMainTaskRunner(); |
| if (!task_runner) |
| return; |
| if (task_runner->BelongsToCurrentThread()) { |
| ResourceTransferSizeUpdated(render_frame_id, request_id, |
| transfer_size_diff); |
| return; |
| } |
| task_runner->PostTask( |
| FROM_HERE, base::BindOnce(ResourceTransferSizeUpdated, render_frame_id, |
| request_id, transfer_size_diff)); |
| } |
| |
| void NotifyResourceLoadCompleted( |
| int render_frame_id, |
| mojom::ResourceLoadInfoPtr resource_load_info, |
| const network::URLLoaderCompletionStatus& status) { |
| RecordLoadHistograms(resource_load_info->url, |
| resource_load_info->resource_type, status.error_code); |
| |
| auto task_runner = RenderThreadImpl::DeprecatedGetMainTaskRunner(); |
| if (!task_runner) |
| return; |
| if (task_runner->BelongsToCurrentThread()) { |
| ResourceLoadCompleted(render_frame_id, std::move(resource_load_info), |
| status); |
| return; |
| } |
| task_runner->PostTask(FROM_HERE, |
| base::BindOnce(ResourceLoadCompleted, render_frame_id, |
| std::move(resource_load_info), status)); |
| } |
| |
| void NotifyResourceLoadCanceled(int render_frame_id, |
| int request_id, |
| const GURL& response_url, |
| ResourceType resource_type, |
| int net_error) { |
| RecordLoadHistograms(response_url, resource_type, net_error); |
| |
| auto task_runner = RenderThreadImpl::DeprecatedGetMainTaskRunner(); |
| if (!task_runner) |
| return; |
| if (task_runner->BelongsToCurrentThread()) { |
| ResourceLoadCanceled(render_frame_id, request_id); |
| return; |
| } |
| task_runner->PostTask(FROM_HERE, base::BindOnce(ResourceLoadCanceled, |
| render_frame_id, request_id)); |
| } |
| |
| } // namespace content |