1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_INSTRUMENTATION_H_
#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_INSTRUMENTATION_H_
/*
The functions in this file are for routing instrumentation signals
to the relevant set of devtools protocol handlers.
*/
#include <cstdint>
#include <optional>
#include <vector>
#include "base/memory/stack_allocated.h"
#include "base/values.h"
#include "content/browser/devtools/devtools_device_request_prompt_info.h"
#include "content/browser/devtools/devtools_throttle_handle.h"
#include "content/browser/interest_group/devtools_enums.h"
#include "content/browser/preloading/prefetch/prefetch_status.h"
#include "content/browser/preloading/prerender/prerender_final_status.h"
#include "content/browser/renderer_host/back_forward_cache_impl.h"
#include "content/browser/renderer_host/frame_tree.h"
#include "content/common/content_export.h"
#include "content/public/browser/certificate_request_result_type.h"
#include "content/public/browser/global_routing_id.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "net/cookies/cookie_setting_override.h"
#include "net/filter/source_stream_type.h"
#include "services/network/public/cpp/url_loader_completion_status.h"
#include "services/network/public/mojom/url_loader_factory.mojom.h"
#include "services/network/public/mojom/url_response_head.mojom-forward.h"
#include "third_party/blink/public/mojom/devtools/inspector_issue.mojom-forward.h"
#include "third_party/blink/public/mojom/navigation/navigation_params.mojom-forward.h"
#include "third_party/blink/public/mojom/speculation_rules/speculation_rules.mojom-forward.h"
class GURL;
namespace base {
class UnguessableToken;
}
namespace blink {
struct UserAgentMetadata;
}
namespace net {
class SSLInfo;
class X509Certificate;
struct WebTransportError;
} // namespace net
namespace network {
class URLLoaderFactoryBuilder;
} // namespace network
namespace download {
struct DownloadCreateInfo;
class DownloadItem;
class DownloadUrlParameters;
} // namespace download
namespace content {
class BackForwardCacheCanStoreDocumentResult;
class BrowserContext;
class DevToolsAgentHostImpl;
class FencedFrame;
class FrameTreeNode;
class NavigationRequest;
class RenderFrameHostImpl;
class RenderProcessHost;
class SharedWorkerHost;
class ServiceWorkerContextWrapper;
class SignedExchangeEnvelope;
class StoragePartition;
class WebContents;
struct PrerenderMismatchedHeaders;
struct SignedExchangeError;
namespace protocol::Audits {
class InspectorIssue;
} // namespace protocol::Audits
namespace devtools_instrumentation {
// Applies network request overrides to the auction worklet's network
// request. Will set `network_instrumentation_enabled` to true if there is a
// network handler listening. Also handles whether cache is disabled or not.
void ApplyAuctionNetworkRequestOverrides(FrameTreeNode* frame_tree_node,
network::ResourceRequest* request,
bool* network_instrumentation_enabled);
// If this function caused the User-Agent header to be overridden,
// `devtools_user_agent_overridden` will be set to true; otherwise, it will be
// set to false. If this function caused the Accept-Language header to be
// overridden, `devtools_accept_language_overridden` will be set to true;
// otherwise, it will be set to false.
void ApplyNetworkRequestOverrides(
FrameTreeNode* frame_tree_node,
blink::mojom::BeginNavigationParams* begin_params,
bool* report_raw_headers,
std::optional<std::vector<net::SourceStreamType>>*
devtools_accepted_stream_types,
bool* devtools_user_agent_overridden,
bool* devtools_accept_language_overridden);
// Returns true if devtools want |*override_out| to be used.
// (A true return and |*override_out| being nullopt means no user agent client
// hints should be sent; a false return means devtools doesn't want to affect
// the behavior).
bool ApplyUserAgentMetadataOverrides(
FrameTreeNode* frame_tree_node,
std::optional<blink::UserAgentMetadata>* override_out);
class WillCreateURLLoaderFactoryParams final {
STACK_ALLOCATED();
public:
static WillCreateURLLoaderFactoryParams ForFrame(RenderFrameHostImpl* rfh);
static WillCreateURLLoaderFactoryParams ForServiceWorker(
RenderProcessHost& rph,
int routing_id);
static std::optional<WillCreateURLLoaderFactoryParams>
ForServiceWorkerMainScript(const ServiceWorkerContextWrapper* context_wrapper,
std::optional<int64_t> version_id);
static std::optional<WillCreateURLLoaderFactoryParams> ForSharedWorker(
SharedWorkerHost* host);
static WillCreateURLLoaderFactoryParams ForWorkerMainScript(
DevToolsAgentHostImpl* agent_host,
const base::UnguessableToken& worker_token,
RenderFrameHostImpl& ancestor_render_frame_host);
// Calls devtools hooks so that they can add interceptors.
bool Run(bool is_navigation,
bool is_download,
network::URLLoaderFactoryBuilder& factory_builder,
network::mojom::URLLoaderFactoryOverridePtr* factory_override);
DevToolsAgentHostImpl* agent_host() { return agent_host_; }
private:
WillCreateURLLoaderFactoryParams(DevToolsAgentHostImpl* agent_host,
const base::UnguessableToken& devtools_token,
int process_id,
StoragePartition* storage_partition);
const raw_ptr<DevToolsAgentHostImpl> agent_host_;
const base::UnguessableToken devtools_token_;
const int process_id_;
const raw_ptr<StoragePartition> storage_partition_;
};
void OnResetNavigationRequest(NavigationRequest* navigation_request);
void MaybeAssignResourceRequestId(FrameTreeNode* ftn,
const std::string& id,
network::ResourceRequest& request);
void MaybeAssignResourceRequestId(FrameTreeNodeId frame_node_id,
const std::string& id,
network::ResourceRequest& request);
void OnNavigationRequestWillBeSent(const NavigationRequest& navigation_request);
void OnNavigationResponseReceived(
const NavigationRequest& nav_request,
const network::mojom::URLResponseHead& response);
void OnNavigationRequestFailed(
const NavigationRequest& nav_request,
const network::URLLoaderCompletionStatus& status);
// Logs fetch keepalive requests proxied via browser to Network panel.
//
// As the implementation requires a RenderFrameHost to locate a
// RenderFrameDevToolsAgentHost to attach the logs to, `frame_free_node` must
// not be nullptr. This doesn't really fit the whole need as such requests may
// be sent after RenderFrameHost unload.
//
// Caller also needs to make sure to avoid duplicated logging that may already
// happens in the request initiator renderer.
void OnFetchKeepAliveRequestWillBeSent(
FrameTreeNode* frame_tree_node,
const std::string& request_id,
const network::ResourceRequest& request,
std::optional<std::pair<const GURL&,
const network::mojom::URLResponseHeadDevToolsInfo&>>
redirect_info = std::nullopt);
void OnFetchKeepAliveResponseReceived(
FrameTreeNode* frame_tree_node,
const std::string& request_id,
const GURL& url,
const network::mojom::URLResponseHead& head);
void OnFetchKeepAliveRequestComplete(
FrameTreeNode* frame_tree_node,
const std::string& request_id,
const network::URLLoaderCompletionStatus& status);
void OnAuctionWorkletNetworkRequestWillBeSent(
FrameTreeNodeId frame_tree_node_id,
const network::ResourceRequest& request,
base::TimeTicks timestamp);
void OnAuctionWorkletNetworkResponseReceived(
FrameTreeNodeId frame_tree_node_id,
const std::string& request_id,
const std::string& loader_id,
const GURL& request_url,
const network::mojom::URLResponseHead& headers);
void OnAuctionWorkletNetworkRequestComplete(
FrameTreeNodeId frame_tree_node_id,
const std::string& request_id,
const network::URLLoaderCompletionStatus& status);
bool NeedInterestGroupAuctionEvents(FrameTreeNodeId frame_tree_node_id);
void OnInterestGroupAuctionEventOccurred(
FrameTreeNodeId frame_tree_node_id,
base::Time event_time,
InterestGroupAuctionEventType type,
const std::string& unique_auction_id,
base::optional_ref<const std::string> parent_auction_id,
const base::Value::Dict& auction_config);
void OnInterestGroupAuctionNetworkRequestCreated(
FrameTreeNodeId frame_tree_node_id,
InterestGroupAuctionFetchType type,
const std::string& request_id,
const std::vector<std::string>& devtools_auction_ids);
bool ShouldBypassCSP(const NavigationRequest& nav_request);
bool ShouldBypassCertificateErrors();
void ApplyNetworkOverridesForDownload(
RenderFrameHostImpl* rfh,
download::DownloadUrlParameters* parameters);
void WillBeginDownload(download::DownloadCreateInfo* info,
download::DownloadItem* item);
void BackForwardCacheNotUsed(
const NavigationRequest* nav_request,
const BackForwardCacheCanStoreDocumentResult* result,
const BackForwardCacheCanStoreTreeResult* tree_result);
void WillSwapFrameTreeNode(FrameTreeNode& old_node, FrameTreeNode& new_node);
void OnFrameTreeNodeDestroyed(FrameTreeNode& frame_tree_node);
void DidUpdatePolicyContainerHost(FrameTreeNode* ftn);
// SpeculationRules
void DidUpdateSpeculationCandidates(
RenderFrameHost& rfh,
const std::vector<blink::mojom::SpeculationCandidatePtr>& candidates);
// Prefetch
void DidUpdatePrefetchStatus(
FrameTreeNode* ftn,
const base::UnguessableToken& initiator_devtools_navigation_token,
const GURL& prefetch_url,
const base::UnguessableToken& preload_pipeline_id,
PreloadingTriggeringOutcome status,
PrefetchStatus prefetch_status,
const std::string& request_id);
// CDP events Network.* for prefetch
void OnPrefetchRequestWillBeSent(
FrameTreeNode& ftn,
const std::string& request_id,
const GURL& initiator,
const network::ResourceRequest& request,
std::optional<std::pair<const GURL&,
const network::mojom::URLResponseHeadDevToolsInfo&>>
redirect_info);
void OnPrefetchResponseReceived(FrameTreeNode* frame_tree_node,
const std::string& request_id,
const GURL& url,
const network::mojom::URLResponseHead& head);
void OnPrefetchRequestComplete(
FrameTreeNode* frame_tree_node,
const std::string& request_id,
const network::URLLoaderCompletionStatus& status);
void OnPrefetchBodyDataReceived(FrameTreeNode* frame_tree_node,
const std::string& request_id,
const std::string& body,
bool is_base64_encoded);
// Prerender
bool IsPrerenderAllowed(FrameTree& frame_tree);
void WillInitiatePrerender(FrameTree& frame_tree);
void DidActivatePrerender(const NavigationRequest& nav_request,
const std::optional<base::UnguessableToken>&
initiator_devtools_navigation_token);
void DidUpdatePrerenderStatus(
FrameTreeNodeId initiator_frame_tree_node_id,
const base::UnguessableToken& initiator_devtools_navigation_token,
const GURL& prerender_url,
std::optional<blink::mojom::SpeculationTargetHint> target_hint,
const base::UnguessableToken& preload_pipeline_id,
PreloadingTriggeringOutcome status,
std::optional<PrerenderFinalStatus> prerender_status,
std::optional<std::string> disallowed_mojo_interface,
const std::vector<PrerenderMismatchedHeaders>* mismatched_headers);
void OnSignedExchangeReceived(
FrameTreeNode* frame_tree_node,
std::optional<const base::UnguessableToken> devtools_navigation_token,
const GURL& outer_request_url,
const network::mojom::URLResponseHead& outer_response,
const std::optional<SignedExchangeEnvelope>& header,
const scoped_refptr<net::X509Certificate>& certificate,
const std::optional<net::SSLInfo>& ssl_info,
const std::vector<SignedExchangeError>& errors);
void OnSignedExchangeCertificateRequestSent(
FrameTreeNode* frame_tree_node,
const base::UnguessableToken& request_id,
const base::UnguessableToken& loader_id,
const network::ResourceRequest& request,
const GURL& signed_exchange_url);
void OnSignedExchangeCertificateResponseReceived(
FrameTreeNode* frame_tree_node,
const base::UnguessableToken& request_id,
const base::UnguessableToken& loader_id,
const GURL& url,
const network::mojom::URLResponseHead& head);
void OnSignedExchangeCertificateRequestCompleted(
FrameTreeNode* frame_tree_node,
const base::UnguessableToken& request_id,
const network::URLLoaderCompletionStatus& status);
void CreateAndAddNavigationThrottles(NavigationThrottleRegistry& registry);
// When registering a new ServiceWorker with PlzServiceWorker, the main script
// fetch happens before starting the worker. This means that we need to give
// TargetHandlers the opportunity to attach to newly created ServiceWorker
// before the script fetch begins if they specified blocking auto-attach
// properties. The `throttle` controls when the script fetch resumes.
//
// Note on the input parameters:
// - `wrapper` and `version_id` are used to identify an existing newly
// installing service worker agent. It is expected to exist.
// - `requesting_frame_id` is required, because the auto attacher is the one of
// the frame registering the worker.
void ThrottleServiceWorkerMainScriptFetch(
ServiceWorkerContextWrapper* wrapper,
int64_t version_id,
const GlobalRenderFrameHostId& requesting_frame_id,
scoped_refptr<DevToolsThrottleHandle> throttle_handle);
// When creating a new DedicatedWorker, the worker script fetch happens before
// starting the worker. This function is called when DedicatedWorkerHost, which
// is the representation of a worker in the browser process, is created.
// `throttle_handle` controls when the script fetch resumes.
void ThrottleWorkerMainScriptFetch(
const base::UnguessableToken& devtools_worker_token,
const GlobalRenderFrameHostId& ancestor_render_frame_host_id,
scoped_refptr<DevToolsThrottleHandle> throttle_handle);
bool ShouldWaitForDebuggerInWindowOpen();
void WillStartDragging(FrameTreeNode* main_frame_tree_node,
const DropData& drop_data,
const blink::mojom::DragDataPtr drag_data,
blink::DragOperationsMask drag_operations_mask,
bool* intercepted);
void DragEnded(FrameTreeNode& node);
// Asks any interested agents to handle the given certificate error. Returns
// |true| if the error was handled, |false| otherwise.
using CertErrorCallback =
base::RepeatingCallback<void(CertificateRequestResultType)>;
bool HandleCertificateError(WebContents* web_contents,
int cert_error,
const GURL& request_url,
CertErrorCallback callback);
void FencedFrameCreated(
base::SafeRef<RenderFrameHostImpl> owner_render_frame_host,
FencedFrame* fenced_frame);
void ReportCookieIssue(
RenderFrameHostImpl* render_frame_host_impl,
const network::mojom::CookieOrLineWithAccessResultPtr& excluded_cookie,
const GURL& url,
const net::SiteForCookies& site_for_cookies,
blink::mojom::CookieOperation operation,
const std::optional<std::string>& devtools_request_id,
const std::optional<std::string>& devtools_issue_id);
// This function works similar to RenderFrameHostImpl::AddInspectorIssue, in
// that it reports an InspectorIssue to DevTools clients. The difference is that
// |ReportBrowserInitiatedIssue| sends issues directly to clients instead of
// going through the issue storage in the renderer process. Sending issues
// directly prevents them from being (potentially) lost during navigations.
//
// DevTools must be attached, otherwise issues reported through
// |ReportBrowserInitiatedIssue| are lost.
void CONTENT_EXPORT
ReportBrowserInitiatedIssue(RenderFrameHostImpl* frame,
protocol::Audits::InspectorIssue* issue);
// Produces an inspector issue and sends it to the client with
// |ReportBrowserInitiatedIssue|.
void BuildAndReportBrowserInitiatedIssue(
RenderFrameHostImpl* frame,
blink::mojom::InspectorIssueInfoPtr info);
void OnWebTransportHandshakeFailed(
RenderFrameHostImpl* frame_host,
const GURL& url,
const std::optional<net::WebTransportError>& error);
void OnServiceWorkerMainScriptFetchingFailed(
const GlobalRenderFrameHostId& requesting_frame_id,
const ServiceWorkerContextWrapper* context_wrapper,
int64_t version_id,
const std::string& error,
const network::URLLoaderCompletionStatus& status,
const network::mojom::URLResponseHead* response_head,
const GURL& url);
void OnServiceWorkerMainScriptRequestWillBeSent(
const GlobalRenderFrameHostId& requesting_frame_id,
const ServiceWorkerContextWrapper* context_wrapper,
int64_t version_id,
network::ResourceRequest& request);
// Fires `Network.onRequestWillBeSent` event for a dedicated worker and shared
// worker main script. Used for DedicatedWorker and SharedWorker.
void OnWorkerMainScriptRequestWillBeSent(
RenderFrameHostImpl& ancestor_frame_host,
const base::UnguessableToken& worker_token,
network::ResourceRequest& request);
// Fires `Network.onLoadingFailed` event for a DedicatedWorker main script.
void OnWorkerMainScriptLoadingFailed(
const GURL& url,
const base::UnguessableToken& worker_token,
FrameTreeNode* ftn,
RenderFrameHostImpl* ancestor_rfh,
const network::URLLoaderCompletionStatus& status);
// Adds a message from a worklet to the devtools console. This is specific to
// FLEDGE auction worklet and shared storage worklet where the message may
// contain sensitive cross-origin information, and therefore the devtools
// logging needs to bypass the usual path through the renderer.
void CONTENT_EXPORT
LogWorkletMessage(RenderFrameHostImpl& frame_host,
blink::mojom::ConsoleMessageLevel log_level,
const std::string& message);
void ApplyNetworkContextParamsOverrides(
BrowserContext* browser_context,
network::mojom::NetworkContextParams* network_context_params);
void DidRejectCrossOriginPortalMessage(
RenderFrameHostImpl* render_frame_host_impl);
void UpdateDeviceRequestPrompt(RenderFrameHost* render_frame_host,
DevtoolsDeviceRequestPromptInfo* prompt_info);
void CleanUpDeviceRequestPrompt(RenderFrameHost* render_frame_host,
DevtoolsDeviceRequestPromptInfo* prompt_info);
// Notifies the active FedCmHandlers that a FedCM request is starting.
// `intercept` should be set to true if the handler is active.
// `disable_delay` should be set to true if the handler wants to disable
// the normal FedCM delay in notifying the renderer of success/failure.
void WillSendFedCmRequest(RenderFrameHost& render_frame_host,
bool* intercept,
bool* disable_delay);
void WillShowFedCmDialog(RenderFrameHost& render_frame_host, bool* intercept);
void DidShowFedCmDialog(RenderFrameHost& render_frame_host);
void DidCloseFedCmDialog(RenderFrameHost& render_frame_host);
// Fires Network Handler to capture FedCM request and response events.
void WillSendFedCmNetworkRequest(FrameTreeNodeId frame_tree_node_id,
const network::ResourceRequest& request);
void DidReceiveFedCmNetworkResponse(
FrameTreeNodeId frame_tree_node_id,
const std::string& devtools_request_id,
const GURL& url,
const network::mojom::URLResponseHead* response_head,
const std::string& response_body,
const network::URLLoaderCompletionStatus& status);
// Handles dev tools integration for fenced frame reporting beacons. Used in
// `FencedFrameReporter`.
void OnFencedFrameReportRequestSent(
FrameTreeNodeId initiator_frame_tree_node_id,
const std::string& devtools_request_id,
network::ResourceRequest& request,
const std::string& event_data);
void OnFencedFrameReportResponseReceived(
FrameTreeNodeId initiator_frame_tree_node_id,
const std::string& devtools_request_id,
const GURL& final_url,
scoped_refptr<net::HttpResponseHeaders> headers);
void DidChangeFrameLoadingState(FrameTreeNode& ftn);
void DidStartNavigating(FrameTreeNode& ftn,
const GURL& url,
const base::UnguessableToken& loader_id,
const blink::mojom::NavigationType& navigation_type);
// Returns true if devtools wants to override the cookie settings.
bool ApplyNetworkCookieControlsOverrides(
RenderFrameHostImpl& rfh,
net::CookieSettingOverrides& overrides);
bool ApplyNetworkCookieControlsOverrides(
DevToolsAgentHostImpl* params,
net::CookieSettingOverrides& overrides);
} // namespace devtools_instrumentation
} // namespace content
#endif // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_INSTRUMENTATION_H_
|