// Copyright 2014 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "content/browser/renderer_host/navigation_request.h" #include #include #include #include #include #include #include #include "base/auto_reset.h" #include "base/byte_size.h" #include "base/check.h" #include "base/check_is_test.h" #include "base/check_op.h" #include "base/command_line.h" #include "base/containers/span.h" #include "base/debug/alias.h" #include "base/debug/crash_logging.h" #include "base/debug/dump_without_crashing.h" #include "base/feature_list.h" #include "base/files/file_path.h" #include "base/functional/bind.h" #include "base/memory/ptr_util.h" #include "base/memory/safe_ref.h" #include "base/metrics/field_trial_params.h" #include "base/metrics/histogram_functions.h" #include "base/metrics/histogram_macros.h" #include "base/metrics/user_metrics.h" #include "base/no_destructor.h" #include "base/not_fatal_until.h" #include "base/notreached.h" #include "base/numerics/safe_conversions.h" #include "base/rand_util.h" #include "base/state_transitions.h" #include "base/strings/strcat.h" #include "base/strings/string_util.h" #include "base/strings/stringprintf.h" #include "base/system/sys_info.h" #include "base/task/sequenced_task_runner.h" #include "base/time/time.h" #include "base/timer/elapsed_timer.h" #include "base/trace_event/trace_event.h" #include "base/types/optional_util.h" #include "base/types/pass_key.h" #include "build/build_config.h" #include "build/buildflag.h" #include "components/viz/host/host_frame_sink_manager.h" #include "content/browser/agent_cluster_key.h" #include "content/browser/back_forward_cache/back_forward_cache_impl.h" #include "content/browser/bad_message.h" #include "content/browser/blob_storage/chrome_blob_storage_context.h" #include "content/browser/client_hints/client_hints.h" #include "content/browser/connection_allowlist_utils.h" #include "content/browser/declarative_performance_observer/declarative_performance_observer.h" #include "content/browser/devtools/devtools_instrumentation.h" #include "content/browser/devtools/network_service_devtools_observer.h" #include "content/browser/download/download_manager_impl.h" #include "content/browser/fenced_frame/fenced_frame_url_mapping.h" #include "content/browser/loader/browser_initiated_resource_request.h" #include "content/browser/loader/cached_navigation_url_loader.h" #include "content/browser/loader/navigation_early_hints_manager.h" #include "content/browser/loader/navigation_fast_fetch_manager.h" #include "content/browser/loader/navigation_url_loader.h" #include "content/browser/loader/object_navigation_fallback_body_loader.h" #include "content/browser/loader/url_loader_factory_utils.h" #include "content/browser/navigation_or_document_handle.h" #include "content/browser/network/cross_origin_embedder_policy_reporter.h" #include "content/browser/network_service_instance_impl.h" #include "content/browser/origin_agent_cluster_isolation_state.h" #include "content/browser/origin_trials/origin_trials_utils.h" #include "content/browser/permissions/permission_controller_impl.h" #include "content/browser/preloading/prefetch/prefetch_document_manager.h" #include "content/browser/preloading/prefetch/prefetch_features.h" #include "content/browser/preloading/preload_activation_report_manager.h" #include "content/browser/preloading/preload_activation_report_utils.h" #include "content/browser/preloading/prerender/prerender_host_registry.h" #include "content/browser/preloading/prerender/prerender_metrics.h" #include "content/browser/preloading/prerender/prerender_navigation_utils.h" #include "content/browser/process_lock.h" #include "content/browser/renderer_host/concurrent_navigations_commit_deferring_condition.h" #include "content/browser/renderer_host/cookie_utils.h" #include "content/browser/renderer_host/debug_urls.h" #include "content/browser/renderer_host/frame_navigation_entry.h" #include "content/browser/renderer_host/frame_tree.h" #include "content/browser/renderer_host/frame_tree_node.h" #include "content/browser/renderer_host/local_network_access_util.h" #include "content/browser/renderer_host/navigation_controller_impl.h" #include "content/browser/renderer_host/navigation_entry_impl.h" #include "content/browser/renderer_host/navigation_request_info.h" #include "content/browser/renderer_host/navigation_state_keep_alive.h" #include "content/browser/renderer_host/navigator.h" #include "content/browser/renderer_host/navigator_delegate.h" #include "content/browser/renderer_host/page_delegate.h" #include "content/browser/renderer_host/render_frame_host_csp_context.h" #include "content/browser/renderer_host/render_frame_host_delegate.h" #include "content/browser/renderer_host/render_frame_host_impl.h" #include "content/browser/renderer_host/render_frame_proxy_host.h" #include "content/browser/renderer_host/render_process_host_impl.h" #include "content/browser/renderer_host/render_view_host_delegate.h" #include "content/browser/renderer_host/render_view_host_impl.h" #include "content/browser/renderer_host/scoped_view_transition_resources.h" #include "content/browser/renderer_host/subframe_history_navigation_throttle.h" #include "content/browser/scoped_active_url.h" #include "content/browser/security/coop/cross_origin_opener_policy_reporter.h" #include "content/browser/security/cpsp/child_process_security_policy_impl.h" #include "content/browser/service_worker/service_worker_client.h" #include "content/browser/service_worker/service_worker_context_core.h" #include "content/browser/service_worker/service_worker_context_wrapper.h" #include "content/browser/service_worker/service_worker_main_resource_handle.h" #include "content/browser/site_info.h" #include "content/browser/site_instance_impl.h" #include "content/browser/storage_partition_impl.h" #include "content/browser/url_loader_factory_params_helper.h" #include "content/browser/web_package/prefetched_signed_exchange_cache.h" #include "content/common/content_constants_internal.h" #include "content/common/content_navigation_policy.h" #include "content/common/debug_utils.h" #include "content/common/features.h" #include "content/common/navigation_params_utils.h" #include "content/public/browser/browser_context.h" #include "content/public/browser/browser_task_traits.h" #include "content/public/browser/browser_thread.h" #include "content/public/browser/child_process_host.h" #include "content/public/browser/client_hints_controller_delegate.h" #include "content/public/browser/commit_deferring_condition.h" #include "content/public/browser/content_browser_client.h" #include "content/public/browser/cookie_access_details.h" #include "content/public/browser/direct_sockets_delegate.h" #include "content/public/browser/global_request_id.h" #include "content/public/browser/isolated_context_util.h" #include "content/public/browser/navigation_controller.h" #include "content/public/browser/navigation_ui_data.h" #include "content/public/browser/network_service_instance.h" #include "content/public/browser/network_service_util.h" #include "content/public/browser/origin_trials_controller_delegate.h" #include "content/public/browser/peak_gpu_memory_tracker_factory.h" #include "content/public/browser/reduce_accept_language_controller_delegate.h" #include "content/public/browser/reduce_accept_language_utils.h" #include "content/public/browser/render_view_host.h" #include "content/public/browser/runtime_feature_state/runtime_feature_state_document_data.h" #include "content/public/browser/security_principal.h" #include "content/public/browser/site_isolation_policy.h" #include "content/public/browser/storage_partition.h" #include "content/public/browser/tracing_support.h" #include "content/public/browser/weak_document_ptr.h" #include "content/public/common/content_client.h" #include "content/public/common/content_features.h" #include "content/public/common/content_switches.h" #include "content/public/common/origin_util.h" #include "content/public/common/url_constants.h" #include "content/public/common/url_utils.h" #include "mojo/public/cpp/bindings/pending_receiver.h" #include "mojo/public/cpp/system/data_pipe.h" #include "net/base/features.h" #include "net/base/filename_util.h" #include "net/base/ip_endpoint.h" #include "net/base/load_flags.h" #include "net/base/net_errors.h" #include "net/base/registry_controlled_domains/registry_controlled_domain.h" #include "net/base/url_util.h" #include "net/cookies/cookie_access_result.h" #include "net/cookies/cookie_setting_override.h" #include "net/filter/source_stream_type.h" #include "net/http/http_request_headers.h" #include "net/http/http_status_code.h" #include "net/storage_access_api/status.h" #include "net/url_request/redirect_info.h" #include "services/metrics/public/cpp/metrics_utils.h" #include "services/metrics/public/cpp/ukm_builders.h" #include "services/metrics/public/cpp/ukm_recorder.h" #include "services/metrics/public/cpp/ukm_source_id.h" #include "services/network/public/cpp/client_hints.h" #include "services/network/public/cpp/connection_allowlist.h" #include "services/network/public/cpp/connection_allowlist_parser.h" #include "services/network/public/cpp/constants.h" #include "services/network/public/cpp/content_decoding_interceptor.h" #include "services/network/public/cpp/content_security_policy/content_security_policy.h" #include "services/network/public/cpp/cross_origin_embedder_policy.h" #include "services/network/public/cpp/cross_origin_opener_policy.h" #include "services/network/public/cpp/cross_origin_resource_policy.h" #include "services/network/public/cpp/features.h" #include "services/network/public/cpp/header_util.h" #include "services/network/public/cpp/integrity_policy.h" #include "services/network/public/cpp/is_potentially_trustworthy.h" #include "services/network/public/cpp/permissions_policy/fenced_frame_permissions_policies.h" #include "services/network/public/cpp/permissions_policy/permissions_policy_declaration.h" #include "services/network/public/cpp/permissions_policy/permissions_policy_features.h" #include "services/network/public/cpp/resource_request_body.h" #include "services/network/public/cpp/supports_loading_mode/supports_loading_mode_parser.h" #include "services/network/public/cpp/url_loader_completion_status.h" #include "services/network/public/cpp/web_sandbox_flags.h" #include "services/network/public/mojom/connection_change_observer_client.mojom.h" #include "services/network/public/mojom/device_bound_sessions.mojom.h" #include "services/network/public/mojom/fetch_api.mojom.h" #include "services/network/public/mojom/link_header.mojom.h" #include "services/network/public/mojom/network_context.mojom.h" #include "services/network/public/mojom/permissions_policy/permissions_policy_feature.mojom-shared.h" #include "services/network/public/mojom/supports_loading_mode.mojom.h" #include "services/network/public/mojom/url_response_head.mojom.h" #include "services/network/public/mojom/web_client_hints_types.mojom.h" #include "services/network/public/mojom/web_sandbox_flags.mojom.h" #include "storage/browser/blob/blob_url_registry.h" #include "third_party/abseil-cpp/absl/cleanup/cleanup.h" #include "third_party/blink/public/common/blob/blob_utils.h" #include "third_party/blink/public/common/chrome_debug_urls.h" #include "third_party/blink/public/common/client_hints/client_hints.h" #include "third_party/blink/public/common/features.h" #include "third_party/blink/public/common/fenced_frame/fenced_frame_utils.h" #include "third_party/blink/public/common/fenced_frame/redacted_fenced_frame_config.h" #include "third_party/blink/public/common/frame/fenced_frame_sandbox_flags.h" #include "third_party/blink/public/common/frame/frame_owner_element_type.h" #include "third_party/blink/public/common/navigation/navigation_params.h" #include "third_party/blink/public/common/navigation/navigation_params_mojom_traits.h" #include "third_party/blink/public/common/navigation/navigation_policy.h" #include "third_party/blink/public/common/navigation/preloading_headers.h" #include "third_party/blink/public/common/origin_trials/trial_token_validator.h" #include "third_party/blink/public/common/permissions_policy/document_policy.h" #include "third_party/blink/public/common/permissions_policy/policy_helper_public.h" #include "third_party/blink/public/common/renderer_preferences/renderer_preferences.h" #include "third_party/blink/public/common/runtime_feature_state/runtime_feature_state_context.h" #include "third_party/blink/public/common/security/address_space_feature.h" #include "third_party/blink/public/common/user_agent/user_agent_metadata.h" #include "third_party/blink/public/common/web_preferences/web_preferences.h" #include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom.h" #include "third_party/blink/public/mojom/frame/frame.mojom.h" #include "third_party/blink/public/mojom/loader/mixed_content.mojom.h" #include "third_party/blink/public/mojom/loader/transferrable_url_loader.mojom.h" #include "third_party/blink/public/mojom/navigation/navigation_params.mojom.h" #include "third_party/blink/public/mojom/navigation/prefetched_signed_exchange_info.mojom.h" #include "third_party/blink/public/mojom/runtime_feature_state/runtime_feature.mojom.h" #include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h" #include "third_party/blink/public/mojom/storage_key/ancestor_chain_bit.mojom.h" #include "third_party/blink/public/mojom/timing/resource_timing.mojom-forward.h" #include "third_party/blink/public/mojom/use_counter/metrics/web_feature.mojom.h" #include "third_party/blink/public/platform/resource_request_blocked_reason.h" #include "third_party/perfetto/include/perfetto/tracing/track.h" #include "ui/compositor/compositor_lock.h" #include "url/origin.h" #include "url/url_constants.h" #if BUILDFLAG(IS_ANDROID) #include "content/browser/renderer_host/navigation_transitions/navigation_entry_screenshot_cache.h" #include "ui/android/window_android.h" #include "ui/android/window_android_compositor.h" #endif namespace content { namespace { // Kill-switch for the fix to copy item_sequence_number and // document_sequence_number from a prerender navigation entry during prerender // activation (https://crbug.com/442618062). BASE_FEATURE(kPrerenderFixSequenceNumbers, base::FEATURE_ENABLED_BY_DEFAULT); // Default timeout for the READY_TO_COMMIT -> COMMIT transition. Chosen // initially based on the Navigation.ReadyToCommitUntilCommit UMA, and then // refined based on feedback based on CrashExitCodes.Renderer/RESULT_CODE_HUNG. constexpr base::TimeDelta kDefaultCommitTimeout = base::Seconds(30); // Timeout for the READY_TO_COMMIT -> COMMIT transition. // Overrideable via SetCommitTimeoutForTesting. base::TimeDelta g_commit_timeout = kDefaultCommitTimeout; #if BUILDFLAG(IS_ANDROID) // Timeout for locking the compositor at the beginning of navigation. constexpr base::TimeDelta kCompositorLockTimeout = base::Milliseconds(150); #endif // Flag to control whether redirect URLs are being sanitized before sending // them to the renderer process as part of the navigation. // See https://crbug.com/40095391. BASE_FEATURE(kSanitizeRedirectUrlsDuringNavigation, base::FEATURE_ENABLED_BY_DEFAULT); // Killswitch to replace the current NavigationEntry for same-URL navigations // recovering from an error document. See https://crbug.com/396645696. BASE_FEATURE(kReplaceEntryWhenRecoveringFromError, base::FEATURE_ENABLED_BY_DEFAULT); const base::FeatureParam kDeferSpeculativeRFHWaitUntilFinalResponse{ &features::kDeferSpeculativeRFHCreation, "wait_until_final_response", false}; // Denotes the type of user agent string value sent in the User-Agent request // header. // // Corresponds to the "UserAgentStringType" histogram enumeration type in // tools/metrics/histograms/enums.xml. // // PLEASE DO NOT REORDER, REMOVE, OR CHANGE THE MEANING OF THESE VALUES. enum class UserAgentStringType { kFullVersion, kReducedVersion, kOverriden, kMaxValue = kOverriden }; // Returns the net load flags to use based on the navigation type. // TODO(clamy): Remove the blink code that sets the caching flags. void UpdateLoadFlagsWithCacheFlags(int* load_flags, blink::mojom::NavigationType navigation_type, bool is_post) { switch (navigation_type) { case blink::mojom::NavigationType::RELOAD: *load_flags |= net::LOAD_VALIDATE_CACHE; break; case blink::mojom::NavigationType::RELOAD_BYPASSING_CACHE: *load_flags |= net::LOAD_BYPASS_CACHE; break; case blink::mojom::NavigationType::RESTORE: *load_flags |= net::LOAD_SKIP_CACHE_VALIDATION; break; case blink::mojom::NavigationType::RESTORE_WITH_POST: *load_flags |= net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION; break; case blink::mojom::NavigationType::SAME_DOCUMENT: case blink::mojom::NavigationType::DIFFERENT_DOCUMENT: if (is_post) *load_flags |= net::LOAD_VALIDATE_CACHE; break; case blink::mojom::NavigationType::HISTORY_SAME_DOCUMENT: case blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT: if (is_post) { *load_flags |= net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION; } else { *load_flags |= net::LOAD_SKIP_CACHE_VALIDATION; } break; } } // This should match blink::ResourceRequest::needsHTTPOrigin. bool NeedsHTTPOrigin(const std::string& method) { // Blink version of this function checks if the Origin header might have // already been added to the headers. This check is not replicated below // because: // 1. We want to overwrite the old (renderer-provided) header value // with a new, trustworthy (browser-provided) value. // 2. The rest of the function matches the Blink version, so there should // be no discrepancies in the Origin value used. // Don't send an Origin header for GET or HEAD to avoid privacy issues. // For example, if an intranet page has a hyperlink to an external web // site, we don't want to include the Origin of the request because it // will leak the internal host name. Similar privacy concerns have lead // to the widespread suppression of the Referer header at the network // layer. if (method == "GET" || method == "HEAD") return false; // For non-GET and non-HEAD methods, always send an Origin header so the // server knows we support this feature. return true; } // Computes the value that should be set for the User-Agent header, if // `user_agent_override` is non-empty, `user_agent_override` is returned as the // header value. std::string ComputeUserAgentValue(const std::string& user_agent_override) { if (!user_agent_override.empty()) { base::UmaHistogramEnumeration("Navigation.UserAgentStringType", UserAgentStringType::kOverriden); return user_agent_override; } base::UmaHistogramEnumeration( "Navigation.UserAgentStringType", base::FeatureList::IsEnabled( blink::features::kReduceUserAgentMinorVersion) ? UserAgentStringType::kReducedVersion : UserAgentStringType::kFullVersion); return GetContentClient()->browser()->GetUserAgent(); } void AddAdditionalRequestHeaders( net::HttpRequestHeaders* headers, const GURL& url, blink::mojom::NavigationType navigation_type, ui::PageTransition transition, BrowserContext* browser_context, const std::string& method, const std::string& user_agent_override, const std::optional& initiator_origin, blink::mojom::Referrer* referrer, FrameTreeNode* frame_tree_node, bool is_browser_initiated) { if (!url.SchemeIsHTTPOrHTTPS()) return; bool is_reload = NavigationTypeUtils::IsReload(navigation_type); bool is_history = NavigationTypeUtils::IsHistory(navigation_type); RenderViewHostImpl* render_view_host = frame_tree_node->current_frame_host()->render_view_host(); const blink::RendererPreferences& render_prefs = render_view_host->GetDelegate()->GetRendererPrefs(render_view_host); UpdateAdditionalHeadersForBrowserInitiatedRequest( headers, browser_context, is_reload, render_prefs, /*is_for_worker_script*=*/false); // Tack an 'Upgrade-Insecure-Requests' header to outgoing navigational // requests, as described in // https://w3c.github.io/webappsec/specs/upgrade/#feature-detect headers->SetHeaderIfMissing("Upgrade-Insecure-Requests", "1"); headers->SetHeaderIfMissing( net::HttpRequestHeaders::kUserAgent, ComputeUserAgentValue(user_agent_override)); if (!render_prefs.enable_referrers) { *referrer = blink::mojom::Referrer(GURL(), network::mojom::ReferrerPolicy::kNever); } // Next, set the HTTP Origin if needed. std::optional existing_origin = headers->GetHeader(net::HttpRequestHeaders::kOrigin); bool needs_http_origin = NeedsHTTPOrigin(method); if (needs_http_origin) { url::Origin origin_header_value = initiator_origin.value_or(url::Origin()); origin_header_value = Referrer::SanitizeOriginForRequest( url, origin_header_value, referrer->policy); std::string serialized_origin = origin_header_value.Serialize(); headers->SetHeader(net::HttpRequestHeaders::kOrigin, serialized_origin); } else if (!is_browser_initiated && !is_history) { headers->RemoveHeader(net::HttpRequestHeaders::kOrigin); } if (existing_origin && !is_browser_initiated && !is_history && base::FeatureList::IsEnabled(features::kKillOnUnexpectedOriginHeader)) { // A well-behaved renderer will never provide an Origin header on a // navigation request, and will instead rely on the browser process to set // it. History navigations are excluded from this enforcement because it is // valid behavior for a renderer-initiated history navigation to reach this // point with an Origin header populated from an existing navigation entry. SCOPED_CRASH_KEY_STRING64("Bug487795397", "renderer_provided_origin", existing_origin.value()); SCOPED_CRASH_KEY_STRING64( "Bug487795397", "current_header_origin", headers->GetHeader(net::HttpRequestHeaders::kOrigin).value_or("")); SCOPED_CRASH_KEY_BOOL("Bug487795397", "needs_origin_header", needs_http_origin); bad_message::ReceivedBadMessage(render_view_host->GetProcess(), bad_message::NR_BAD_ORIGIN_HEADER); } if (base::FeatureList::IsEnabled(features::kDocumentPolicyNegotiation)) { const blink::DocumentPolicyFeatureState& required_policy = frame_tree_node->effective_frame_policy().required_document_policy; if (!required_policy.empty()) { std::optional policy_header = blink::DocumentPolicy::Serialize(required_policy); CHECK(policy_header); headers->SetHeader("Sec-Required-Document-Policy", policy_header.value()); } } // Add the "Sec-Purpose: prefetch;prerender" header to prerender navigations // including subframe navigations. if (frame_tree_node->frame_tree().is_prerendering()) { PrerenderHost::GetFromFrameTreeNode(*frame_tree_node) .AddAdditionalRequestHeaders(*headers, *frame_tree_node); } } bool ShouldPropagateUserActivation(const url::Origin& previous_origin, const url::Origin& new_origin) { if ((previous_origin.scheme() != "http" && previous_origin.scheme() != "https") || (new_origin.scheme() != "http" && new_origin.scheme() != "https")) { return false; } if (previous_origin.host() == new_origin.host()) return true; std::string previous_domain = net::registry_controlled_domains::GetDomainAndRegistry( previous_origin, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); std::string new_domain = net::registry_controlled_domains::GetDomainAndRegistry( new_origin, net::registry_controlled_domains::INCLUDE_PRIVATE_REGISTRIES); return !previous_domain.empty() && previous_domain == new_domain; } // LOG_NAVIGATION_TIMING_HISTOGRAM logs |value| for "Navigation." UMA // as well as supplementary UMAs (depending on |transition| and |priority|) // for BackForward/Reload/NewNavigation variants. // // kMaxTime and kBuckets constants are consistent with // UmaHistogramMediumTimes, but a custom kMinTime is used for high // fidelity near the low end of measured values. // // TODO(csharrison,nasko): This macro is incorrect for subframe navigations, // which will only have subframe-specific transition types. This means that all // subframes currently are tagged as NewNavigations. #define LOG_NAVIGATION_TIMING_HISTOGRAM(histogram, transition, priority, \ duration) \ do { \ const base::TimeDelta kMinTime = base::Milliseconds(1); \ const base::TimeDelta kMaxTime = base::Minutes(3); \ const int kBuckets = 50; \ UMA_HISTOGRAM_CUSTOM_TIMES("Navigation." histogram, duration, kMinTime, \ kMaxTime, kBuckets); \ if (transition & ui::PAGE_TRANSITION_FORWARD_BACK) { \ UMA_HISTOGRAM_CUSTOM_TIMES("Navigation." histogram ".BackForward", \ duration, kMinTime, kMaxTime, kBuckets); \ } else if (ui::PageTransitionCoreTypeIs(transition, \ ui::PAGE_TRANSITION_RELOAD)) { \ UMA_HISTOGRAM_CUSTOM_TIMES("Navigation." histogram ".Reload", duration, \ kMinTime, kMaxTime, kBuckets); \ } else if (ui::PageTransitionIsNewNavigation(transition)) { \ UMA_HISTOGRAM_CUSTOM_TIMES("Navigation." histogram ".NewNavigation", \ duration, kMinTime, kMaxTime, kBuckets); \ } else { \ NOTREACHED() << "Invalid page transition: " << transition; \ } \ if (priority.has_value()) { \ if (priority.value() == base::Process::Priority::kBestEffort) { \ UMA_HISTOGRAM_CUSTOM_TIMES("Navigation." histogram \ ".BackgroundProcessPriority", \ duration, kMinTime, kMaxTime, kBuckets); \ } else { \ UMA_HISTOGRAM_CUSTOM_TIMES("Navigation." histogram \ ".ForegroundProcessPriority", \ duration, kMinTime, kMaxTime, kBuckets); \ } \ } \ } while (0) void RecordStartToCommitMetrics(base::TimeTicks navigation_start_time, ui::PageTransition transition, const base::TimeTicks& ready_to_commit_time, std::optional priority, bool is_same_process, bool is_main_frame) { base::TimeTicks now = base::TimeTicks::Now(); base::TimeDelta delta = now - navigation_start_time; LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit", transition, priority, delta); if (is_main_frame) { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.MainFrame", transition, priority, delta); } else { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.Subframe", transition, priority, delta); } if (is_same_process) { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.SameProcess", transition, priority, delta); if (is_main_frame) { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.SameProcess.MainFrame", transition, priority, delta); } else { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.SameProcess.Subframe", transition, priority, delta); } } else { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.CrossProcess", transition, priority, delta); if (is_main_frame) { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.CrossProcess.MainFrame", transition, priority, delta); } else { LOG_NAVIGATION_TIMING_HISTOGRAM("StartToCommit.CrossProcess.Subframe", transition, priority, delta); } } if (!ready_to_commit_time.is_null()) { LOG_NAVIGATION_TIMING_HISTOGRAM("ReadyToCommitUntilCommit2", transition, priority, now - ready_to_commit_time); } } void RecordReadyToCommitMetrics( RenderFrameHostImpl* old_rfh, RenderFrameHostImpl* new_rfh, const blink::mojom::CommonNavigationParams& common_params, base::TimeTicks ready_to_commit_time, NavigationRequest::OriginAgentClusterEndResult origin_agent_cluster_end_result, bool did_receive_early_hints_before_cross_origin_redirect) { bool is_main_frame = !new_rfh->GetParent(); bool is_same_process = old_rfh->GetProcess()->GetDeprecatedID() == new_rfh->GetProcess()->GetDeprecatedID(); // Navigation.IsSameBrowsingInstance if (is_main_frame) { bool is_same_browsing_instance = old_rfh->GetSiteInstance()->IsRelatedSiteInstance( new_rfh->GetSiteInstance()); UMA_HISTOGRAM_BOOLEAN("Navigation.IsSameBrowsingInstance", is_same_browsing_instance); } // Navigation.IsSameSiteInstance { bool is_same_site_instance = old_rfh->GetSiteInstance() == new_rfh->GetSiteInstance(); UMA_HISTOGRAM_BOOLEAN("Navigation.IsSameSiteInstance", is_same_site_instance); if (is_main_frame) { UMA_HISTOGRAM_BOOLEAN("Navigation.IsSameSiteInstance.MainFrame", is_same_site_instance); } else { UMA_HISTOGRAM_BOOLEAN("Navigation.IsSameSiteInstance.Subframe", is_same_site_instance); } } // Navigation.IsLockedProcess { ProcessLock process_lock = new_rfh->GetProcess()->GetProcessLock(); UMA_HISTOGRAM_BOOLEAN("Navigation.IsLockedProcess", process_lock.IsLockedToSite()); if (common_params.url.SchemeIsHTTPOrHTTPS()) { UMA_HISTOGRAM_BOOLEAN("Navigation.IsLockedProcess.HTTPOrHTTPS", process_lock.IsLockedToSite()); } } // Navigation.RequiresDedicatedProcess { UMA_HISTOGRAM_BOOLEAN( "Navigation.RequiresDedicatedProcess", new_rfh->GetSiteInstance()->RequiresDedicatedProcess()); if (common_params.url.SchemeIsHTTPOrHTTPS()) { UMA_HISTOGRAM_BOOLEAN( "Navigation.RequiresDedicatedProcess.HTTPOrHTTPS", new_rfh->GetSiteInstance()->RequiresDedicatedProcess()); } } // TimeToReadyToCommit2 { constexpr std::optional kPriority = std::nullopt; base::TimeDelta delta = ready_to_commit_time - common_params.navigation_start; ui::PageTransition transition = ui::PageTransitionFromInt(common_params.transition); LOG_NAVIGATION_TIMING_HISTOGRAM("TimeToReadyToCommit2", transition, kPriority, delta); if (is_main_frame) { LOG_NAVIGATION_TIMING_HISTOGRAM("TimeToReadyToCommit2.MainFrame", transition, kPriority, delta); } else { LOG_NAVIGATION_TIMING_HISTOGRAM("TimeToReadyToCommit2.Subframe", transition, kPriority, delta); } if (is_same_process) { LOG_NAVIGATION_TIMING_HISTOGRAM("TimeToReadyToCommit2.SameProcess", transition, kPriority, delta); } else { LOG_NAVIGATION_TIMING_HISTOGRAM("TimeToReadyToCommit2.CrossProcess", transition, kPriority, delta); } if (did_receive_early_hints_before_cross_origin_redirect) { LOG_NAVIGATION_TIMING_HISTOGRAM( "TimeToReadyToCommit2.CrossOriginRedirectAfterEarlyHints", transition, kPriority, delta); } } // Navigation.OriginAgentCluster { UMA_HISTOGRAM_ENUMERATION("Navigation.OriginAgentCluster.Result", origin_agent_cluster_end_result); } // Guest ( tag) metrics. { base::UmaHistogramBoolean( "Navigation.IsGuest", new_rfh->GetSiteInstance()->GetSecurityPrincipal().IsGuest()); if (new_rfh->GetSiteInstance()->GetSecurityPrincipal().IsGuest()) { base::UmaHistogramBoolean("Navigation.Guest.IsHTTPOrHTTPS", common_params.url.SchemeIsHTTPOrHTTPS()); base::UmaHistogramBoolean("Navigation.Guest.IsMainFrame", is_main_frame); } } } // Convert the navigation type to the appropriate cross-document one. // // This is currently used when: // 1) Restarting a same-document navigation as cross-document. // 2) Failing a navigation and committing an error page. blink::mojom::NavigationType ConvertToCrossDocumentType( blink::mojom::NavigationType type) { switch (type) { case blink::mojom::NavigationType::SAME_DOCUMENT: return blink::mojom::NavigationType::DIFFERENT_DOCUMENT; case blink::mojom::NavigationType::HISTORY_SAME_DOCUMENT: return blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT; case blink::mojom::NavigationType::RELOAD: case blink::mojom::NavigationType::RELOAD_BYPASSING_CACHE: case blink::mojom::NavigationType::RESTORE: case blink::mojom::NavigationType::RESTORE_WITH_POST: case blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT: case blink::mojom::NavigationType::DIFFERENT_DOCUMENT: return type; } } base::debug::CrashKeyString* GetNavigationRequestUrlCrashKey() { static auto* crash_key = base::debug::AllocateCrashKeyString( "navigation_request_url", base::debug::CrashKeySize::Size256); return crash_key; } base::debug::CrashKeyString* GetNavigationRequestInitiatorCrashKey() { static auto* crash_key = base::debug::AllocateCrashKeyString( "navigation_request_initiator", base::debug::CrashKeySize::Size64); return crash_key; } base::debug::CrashKeyString* GetNavigationRequestIsSameDocumentCrashKey() { static auto* crash_key = base::debug::AllocateCrashKeyString( "navigation_request_is_same_document", base::debug::CrashKeySize::Size64); return crash_key; } // Start a new nested async event with the given name. template void EnterChildTraceEvent(perfetto::StaticString name, NavigationRequest* request, Args... args) { TRACE_EVENT_END( "navigation", request->GetNavigationTracingTrack()); // Closes the previous child event TRACE_EVENT_BEGIN("navigation", name, request->GetNavigationTracingTrack(), args...); } network::mojom::RequestDestination GetDestinationFromFrameTreeNode( FrameTreeNode* frame_tree_node) { if (frame_tree_node->IsInFencedFrameTree()) return network::mojom::RequestDestination::kFencedframe; if (frame_tree_node->IsMainFrame()) { return network::mojom::RequestDestination::kDocument; } switch (frame_tree_node->frame_owner_element_type()) { case blink::FrameOwnerElementType::kObject: return network::mojom::RequestDestination::kObject; case blink::FrameOwnerElementType::kEmbed: return network::mojom::RequestDestination::kEmbed; case blink::FrameOwnerElementType::kIframe: return network::mojom::RequestDestination::kIframe; case blink::FrameOwnerElementType::kFrame: return network::mojom::RequestDestination::kFrame; // Main frames are handled above. case blink::FrameOwnerElementType::kNone: NOTREACHED(); case blink::FrameOwnerElementType::kFencedframe: // Fenced frames are handled above. NOTREACHED(); } } // Returns true if the parent's COEP policy `parent_coep` should block a child // embedded in an element; this is covered by // NavigationBrowserTest.BlockedSrcDoc* tests. While this will result in // an error page, we might still get here via GetURLInfo if the navigation // encounters a COOP header. In that case we return the origin of the // page that executed the script, knowing that the navigation will fail // anyways. return frame_tree_node()->current_frame_host()->GetLastCommittedOrigin(); } } if (GetURL().SchemeIsBlob()) { // Blob URLs either have the origin embedded within the URL, or have a // URL -> origin mapping for it saved in the BlobURLRegistry. std::optional target_rph_id; if (HasRenderFrameHost() && GetRenderFrameHost()->GetProcess()) { target_rph_id = GetRenderFrameHost()->GetProcess()->GetDeprecatedID(); } return static_cast( GetStoragePartitionWithCurrentSiteInfo()) ->GetBlobUrlRegistry() ->GetOriginForNavigation( GetURL(), common_params().initiator_origin.value_or(url::Origin()), target_rph_id); } // In cases not covered above, URLLoaderFactory should be associated with the // origin of |common_params.url| and/or |common_params.initiator_origin|. url::Origin resolved_origin = url::Origin::Resolve( common_params().url, common_params().initiator_origin.value_or(url::Origin())); if (common_params().url.SchemeIs(url::kDataScheme)) { // Cache the origin for data: URLs, so that its nonce remains stable. tentative_data_origin_to_commit_ = resolved_origin; } return resolved_origin; } bool NavigationRequest::HasLoader() const { return loader_.get() != nullptr; } blink::mojom::PageSwapEventParamsPtr NavigationRequest::WillDispatchPageSwap() { CHECK(ShouldDispatchPageSwapEvent()); did_fire_page_swap_ = true; if (did_encounter_cross_origin_redirect_) { return nullptr; } // The `pageswap` event is fired on the old Document to provide information // about the new Document. The information shared must be restricted to // same-origin Documents. const bool is_same_origin = frame_tree_node_->current_origin().IsSameOriginWith( is_running_potential_prerender_activation_checks_ ? GetTentativeOriginAtRequestTime() : *GetOriginToCommit()); if (!is_same_origin) { return nullptr; } auto page_swap_event_params = blink::mojom::PageSwapEventParams::New(); page_swap_event_params->url = common_params_->url; switch (common_params_->navigation_type) { case blink::mojom::NavigationType::RELOAD: case blink::mojom::NavigationType::RELOAD_BYPASSING_CACHE: page_swap_event_params->navigation_type = blink::mojom::NavigationTypeForNavigationApi::kReload; break; case blink::mojom::NavigationType::RESTORE: case blink::mojom::NavigationType::RESTORE_WITH_POST: // When traversing to a restored entry, we use these navigation types. // Process them same as traverse navigations. case blink::mojom::NavigationType::HISTORY_DIFFERENT_DOCUMENT: page_swap_event_params->navigation_type = blink::mojom::NavigationTypeForNavigationApi::kTraverse; page_swap_event_params->page_state = commit_params_->page_state; break; case blink::mojom::NavigationType::DIFFERENT_DOCUMENT: page_swap_event_params->navigation_type = common_params_->should_replace_current_entry ? blink::mojom::NavigationTypeForNavigationApi::kReplace : blink::mojom::NavigationTypeForNavigationApi::kPush; break; case blink::mojom::NavigationType::HISTORY_SAME_DOCUMENT: case blink::mojom::NavigationType::SAME_DOCUMENT: NOTREACHED() << "Same-document navigations shouldn't fire pageswap"; } return page_swap_event_params; } std::optional NavigationRequest::GetNavigationDiscardReason() { return navigation_discard_reason_; } NavigationDiscardReason NavigationRequest::GetTypeForNavigationDiscardReason() { if (NavigationTypeUtils::IsReload(common_params_->navigation_type)) { return NavigationDiscardReason::kNewReloadNavigation; } if (NavigationTypeUtils::IsHistory(common_params_->navigation_type)) { return NavigationDiscardReason::kNewHistoryNavigation; } if (IsRendererInitiated()) { return NavigationDiscardReason::kNewOtherNavigationRendererInitiated; } return NavigationDiscardReason::kNewOtherNavigationBrowserInitiated; } std::optional NavigationRequest::GetNavigationTimelineUkmBuilder() { if (ShouldRecordNavigationTimelineUkm() && IsInMainFrame() && // UKM data is sampled at a frequency of `GetUkmSamplingRate()`. base::RandDouble() < GetUkmSamplingRate()) { return ukm::builders::NavigationTimeline(GetNextPageUkmSourceId()); } return std::nullopt; } bool NavigationRequest::ShouldRecordNavigationTimelineUkm() const { return !IsSameDocument() && !IsRestore() && !NavigationTypeUtils::IsHistory(common_params_->navigation_type) && !NavigationTypeUtils::IsReload(common_params_->navigation_type) && (common_params_->url.SchemeIsHTTPOrHTTPS() || common_params_->url.SchemeIs(content::kChromeUIScheme)) && !IsPrerenderedPageActivation(); } bool NavigationRequest::CanRecordEarlyNavigationFailure() const { // `site_info_` reflects the target frame's StoragePartition only after // StartNavigation() has run; before that it holds a default configuration. // To prevent cross-partition leaks from non-default partitions (e.g., guest // ) while keeping metrics for standard primary main frames, require // that StartNavigation() has run (`state_ >= WILL_START_REQUEST`) or that // the current frame already belongs to the default StoragePartition. return state_ >= WILL_START_REQUEST || frame_tree_node_->current_frame_host() ->GetSiteInstance() ->GetSecurityPrincipal() .GetStoragePartitionConfig() .is_default(); } void NavigationRequest::MaybeRecordTraceEventsAndHistograms() { if (navigation_handle_timing_.navigation_commit_sent_time.is_null()) { return; } bool record_metrics = ShouldRecordNavigationTimelineUkm(); CHECK(!blink::IsRendererDebugURL(common_params_->url)); base::TimeTicks navigation_start_time = common_params_->navigation_start; CHECK(!navigation_start_time.is_null()); const auto& trace_id = breakdown_trace_track_; const base::TimeTicks loader_start_time = navigation_handle_timing_.loader_start_time; const base::TimeTicks first_request_start_time = navigation_handle_timing_.first_request_start_time; const base::TimeTicks navigation_commit_sent_time = navigation_handle_timing_.navigation_commit_sent_time; #define MAYBE_RECORD_TRACE_AND_HISTOGRAM0(name, begin_time, end_time) \ do { \ if (!begin_time.is_null() && !end_time.is_null() && \ navigation_start_time <= begin_time && \ end_time <= navigation_commit_sent_time) { \ TRACE_EVENT_BEGIN("navigation", name, trace_id, begin_time); \ TRACE_EVENT_END("navigation", trace_id, end_time); \ if (record_metrics) { \ base::UmaHistogramTimes( \ "Navigation.MainFrame.NewNavigation.IgnoreRestore." \ "IsHTTPOrHTTPS." name ".Time2", \ end_time - begin_time); \ } \ } \ } while (0) #define MAYBE_RECORD_TRACE_AND_HISTOGRAM1(name, begin_time, end_time, \ arg1_name, arg1_val) \ do { \ if (!begin_time.is_null() && !end_time.is_null() && \ navigation_start_time <= begin_time && \ end_time <= navigation_commit_sent_time) { \ TRACE_EVENT_BEGIN("navigation", name, trace_id, begin_time, arg1_name, \ arg1_val); \ TRACE_EVENT_END("navigation", trace_id, end_time); \ if (record_metrics) { \ base::UmaHistogramTimes( \ "Navigation.MainFrame.NewNavigation.IgnoreRestore." \ "IsHTTPOrHTTPS." name ".Time2", \ end_time - begin_time); \ } \ } \ } while (0) MAYBE_RECORD_TRACE_AND_HISTOGRAM0("NavigationStartToBeginNavigation", navigation_start_time, begin_navigation_time_); MAYBE_RECORD_TRACE_AND_HISTOGRAM0("BeginNavigationToLoaderStart", begin_navigation_time_, loader_start_time); MAYBE_RECORD_TRACE_AND_HISTOGRAM1("LoaderStartToReceiveResponse", loader_start_time, receive_response_time_, "URL", common_params_->url.spec()); // `first_fetch_start_time_` can be earlier than // `loader_start_time` when Prefetch or Prerendering // is enabled. The following UMAs are not recorded in such cases because it // will skew the data. Also the following trace events are not recorded in // such cases because such traces will not be rendered correctly. if (loader_start_time <= first_fetch_start_time_) { MAYBE_RECORD_TRACE_AND_HISTOGRAM0( "LoaderStartToFetchStart", loader_start_time, first_fetch_start_time_); MAYBE_RECORD_TRACE_AND_HISTOGRAM0("FetchStart", first_fetch_start_time_, first_request_start_time); MAYBE_RECORD_TRACE_AND_HISTOGRAM0("ReceiveHeaders", first_request_start_time, final_receive_headers_end_time_); MAYBE_RECORD_TRACE_AND_HISTOGRAM0("ReceiveHeadersToReceiveResponse", final_receive_headers_end_time_, receive_response_time_); } MAYBE_RECORD_TRACE_AND_HISTOGRAM0("ReceiveResponseToCommitNavigation", receive_response_time_, navigation_commit_sent_time); TRACE_EVENT_END("navigation", breakdown_trace_track_, navigation_commit_sent_time); // Navigation StartToCommit navigation_start_to_commit_ended_ = true; // UKM data is sampled at a frequency of `GetUkmSamplingRate()`. if (record_metrics && base::RandDouble() < GetUkmSamplingRate() && !navigation_start_time.is_null() && !begin_navigation_time_.is_null() && !loader_start_time.is_null() && !receive_response_time_.is_null() && navigation_start_time <= begin_navigation_time_ && begin_navigation_time_ <= loader_start_time && loader_start_time <= receive_response_time_ && receive_response_time_ <= navigation_commit_sent_time) { ukm::builders::NavigationRequestBreakDown ukm(GetNextPageUkmSourceId()); ukm.SetNavigationStartToBeginNavigation( (begin_navigation_time_ - navigation_start_time).InMilliseconds()) .SetBeginNavigationToLoaderStart( (loader_start_time - begin_navigation_time_).InMilliseconds()) .SetLoaderStartToReceiveResponse( (receive_response_time_ - loader_start_time).InMilliseconds()) .SetReceiveResponseToCommitNavigation( (navigation_commit_sent_time - receive_response_time_) .InMilliseconds()); // To avoid affecting other metrics, we check the following conditions // separately. These conditions should usually be true, but there can be // uncommon error cases. if (!first_fetch_start_time_.is_null() && !first_request_start_time.is_null() && loader_start_time <= first_fetch_start_time_ && first_fetch_start_time_ <= first_request_start_time) { ukm.SetLoaderStartToFetchStart( (first_fetch_start_time_ - loader_start_time).InMilliseconds()) .SetFetchStartToRequestStart( (first_request_start_time - first_fetch_start_time_) .InMilliseconds()); } ukm.Record(ukm::UkmRecorder::Get()); } #undef MAYBE_RECORD_TRACE_AND_HISTOGRAM0 #undef MAYBE_RECORD_TRACE_AND_HISTOGRAM1 } void NavigationRequest::MaybeRecordNavigationStartAdjustments() { // Only record metrics if we have a navigation start time. if (common_params().navigation_start.is_null()) { return; } if (IsSameDocument()) { // No adjustments are made for same-document navigations. CHECK(original_navigation_start_.is_null()); return; } // Some navigations do not adjust the start time, in which case // `original_navigation_start_` is left as null. if (original_navigation_start_.is_null()) { base::UmaHistogramEnumeration("Navigation.StartAdjustment.AllFrames", NavigationStartAdjustmentType::kNone); if (IsInPrimaryMainFrame()) { base::UmaHistogramEnumeration("Navigation.StartAdjustment.MainFrameOnly", NavigationStartAdjustmentType::kNone); } return; } // Compute the adjustment made and what percentage of the total navigation // time it includes (approximating now as the end of the navigation). base::TimeDelta adjustment = common_params().navigation_start - original_navigation_start_; base::TimeDelta original_start_to_finish = base::TimeTicks::Now() - original_navigation_start_; // Note that in unit tests, all timestamps can be the same. Skip recording // duration metrics if no time has elapsed during the navigation. if (original_start_to_finish.is_zero()) { return; } // Report the adjustment in UMA metrics specific to the case that occurred. NavigationStartAdjustmentType adjustment_type = NavigationStartAdjustmentType::kNone; std::string histogram_name = "Navigation.StartAdjustment"; if (navigation_start_adjustment_for_legacy_) { // No beforeunload handlers actually run in legacy mode. CHECK(!beforeunload_dialog_shown_); adjustment_type = NavigationStartAdjustmentType::kLegacyPostTask; histogram_name += ".LegacyPostTask"; } else if (!beforeunload_dialog_shown_) { adjustment_type = NavigationStartAdjustmentType::kBeforeUnloadHandlers; histogram_name += ".BeforeUnloadHandlers"; } else { adjustment_type = NavigationStartAdjustmentType::kBeforeUnloadDialog; histogram_name += ".BeforeUnloadDialog"; } base::UmaHistogramEnumeration("Navigation.StartAdjustment.AllFrames", adjustment_type); if (IsInPrimaryMainFrame()) { base::UmaHistogramEnumeration("Navigation.StartAdjustment.MainFrameOnly", adjustment_type); } // It is currently possible for the adjustment to be negative, due to a bug // where the updated start time from an earlier navigation is applied to the // current NavigationRequest. See https://crbug.com/385170155. if (adjustment.is_negative()) { // In this case, report the absolute value of the adjustment in a different // per-type metric, without reporting the (ill-defined) percentage or trying // to create a trace event. histogram_name += ".Negative"; base::UmaHistogramTimes(histogram_name, adjustment.magnitude()); return; } // The duration of the navigation should never be negative. For now, return // early if that happens, after reporting a DumpWithoutCrashing. Upgrade this // to a CHECK failure if no reports are received by M135. if (original_start_to_finish.is_negative()) { NOTREACHED() << original_start_to_finish; } base::UmaHistogramTimes(histogram_name, adjustment); size_t percentage = 100 * adjustment / original_start_to_finish; base::UmaHistogramPercentage(histogram_name + ".Percentage", percentage); // Show trace events indicating where the adjustment occurred in time. TRACE_EVENT_BEGIN("navigation", "NavigationStartAdjustment", breakdown_trace_track_, original_navigation_start_, "Percentage", percentage); TRACE_EVENT_END( "navigation", breakdown_trace_track_, common_params().navigation_start); // NavigationStartAdjustment } void NavigationRequest::WillStartBeforeUnload() { SetWaitingForRendererResponse(); beforeunload_phase2_start_time_ = base::TimeTicks().Now(); } void NavigationRequest::set_beforeunload_phase2_dialog_opened_time( const base::TimeTicks& dialog_opened_time) { beforeunload_phase2_dialog_opened_time_ = dialog_opened_time; } void NavigationRequest::set_beforeunload_phase2_dialog_closed_time( const base::TimeTicks& dialog_closed_time) { beforeunload_phase2_dialog_closed_time_ = dialog_closed_time; } NavigationRequest::Timeline::Timeline() = default; NavigationRequest::Timeline::Timeline( const NavigationRequest::Timeline& timeline) = default; NavigationRequest::Timeline::~Timeline() = default; void NavigationRequest::Timeline::MarkFinish() { finish = base::TimeTicks().Now(); } NavigationRequest::Timeline NavigationRequest::GenerateNavigationTimelineForMetrics( const mojom::DidCommitProvisionalLoadParams& params, const base::TimeTicks& did_commit_ipc_received_time) { NavigationRequest::Timeline timeline; // Similar to how `actual_navigation_start` is handled for `timeline.start` in // synchronous renderer commits below, the input start time is not implemented // for all navigations. For example, synchronous about:blank commits and // same-document navigations do not currently set `input_start`, but it's // possible to send the actual input start later in the future if it's useful. if (!common_params().input_start.is_null()) { timeline.user_interaction = common_params().input_start; } if (is_synchronous_renderer_commit()) { // For synchronous renderer commits, the start time in the renderer process // should be provided in `actual_navigation_start`. if (!common_params().actual_navigation_start.is_null()) { timeline.start = common_params().actual_navigation_start; } else { // If `actual_navigation_start` is unexpectedly missing, fall back to the // time this IPC was received. timeline.start = did_commit_ipc_received_time; } } else if (!common_params().actual_navigation_start.is_null()) { // Use the actual start time if it is provided, and record how long was // spent on beforeunload phase 1 in the initiating renderer (if any). timeline.start = common_params().actual_navigation_start; if (!begin_params().before_unload_start.is_null()) { timeline.beforeunload_phase1_start = begin_params().before_unload_start; timeline.beforeunload_phase1_end = begin_params().before_unload_end; if (!begin_params().before_unload_dialog_opened.is_null() && !begin_params().before_unload_dialog_closed.is_null()) { timeline.beforeunload_phase1_dialog_opened = begin_params().before_unload_dialog_opened; timeline.beforeunload_phase1_dialog_closed = begin_params().before_unload_dialog_closed; } } } else { // For any legacy cases where the actual start time isn't provided, fall // back to the `navigation_start` used by web-exposed metrics. However, if // the navigation start time was adjusted due to beforeunload processing, // use the original timestamp to ensure that the trace event start time is // still accurate. // // TODO(alexmos): examine whether these timestamps, as well as their other // uses, should use InterProcessTimeTicksConverter since they may come from // the renderer process. timeline.start = !original_navigation_start_.is_null() ? original_navigation_start_ : common_params().navigation_start; } timeline.navigation_request_creation = creation_time_; if (!beforeunload_phase2_start_time_.is_null()) { timeline.beforeunload_phase2_start = beforeunload_phase2_start_time_; timeline.beforeunload_phase2_end = beforeunload_phase2_end_time_; if (!beforeunload_phase2_dialog_opened_time_.is_null() && !beforeunload_phase2_dialog_closed_time_.is_null()) { timeline.beforeunload_phase2_dialog_opened = beforeunload_phase2_dialog_opened_time_; timeline.beforeunload_phase2_dialog_closed = beforeunload_phase2_dialog_closed_time_; } } timeline.common_params_start = common_params().navigation_start; timeline.begin_navigation = begin_navigation_time_; timeline.loader_start = navigation_handle_timing_.loader_start_time; if (!IsPageActivation()) { // Prerender and bfcache activations should not use the stale loader values // from the original commit. (Note: `loader_start` and `receive_response` // are both set to fresh values for page activations.) timeline.loader_fetch_start = first_fetch_start_time_; timeline.loader_receive_headers = final_receive_headers_end_time_; } timeline.receive_response = receive_response_time_; timeline.commit_ipc_sent = !IsPageActivation() ? navigation_handle_timing_.navigation_commit_sent_time : page_activation_commit_time_; // Note that we can't use NavigationRequest's // navigation_handle_timing_.navigation_commit_received_time because it's // not populated yet when this function is called. if (!IsPageActivation()) { timeline.renderer_commit_ipc_received = params.commit_navigation_start; timeline.renderer_did_commit_ipc_sent = params.commit_reply_sent; timeline.did_commit_ipc_received = did_commit_ipc_received_time; } else { // Page activations don't send a commit IPC, so use a zero size interval. timeline.did_commit_ipc_received = timeline.commit_ipc_sent; } // Populates information in `navigation_handle_timing_` from the // `NavigationTimeline` so that it can be accessed by PageLoadMetricsObservers // via `NavigationRequest::GetNavigationHandleTiming()`. UpdateNavigationHandleTimingsFromNavigationTimeline(timeline); // Populate the renderer process creation and launch times. if (GetRenderFrameHost() && GetRenderFrameHost()->GetProcess()) { timeline.renderer_process_created = GetRenderFrameHost()->GetProcess()->GetLastInitTime(); timeline.renderer_process_launched = GetRenderFrameHost()->GetProcess()->GetProcessLaunchedTime(); } return timeline; } void NavigationRequest::UpdateNavigationHandleTimingsFromNavigationTimeline( const NavigationRequest::Timeline& timeline) { navigation_handle_timing_.user_interaction = timeline.user_interaction; navigation_handle_timing_.actual_navigation_start = timeline.start; navigation_handle_timing_.before_unload_dialog_duration = std::max(base::TimeDelta(), timeline.beforeunload_phase1_dialog_closed - timeline.beforeunload_phase1_dialog_opened) + std::max(base::TimeDelta(), timeline.beforeunload_phase2_dialog_closed - timeline.beforeunload_phase2_dialog_opened); } void NavigationRequest::SanitizeDocumentIsolationPolicyHeader() { if (!response_head_) { return; } // If the DocumentIsolationPolicy feature is not enabled, set its // DocumentIsolationPolicy to its default value. if (!base::FeatureList::IsEnabled( network::features::kDocumentIsolationPolicy)) { response_head_->parsed_headers->document_isolation_policy = network::DocumentIsolationPolicy(); return; } // Check if the process model of the platform supports // DocumentIsolationPolicy. bool document_isolation_policy_supported = false; // DocumentIsolationPolicy is supported in full SiteIsolation mode. document_isolation_policy_supported |= SiteIsolationPolicy::UseDedicatedProcessesForAllSites(); // When kDocumentIsolationPolicyWithoutSiteIsolation is enabled, // DocumentIsolationPolicy is also supported without full SiteIsolation. if (base::FeatureList::IsEnabled( features::kDocumentIsolationPolicyWithoutSiteIsolation)) { document_isolation_policy_supported = true; } // If the process model cannot support DocumentIsolationPolicy, set the header // to its default value. if (!document_isolation_policy_supported) { response_head_->parsed_headers->document_isolation_policy = network::DocumentIsolationPolicy(); return; } network::DocumentIsolationPolicy& dip = response_head_->parsed_headers->document_isolation_policy; bool has_dip_header = dip.value != network::mojom::DocumentIsolationPolicyValue::kNone || dip.report_only_value != network::mojom::DocumentIsolationPolicyValue::kNone || dip.reporting_endpoint || dip.report_only_reporting_endpoint; // DocumentIsolationPolicy should only be used by secure contexts. if (!network::IsUrlPotentiallyTrustworthy(GetURL()) && has_dip_header) { response_head_->parsed_headers->document_isolation_policy = network::DocumentIsolationPolicy(); AddDeferredConsoleMessage( blink::mojom::ConsoleMessageLevel::kError, "The Document-Isolation-Policy header has been ignored because " "the URL's origin was untrustworthy. Please deliver the response using " "the HTTPS protocol. You can also use the 'localhost' origin " "instead. See " "https://www.w3.org/TR/powerful-features/" "#potentially-trustworthy-origin."); } } void NavigationRequest::ValidateCommitOrigin( const url::Origin& origin_to_commit) { NavigationEntryImpl* nav_entry = static_cast(GetNavigationEntry()); if (!nav_entry) { return; } FrameNavigationEntry* frame_entry = nav_entry->GetFrameEntry(frame_tree_node_); if (!frame_entry || !frame_entry->committed_origin().has_value()) { return; } const url::Origin& expected_origin = frame_entry->committed_origin().value(); bool origins_match = false; // Current weakened check: allows precursor tuple comparison if *either* // origin is opaque. This is a temporary workaround because sandbox // navigations do not currently clear PageState properly. // // TODO(crbug.com/421948889): After this bug is fixed, tighten this check // to only allow precursor tuple comparison if *both* origins are opaque. if (expected_origin.opaque() || origin_to_commit.opaque()) { // Both origins are opaque — compare by their precursor tuples. origins_match = expected_origin.GetTupleOrPrecursorTupleIfOpaque() == origin_to_commit.GetTupleOrPrecursorTupleIfOpaque(); } else { // If either is non-opaque, use regular strict comparison. origins_match = expected_origin.IsSameOriginWith(origin_to_commit); } if (!origins_match) { // TODO(crbug.com/420965165): In redirects or other origin-changing // cases (e.g., CSP), FrameNavigationEntry may retain a stale // committed_origin(). We should clear it when the origin changes, so // that if it exists at commit time, it can be trusted to match. // // In the meantime, it’s safe for a stale committed_origin() to stick // around **only** if there’s no origin-related state (e.g., PageState) // being sent in commit_params_. CHECK(commit_params_->page_state.empty(), base::NotFatalUntil::M140) << "PageState wasn't cleared after a commit origin mismatch." << "expected_origin: " << expected_origin << ", origin_to_commit: " << origin_to_commit; } } PrerenderHostId NavigationRequest::GetPrerenderHostId() const { return prerender_host_id_; } void NavigationRequest::SetAsyncBeforeUnloadCommitResumeClosure( base::OnceClosure commit_resume_closure) { CHECK(!async_before_unload_pending_replies_.empty()); CHECK(!async_before_unload_commit_resume_closure_); async_before_unload_commit_resume_closure_ = std::move(commit_resume_closure); } void NavigationRequest::StartAsyncBeforeUnloadTimer() { CHECK(!async_before_unload_pending_replies_.empty()); // Note: The AsyncBeforeUnload event runs in parallel with the navigation // setup and is guaranteed to complete before commit. It is shown on a // separate track to avoid overlapping with sequential breakdown phases. TRACE_EVENT_BEGIN("navigation", "AsyncBeforeUnload", async_before_unload_trace_track_, "Initial URL", common_params_->url.spec()); async_before_unload_timeout_.Start( FROM_HERE, features::kAsyncBeforeUnloadTimeout.Get(), base::BindOnce( [](base::WeakPtr self) { if (!self) { return; } // If the timeout occurs, we proceed with the navigation commit // regardless of any pending replies. We pass nullopt to indicate // that the timer expired. self->async_before_unload_pending_replies_.clear(); self->MaybeResumeAsyncBeforeUnloadCommit(std::nullopt); }, weak_factory_.GetWeakPtr())); } void NavigationRequest::MaybeResumeAsyncBeforeUnloadCommit( std::optional acked_rfh_id) { if (acked_rfh_id) { // Remove the frame that just replied. (If `acked_rfh_id` is nullopt, it // means the timer expired). async_before_unload_pending_replies_.erase(*acked_rfh_id); } // All IDs remaining in the pending replies set must correspond to live // frames, because RenderFrameHostImpl::~RenderFrameHostImpl handles // removing destroyed frames from the set. // // Using DCHECK because this validation is computationally expensive as it // iterates over all pending replies. DCHECK(std::ranges::all_of(async_before_unload_pending_replies_, [](const GlobalRenderFrameHostId& id) -> bool { return RenderFrameHostImpl::FromID(id); })); if (!async_before_unload_pending_replies_.empty()) { // Wait for the remaining reply for beforeunload. return; } TRACE_EVENT_END("navigation", async_before_unload_trace_track_); // AsyncBeforeUnload // Proceed with navigation commit. async_before_unload_timeout_.Stop(); if (async_before_unload_commit_resume_closure_) { std::move(async_before_unload_commit_resume_closure_).Run(); } } bool NavigationRequest::IsWaitingForAsyncBeforeUnload() const { return !async_before_unload_pending_replies_.empty(); } bool NavigationRequest::IsInitialWebUINavigation() { #if !BUILDFLAG(IS_ANDROID) return GetContentClient()->browser()->IsInitialWebUIURL(GetURL()); #else return false; #endif } perfetto::NamedTrack NavigationRequest::GetNavigationTracingTrack() const { return navigation_trace_track_; } bool NavigationRequest::HasPrefetchedSignedExchange() const { CHECK(base::FeatureList::IsEnabled(features::kNavigationFastFetchDryRun)); if (!prefetched_signed_exchange_cache_) { return false; } const auto& exchanges = prefetched_signed_exchange_cache_->GetExchanges(); return exchanges.find(common_params().url) != exchanges.end(); } } // namespace content