chromium/content/browser/renderer_host/navigation_request.cc

// 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 <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "base/auto_reset.h"
#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/containers/span.h"
#include "base/debug/alias.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/notreached.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/base_tracing.h"
#include "base/types/optional_util.h"
#include "base/types/pass_key.h"
#include "build/build_config.h"
#include "build/buildflag.h"
#include "build/chromeos_buildflags.h"
#include "components/viz/host/host_frame_sink_manager.h"
#include "content/browser/agent_cluster_key.h"
#include "content/browser/blob_storage/chrome_blob_storage_context.h"
#include "content/browser/browsing_topics/header_util.h"
#include "content/browser/child_process_security_policy_impl.h"
#include "content/browser/client_hints/client_hints.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/interest_group/ad_auction_headers_util.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_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/preloading/prefetch/prefetch_document_manager.h"
#include "content/browser/preloading/prefetch/prefetch_features.h"
#include "content/browser/preloading/prefetch/prefetch_serving_page_metrics_container.h"
#include "content/browser/preloading/prerender/prerender_host_registry.h"
#include "content/browser/preloading/prerender/prerender_navigation_utils.h"
#include "content/browser/process_lock.h"
#include "content/browser/reduce_accept_language/reduce_accept_language_utils.h"
#include "content/browser/renderer_host/back_forward_cache_impl.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_tree.h"
#include "content/browser/renderer_host/frame_tree_node.h"
#include "content/browser/renderer_host/navigation_controller_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/navigation_transitions/navigation_entry_screenshot_cache.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/private_network_access_util.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/renderer_host/system_entropy_utils.h"
#include "content/browser/scoped_active_url.h"
#include "content/browser/security/coop/cross_origin_opener_policy_reporter.h"
#include "content/browser/service_worker/service_worker_client.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/shared_storage/shared_storage_header_observer.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/global_request_id.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/render_view_host.h"
#include "content/public/browser/runtime_feature_state/runtime_feature_state_document_data.h"
#include "content/public/browser/site_isolation_policy.h"
#include "content/public/browser/storage_partition.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/system/data_pipe.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/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/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/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/is_potentially_trustworthy.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/fetch_api.mojom.h"
#include "services/network/public/mojom/supports_loading_mode.mojom.h"
#include "services/network/public/mojom/url_response_head.mojom-forward.h"
#include "services/network/public/mojom/url_response_head.mojom-shared.h"
#include "services/network/public/mojom/url_response_head.mojom.h"
#include "services/network/public/mojom/web_client_hints_types.mojom-shared.h"
#include "services/network/public/mojom/web_client_hints_types.mojom.h"
#include "services/network/public/mojom/web_sandbox_flags.mojom.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_permissions_policies.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/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/permissions_policy_features.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/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-shared.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 "ui/compositor/compositor_lock.h"
#include "url/origin.h"
#include "url/url_constants.h"

#if BUILDFLAG(IS_ANDROID)
#include "ui/android/window_android.h"
#include "ui/android/window_android_compositor.h"
#endif

namespace content {

namespace {

// 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 =;

// Timeout for the READY_TO_COMMIT -> COMMIT transition.
// Overrideable via SetCommitTimeoutForTesting.
base::TimeDelta g_commit_timeout =;

#if BUILDFLAG(IS_ANDROID)
// Timeout for locking the compositor at the beginning of navigation.
constexpr base::TimeDelta kCompositorLockTimeout = base::Milliseconds(150);
#endif

// crbug.com/954271: This feature is a part of an ablation study which makes
// history navigations slower.
// TODO(altimin): Clean this up after the study finishes.
BASE_FEATURE();
constexpr base::FeatureParam<double> kDoNotUseCacheProbability{};

const char kSecSharedStorageWritableRequestHeaderKey[] =;

constexpr char kNavigationRequestScope[] =;

// 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 {};

// 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) {}

// TODO(clamy): This should be function in FrameTreeNode.
bool IsSecureFrame(RenderFrameHostImpl* frame) {}

// This should match blink::ResourceRequest::needsHTTPOrigin.
bool NeedsHTTPOrigin(net::HttpRequestHeaders* headers,
                     const std::string& method) {}

// 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 net::HttpRequestHeaders& headers,
                                  const std::string& user_agent_override,
                                  content::BrowserContext* context) {}

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<url::Origin>& initiator_origin,
    blink::mojom::Referrer* referrer,
    FrameTreeNode* frame_tree_node) {}

bool ShouldPropagateUserActivation(const url::Origin& previous_origin,
                                   const url::Origin& new_origin) {}

// LOG_NAVIGATION_TIMING_HISTOGRAM logs |value| for "Navigation.<histogram>" UMA
// as well as supplementary UMAs (depending on |transition| and |priority|)
// for BackForward/Reload/NewNavigation variants.
//
// kMaxTime and kBuckets constants are consistent with
// UMA_HISTOGRAM_MEDIUM_TIMES, 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)

void RecordStartToCommitMetrics(base::TimeTicks navigation_start_time,
                                ui::PageTransition transition,
                                const base::TimeTicks& ready_to_commit_time,
                                std::optional<base::Process::Priority> priority,
                                bool is_same_process,
                                bool is_main_frame) {}

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) {}

// 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) {}

base::debug::CrashKeyString* GetNavigationRequestUrlCrashKey() {}

base::debug::CrashKeyString* GetNavigationRequestInitiatorCrashKey() {}

base::debug::CrashKeyString* GetNavigationRequestIsSameDocumentCrashKey() {}

// Start a new nested async event with the given name.
void EnterChildTraceEvent(const char* name, NavigationRequest* request) {}

// Start a new nested async event with the given name and args.
template <typename ArgType>
void EnterChildTraceEvent(const char* name,
                          NavigationRequest* request,
                          const char* arg_name,
                          ArgType arg_value) {}

network::mojom::RequestDestination GetDestinationFromFrameTreeNode(
    FrameTreeNode* frame_tree_node) {}

// Returns true if the parent's COEP policy `parent_coep` should block a child
// embedded in an <iframe> loaded with `child_coep` policy. The
// `is_credentialless` parameter reflects whether the child will be loaded as a
// credentialless document.
bool CoepBlockIframe(network::mojom::CrossOriginEmbedderPolicyValue parent_coep,
                     network::mojom::CrossOriginEmbedderPolicyValue child_coep,
                     bool is_credentialless) {}

// Computes the history offset of the new document compared to the current one.
int EstimateHistoryOffset(NavigationController& controller,
                          bool should_replace_current_entry) {}

bool IsDocumentToCommitAnonymous(FrameTreeNode* frame,
                                 bool is_synchronous_about_blank_navigation) {}

// Returns the "loading" URL in the renderer. This tries to replicate
// RenderFrameImpl::GetLoadingUrl(). This might return a different URL from
// what we get when calling GetLastCommittedURL() on `rfh`, in case the
// document had changed its URL through document.open() before, or
// when calling last_document_url_in_renderer(), in case of error pages and
// loadDataWithBaseURL documents.
// This function should only be used to preserve calculations that were
// previously done in the renderer but got moved to the browser (e.g. URL
// comparisons to determine if a navigation should do a replacement or not).
const GURL& GetLastLoadingURLInRendererForNavigationReplacement(
    RenderFrameHostImpl* rfh) {}

bool IsOptedInFencedFrame(const net::HttpResponseHeaders& http_headers) {}

// If there are any "Origin-Trial" headers on the |response|, persist those
// that correspond to persistent origin trials, provided the tokens are valid.
void PersistOriginTrialsFromHeaders(
    const url::Origin& origin,
    const url::Origin& partition_origin,
    const network::mojom::URLResponseHead* response,
    BrowserContext* browser_context,
    ukm::SourceId source_id) {}

struct TopicsHeaderValueResult {};

// Returns the topics header for a navigation request. Returns std::nullopt if
// the request isn't eligible for topics. This should align with the handling in
// `GetTopicsHeaderValueForSubresourceRequest()`.
TopicsHeaderValueResult GetTopicsHeaderValueForNavigationRequest(
    FrameTreeNode* frame_tree_node,
    const GURL& url) {}

ukm::SourceId GetPageUkmSourceId(FrameTreeNode* frame_tree_node) {}

bool IsMhtmlMimeType(const std::string& mime_type) {}

network::mojom::WebSandboxFlags GetSandboxFlagsInitiator(
    const std::optional<blink::LocalFrameToken>& frame_token,
    int initiator_process_id,
    StoragePartitionImpl* storage_partition) {}

bool IsSharedStorageWritableEligibleForNavigationRequest(
    FrameTreeNode* frame_tree_node,
    const GURL& url) {}

std::optional<base::SafeRef<RenderFrameHostImpl>>
GetRenderFrameHostForBackForwardCacheRestore(FrameTreeNode* frame_tree_node,
                                             NavigationEntryImpl* entry) {}

void MaybePrewarmHttpDiskCache(
    BrowserContext& browser_context,
    const GURL& url,
    const std::optional<url::Origin>& initiator_origin) {}

// Returns true in cases where an attempted download will end up replacing the
// current document anyway, due to showing an error page.
bool IsFailedDownload(bool is_download,
                      const net::HttpResponseHeaders* headers) {}

// Returns if the given `rfh` should be evicted from BackForwardCache due to
// ongoing navigation.
bool MaybeEvictFromBackForwardCacheBySubframeNavigation(
    RenderFrameHostImpl* rfh) {}

net::StorageAccessApiStatus ShouldLoadWithStorageAccess(
    const blink::mojom::BeginNavigationParams& begin_params,
    const blink::mojom::CommonNavigationParams& common_params,
    const RenderFrameHostImpl* previous_document_rfh,
    bool did_encounter_cross_origin_redirect,
    const GURL response_url,
    const network::mojom::URLResponseHead* response) {}

// The sampling rate for UKM.
constexpr double kUkmSamplingRate =;

}  // namespace

NavigationRequest::PrerenderActivationNavigationState::
    PrerenderActivationNavigationState() = default;
NavigationRequest::PrerenderActivationNavigationState::
    ~PrerenderActivationNavigationState() = default;

// static
std::unique_ptr<NavigationRequest> NavigationRequest::CreateBrowserInitiated(
    FrameTreeNode* frame_tree_node,
    blink::mojom::CommonNavigationParamsPtr common_params,
    blink::mojom::CommitNavigationParamsPtr commit_params,
    bool was_opener_suppressed,
    const std::string& extra_headers,
    FrameNavigationEntry* frame_entry,
    NavigationEntryImpl* entry,
    bool is_form_submission,
    std::unique_ptr<NavigationUIData> navigation_ui_data,
    const std::optional<blink::Impression>& impression,
    bool is_pdf,
    bool is_embedder_initiated_fenced_frame_navigation,
    std::optional<std::u16string> embedder_shared_storage_context) {}

// static
std::unique_ptr<NavigationRequest> NavigationRequest::Create(
    FrameTreeNode* frame_tree_node,
    blink::mojom::CommonNavigationParamsPtr common_params,
    blink::mojom::CommitNavigationParamsPtr commit_params,
    bool browser_initiated,
    bool was_opener_suppressed,
    const std::optional<blink::LocalFrameToken>& initiator_frame_token,
    int initiator_process_id,
    const std::string& extra_headers,
    FrameNavigationEntry* frame_entry,
    NavigationEntryImpl* entry,
    bool is_form_submission,
    std::unique_ptr<NavigationUIData> navigation_ui_data,
    const std::optional<blink::Impression>& impression,
    blink::mojom::NavigationInitiatorActivationAndAdStatus
        initiator_activation_and_ad_status,
    bool is_pdf,
    bool is_embedder_initiated_fenced_frame_navigation,
    bool is_container_initiated,
    bool has_rel_opener,
    net::StorageAccessApiStatus storage_access_api_status,
    std::optional<std::u16string> embedder_shared_storage_context) {}

// static
std::unique_ptr<NavigationRequest> NavigationRequest::CreateRendererInitiated(
    FrameTreeNode* frame_tree_node,
    NavigationEntryImpl* entry,
    blink::mojom::CommonNavigationParamsPtr common_params,
    blink::mojom::BeginNavigationParamsPtr begin_params,
    int current_history_list_offset,
    int current_history_list_length,
    bool override_user_agent,
    scoped_refptr<network::SharedURLLoaderFactory> blob_url_loader_factory,
    mojo::PendingAssociatedRemote<mojom::NavigationClient> navigation_client,
    scoped_refptr<PrefetchedSignedExchangeCache>
        prefetched_signed_exchange_cache,
    mojo::PendingReceiver<mojom::NavigationRendererCancellationListener>
        renderer_cancellation_listener) {}

// static
std::unique_ptr<NavigationRequest>
NavigationRequest::CreateForSynchronousRendererCommit(
    FrameTreeNode* frame_tree_node,
    RenderFrameHostImpl* render_frame_host,
    bool is_same_document,
    const GURL& url,
    const url::Origin& origin,
    const std::optional<GURL>& initiator_base_url,
    const net::IsolationInfo& isolation_info_for_subresources,
    blink::mojom::ReferrerPtr referrer,
    const ui::PageTransition& transition,
    bool should_replace_current_entry,
    const std::string& method,
    bool has_transient_activation,
    bool is_overriding_user_agent,
    const std::vector<GURL>& redirects,
    const GURL& original_url,
    std::unique_ptr<CrossOriginEmbedderPolicyReporter> coep_reporter,
    int http_response_code) {}

// static class variable used to generate unique navigation ids for
// NavigationRequest.
int64_t NavigationRequest::unique_id_counter_ =;

NavigationRequest::NavigationRequest(
    FrameTreeNode* frame_tree_node,
    blink::mojom::CommonNavigationParamsPtr common_params,
    blink::mojom::BeginNavigationParamsPtr begin_params,
    blink::mojom::CommitNavigationParamsPtr commit_params,
    bool browser_initiated,
    bool from_begin_navigation,
    bool is_synchronous_renderer_commit,
    const FrameNavigationEntry* frame_entry,
    NavigationEntryImpl* entry,
    std::unique_ptr<NavigationUIData> navigation_ui_data,
    scoped_refptr<network::SharedURLLoaderFactory> blob_url_loader_factory,
    mojo::PendingAssociatedRemote<mojom::NavigationClient> navigation_client,
    scoped_refptr<PrefetchedSignedExchangeCache>
        prefetched_signed_exchange_cache,
    std::optional<base::SafeRef<RenderFrameHostImpl>>
        rfh_restored_from_back_forward_cache,
    int initiator_process_id,
    bool was_opener_suppressed,
    bool is_pdf,
    bool is_embedder_initiated_fenced_frame_navigation,
    mojo::PendingReceiver<mojom::NavigationRendererCancellationListener>
        renderer_cancellation_listener,
    std::optional<std::u16string> embedder_shared_storage_context)
    :{}

NavigationRequest::~NavigationRequest() {}

void NavigationRequest::RegisterCommitDeferringConditionForTesting(
    std::unique_ptr<CommitDeferringCondition> condition) {}

bool NavigationRequest::IsCommitDeferringConditionDeferredForTesting() {}

CommitDeferringCondition*
NavigationRequest::GetCommitDeferringConditionForTesting() {}

void NavigationRequest::BeginNavigation() {}

bool NavigationRequest::MaybeStartPrerenderingActivationChecks() {}

void NavigationRequest::OnPrerenderingActivationChecksComplete(
    CommitDeferringCondition::NavigationType navigation_type,
    std::optional<int> candidate_prerender_frame_tree_node_id) {}

FencedFrameURLMapping& NavigationRequest::GetFencedFrameURLMap() {}

bool NavigationRequest::NeedFencedFrameURLMapping() {}

void NavigationRequest::OnFencedFrameURLMappingComplete(
    const std::optional<FencedFrameProperties>& properties) {}

void NavigationRequest::BeginNavigationImpl() {}

void NavigationRequest::
    SelectFrameHostForCrossDocumentNavigationWithNoUrlLoader() {}

void NavigationRequest::SetWaitingForRendererResponse() {}

bool NavigationRequest::ShouldAddCookieChangeListener() {}

void NavigationRequest::StartNavigation() {}

void NavigationRequest::ResetForCrossDocumentRestart() {}

void NavigationRequest::ResetStateForSiteInstanceChange() {}

void NavigationRequest::RegisterSubresourceOverride(
    blink::mojom::TransferrableURLLoaderPtr transferrable_loader) {}

mojom::NavigationClient* NavigationRequest::GetCommitNavigationClient() {}

void NavigationRequest::SetRequiredCSP(
    network::mojom::ContentSecurityPolicyPtr csp) {}

network::mojom::ContentSecurityPolicyPtr NavigationRequest::TakeRequiredCSP() {}

const PolicyContainerPolicies*
NavigationRequest::GetInitiatorPolicyContainerPolicies() const {}

const blink::DocumentToken& NavigationRequest::GetDocumentToken() const {}

const PolicyContainerPolicies& NavigationRequest::GetPolicyContainerPolicies()
    const {}

blink::mojom::PolicyContainerPtr
NavigationRequest::CreatePolicyContainerForBlink() {}
scoped_refptr<PolicyContainerHost> NavigationRequest::GetPolicyContainerHost() {}

scoped_refptr<PolicyContainerHost>
NavigationRequest::TakePolicyContainerHost() {}

void NavigationRequest::CreateCoepReporter(
    StoragePartition* storage_partition) {}

std::unique_ptr<CrossOriginEmbedderPolicyReporter>
NavigationRequest::TakeCoepReporter() {}

ukm::SourceId NavigationRequest::GetPreviousPageUkmSourceId() {}

void NavigationRequest::OnRequestRedirected(
    const net::RedirectInfo& redirect_info,
    const net::NetworkAnonymizationKey& network_anonymization_key,
    network::mojom::URLResponseHeadPtr response_head) {}

base::WeakPtr<NavigationRequest> NavigationRequest::GetWeakPtr() {}

base::SafeRef<NavigationHandle> NavigationRequest::GetSafeRef() {}

bool NavigationRequest::ExistingDocumentWasDiscarded() const {}

void NavigationRequest::SetContentSettings(
    blink::mojom::RendererContentSettingsPtr content_settings) {}

blink::mojom::RendererContentSettingsPtr
NavigationRequest::GetContentSettingsForTesting() {}

void NavigationRequest::SetIsAdTagged() {}

void NavigationRequest::CheckForIsolationOptIn(const GURL& url) {}

void NavigationRequest::AddOriginAgentClusterStateIfNecessary(
    const IsolationContext& isolation_context) {}

bool NavigationRequest::IsOriginAgentClusterOptInRequested() {}

bool NavigationRequest::IsOriginAgentClusterOptOutRequested() {}

bool NavigationRequest::IsIsolationImplied() {}

void NavigationRequest::DetermineOriginAgentClusterEndResult() {}

void NavigationRequest::ProcessOriginAgentClusterEndResult() {}

void NavigationRequest::PopulateDocumentTokenForCrossDocumentNavigation() {}

bool NavigationRequest::HasCommittingOrigin(const url::Origin& origin) {}

bool NavigationRequest::ShouldRequestSiteIsolationForCOOP() {}

UrlInfo NavigationRequest::GetUrlInfo() {}

const GURL& NavigationRequest::GetOriginalRequestURL() {}

void NavigationRequest::OnResponseStarted(
    network::mojom::URLLoaderClientEndpointsPtr url_loader_client_endpoints,
    network::mojom::URLResponseHeadPtr response_head,
    mojo::ScopedDataPipeConsumerHandle response_body,
    GlobalRequestID request_id,
    bool is_download,
    net::NetworkAnonymizationKey network_anonymization_key,
    SubresourceLoaderParams subresource_loader_params,
    EarlyHints early_hints) {}

void NavigationRequest::SelectFrameHostForOnResponseStarted(
    network::mojom::URLLoaderClientEndpointsPtr url_loader_client_endpoints,
    bool is_download,
    SubresourceLoaderParams subresource_loader_params) {}

void NavigationRequest::OnRequestFailed(
    const network::URLLoaderCompletionStatus& status) {}

std::optional<NavigationEarlyHintsManagerParams>
NavigationRequest::CreateNavigationEarlyHintsManagerParams(
    const network::mojom::EarlyHints& early_hints) {}

void NavigationRequest::OnRequestFailedInternal(
    const network::URLLoaderCompletionStatus& status,
    bool skip_throttles,
    const std::optional<std::string>& error_page_content,
    bool collapse_frame) {}

void NavigationRequest::SelectFrameHostForOnRequestFailedInternal(
    bool exists_in_cache,
    bool skip_throttles,
    const std::optional<std::string>& error_page_content) {}

NavigationRequest::ErrorPageProcess
NavigationRequest::ComputeErrorPageProcess() {}

void NavigationRequest::OnStartChecksComplete(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnServiceWorkerAccessed(
    const GURL& scope,
    AllowServiceWorkerResult allowed) {}

network::mojom::WebSandboxFlags NavigationRequest::SandboxFlagsInitiator() {}

network::mojom::WebSandboxFlags NavigationRequest::SandboxFlagsInherited() {}

network::mojom::WebSandboxFlags NavigationRequest::SandboxFlagsToCommit() {}

void NavigationRequest::MaybeAddResourceTimingEntryForCancelledNavigation() {}

void NavigationRequest::AddResourceTimingEntryForFailedSubframeNavigation(
    const network::URLLoaderCompletionStatus& status) {}

void NavigationRequest::OnRedirectChecksComplete(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnFailureChecksComplete(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillProcessResponseChecksComplete(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillCommitWithoutUrlLoaderChecksComplete(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::RunCommitDeferringConditions() {}

void NavigationRequest::OnCommitDeferringConditionChecksComplete(
    CommitDeferringCondition::NavigationType navigation_type,
    std::optional<int> candidate_prerender_frame_tree_node_id) {}

void NavigationRequest::CommitErrorPage(
    const std::optional<std::string>& error_page_content) {}

void NavigationRequest::AddOldPageInfoToCommitParamsIfNeeded() {}

bool NavigationRequest::ShouldDispatchPageSwapEvent() const {}

void NavigationRequest::CommitNavigation() {}

void NavigationRequest::CommitPageActivation() {}

void NavigationRequest::SetExpectedProcess(
    RenderProcessHost* expected_process) {}

void NavigationRequest::SetExpectedProcessIfAssociated() {}

void NavigationRequest::ResetExpectedProcess() {}

void NavigationRequest::RenderProcessHostDestroyed(RenderProcessHost* host) {}

void NavigationRequest::RenderProcessExited(
    RenderProcessHost* host,
    const ChildProcessTerminationInfo& info) {}

void NavigationRequest::UpdateNavigationHandleTimingsOnResponseReceived(
    bool is_redirect,
    bool is_first_response) {}

void NavigationRequest::UpdateNavigationHandleTimingsOnCommitSent() {}

void NavigationRequest::UpdateSiteInfo(
    RenderProcessHost* post_redirect_process) {}

bool NavigationRequest::IsAllowedByCSPDirective(
    const std::vector<network::mojom::ContentSecurityPolicyPtr>& policies,
    network::CSPContext* context,
    network::mojom::CSPDirectiveName directive,
    bool has_followed_redirect,
    bool url_upgraded_after_redirect,
    bool is_response_check,
    bool is_opaque_fenced_frame,
    network::CSPContext::CheckCSPDisposition disposition) {}

net::Error NavigationRequest::CheckCSPDirectives(
    RenderFrameHostCSPContext parent_context,
    const PolicyContainerPolicies* parent_policies,
    RenderFrameHostCSPContext initiator_context,
    const PolicyContainerPolicies* initiator_policies,
    bool has_followed_redirect,
    bool url_upgraded_after_redirect,
    bool is_response_check,
    network::CSPContext::CheckCSPDisposition disposition) {}

net::Error NavigationRequest::CheckContentSecurityPolicy(
    bool has_followed_redirect,
    bool url_upgraded_after_redirect,
    bool is_response_check) {}

NavigationRequest::CredentialedSubresourceCheckResult
NavigationRequest::CheckCredentialedSubresource() const {}

NavigationRequest::AboutSrcDocCheckResult NavigationRequest::CheckAboutSrcDoc()
    const {}

void NavigationRequest::SetupCSPEmbeddedEnforcement() {}

NavigationRequest::CSPEmbeddedEnforcementResult
NavigationRequest::CheckCSPEmbeddedEnforcement() {}

void NavigationRequest::UpdateHistoryParamsInCommitNavigationParams() {}

void NavigationRequest::RendererRequestedNavigationCancellationForTesting() {}

void NavigationRequest::OnNavigationClientDisconnected(
    uint32_t reason,
    const std::string& description) {}

void NavigationRequest::HandleInterfaceDisconnection(
    mojo::AssociatedRemote<mojom::NavigationClient>& navigation_client) {}

void NavigationRequest::IgnoreInterfaceDisconnection() {}

void NavigationRequest::IgnoreCommitInterfaceDisconnection() {}

bool NavigationRequest::IsSameDocument() const {}

bool NavigationRequest::IsHistory() const {}

bool NavigationRequest::IsRestore() const {}

void NavigationRequest::RecordDownloadUseCountersPrePolicyCheck() {}

void NavigationRequest::RecordDownloadUseCountersPostPolicyCheck() {}

void NavigationRequest::OnNavigationEventProcessed(
    NavigationThrottleRunner::Event event,
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillStartRequestProcessed(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillRedirectRequestProcessed(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillFailRequestProcessed(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillProcessResponseProcessed(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::OnWillCommitWithoutUrlLoaderProcessed(
    NavigationThrottle::ThrottleCheckResult result) {}

RenderFrameHostImpl*
NavigationRequest::GetRenderFrameHostRestoredFromBackForwardCache() const {}

NavigatorDelegate* NavigationRequest::GetDelegate() const {}

void NavigationRequest::Resume(NavigationThrottle* resuming_throttle) {}

void NavigationRequest::CancelDeferredNavigation(
    NavigationThrottle* cancelling_throttle,
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::RegisterThrottleForTesting(
    std::unique_ptr<NavigationThrottle> navigation_throttle) {}
bool NavigationRequest::IsDeferredForTesting() {}

bool NavigationRequest::IsMhtmlOrSubframe() {}

bool NavigationRequest::IsForMhtmlSubframe() const {}

void NavigationRequest::CancelDeferredNavigationInternal(
    NavigationThrottle::ThrottleCheckResult result) {}

void NavigationRequest::WillStartRequest() {}

void NavigationRequest::WillRedirectRequest(
    const GURL& new_referrer_url,
    RenderProcessHost* post_redirect_process) {}

void NavigationRequest::WillFailRequest() {}

void NavigationRequest::WillProcessResponse() {}

void NavigationRequest::WillCommitWithoutUrlLoader() {}

bool NavigationRequest::IsSelfReferentialURL() {}

void NavigationRequest::DidCommitNavigation(
    const mojom::DidCommitProvisionalLoadParams& params,
    bool navigation_entry_committed,
    bool did_replace_entry,
    const GURL& previous_main_frame_url) {}

SiteInfo NavigationRequest::GetSiteInfoForCommonParamsURL() {}

// TODO(zetamoo): Try to merge this function inside its callers.
void NavigationRequest::UpdateStateFollowingRedirect(
    const GURL& new_referrer_url) {}

void NavigationRequest::SetNavigationClient(
    mojo::PendingAssociatedRemote<mojom::NavigationClient> navigation_client) {}

bool NavigationRequest::NeedsUrlLoader() {}

void NavigationRequest::UpdatePrivateNetworkRequestPolicy() {}

std::vector<blink::mojom::WebFeature>
NavigationRequest::TakeWebFeaturesToLog() {}

void NavigationRequest::ReadyToCommitNavigation(bool is_error) {}

bool NavigationRequest::IsWaitingToCommit() {}

bool NavigationRequest::WasResourceHintsReceived() {}

bool NavigationRequest::IsPdf() {}

bool NavigationRequest::IsLoadDataWithBaseURL() const {}

url::Origin NavigationRequest::GetTentativeOriginAtRequestTime() {}

std::optional<url::Origin> NavigationRequest::GetOriginToCommit() {}

std::pair<std::optional<url::Origin>, std::string>
NavigationRequest::GetOriginToCommitWithDebugInfo() {}

url::Origin NavigationRequest::GetOriginForURLLoaderFactoryBeforeResponse(
    network::mojom::WebSandboxFlags sandbox_flags) {}

std::pair<url::Origin, std::string>
NavigationRequest::GetOriginForURLLoaderFactoryBeforeResponseWithDebugInfo(
    network::mojom::WebSandboxFlags sandbox_flags) {}

std::optional<url::Origin>
NavigationRequest::GetOriginForURLLoaderFactoryAfterResponse() {}

// TODO(crbug.com/40065692): Remove.
// Determine the relationship between the initiator and the current frame.
// `same`: they are the same frame.
// `ancestor`: the initiator is the ancestor of the navigating frame.
// `descendant`: the initiator is the descendant of the navigating frame.
// `other`: any other scenarios.
std::string DetermineInitiatorRelationship(RenderFrameHost* initiator_frame,
                                           RenderFrameHost* current_frame) {}

std::pair<std::optional<url::Origin>, std::string>
NavigationRequest::GetOriginForURLLoaderFactoryAfterResponseWithDebugInfo() {}

void NavigationRequest::WriteIntoTrace(
    perfetto::TracedProto<TraceProto> ctx) const {}

bool NavigationRequest::SetNavigationTimeout(base::TimeDelta timeout) {}

void NavigationRequest::CancelNavigationTimeout() {}

void NavigationRequest::SetAllowCookiesFromBrowser(
    bool allow_cookies_from_browser) {}

void NavigationRequest::GetResponseBody(ResponseBodyCallback callback) {}

void NavigationRequest::RenderProcessBlockedStateChanged(bool blocked) {}

void NavigationRequest::StopCommitTimeout() {}

void NavigationRequest::RestartCommitTimeout() {}

void NavigationRequest::OnCommitTimeout() {}

// static
void NavigationRequest::SetCommitTimeoutForTesting(
    const base::TimeDelta& timeout) {}

void NavigationRequest::SetPrerenderActivationNavigationState(
    std::unique_ptr<NavigationEntryImpl> prerender_navigation_entry,
    const blink::mojom::FrameReplicationState& replication_state) {}

void NavigationRequest::RemoveRequestHeader(const std::string& header_name) {}

void NavigationRequest::SetRequestHeader(const std::string& header_name,
                                         const std::string& header_value) {}

void NavigationRequest::SetCorsExemptRequestHeader(
    const std::string& header_name,
    const std::string& header_value) {}

void NavigationRequest::SetLCPPNavigationHint(
    const blink::mojom::LCPCriticalPathPredictorNavigationTimeHint& hint) {}

const blink::mojom::LCPCriticalPathPredictorNavigationTimeHintPtr&
NavigationRequest::GetLCPPNavigationHint() {}

const net::HttpResponseHeaders* NavigationRequest::GetResponseHeaders() {}

mojom::DidCommitProvisionalLoadParamsPtr
NavigationRequest::MakeDidCommitProvisionalLoadParamsForActivation() {}

mojom::DidCommitProvisionalLoadParamsPtr
NavigationRequest::MakeDidCommitProvisionalLoadParamsForBFCacheRestore() {}

mojom::DidCommitProvisionalLoadParamsPtr
NavigationRequest::MakeDidCommitProvisionalLoadParamsForPrerenderActivation() {}

bool NavigationRequest::IsExternalProtocol() {}

bool NavigationRequest::IsSignedExchangeInnerResponse() {}

net::IPEndPoint NavigationRequest::GetSocketAddress() {}

bool NavigationRequest::HasCommitted() const {}

bool NavigationRequest::IsErrorPage() const {}

bool NavigationRequest::DidEncounterError() const {}

net::HttpConnectionInfo NavigationRequest::GetConnectionInfo() {}

bool NavigationRequest::IsInMainFrame() const {}

RenderFrameHostImpl* NavigationRequest::GetParentFrame() {}

RenderFrameHostImpl* NavigationRequest::GetParentFrameOrOuterDocument() {}

bool NavigationRequest::IsInPrimaryMainFrame() const {}

bool NavigationRequest::IsInOutermostMainFrame() {}

bool NavigationRequest::IsInPrerenderedMainFrame() const {}

bool NavigationRequest::IsPrerenderedPageActivation() const {}

bool NavigationRequest::IsInFencedFrameTree() const {}

FrameType NavigationRequest::GetNavigatingFrameType() const {}

int NavigationRequest::GetFrameTreeNodeId() {}

bool NavigationRequest::WasResponseCached() {}

bool NavigationRequest::HasPrefetchedAlternativeSubresourceSignedExchange() {}

int64_t NavigationRequest::GetNavigationId() const {}

ukm::SourceId NavigationRequest::GetNextPageUkmSourceId() {}

const GURL& NavigationRequest::GetURL() {}

SiteInstanceImpl* NavigationRequest::GetStartingSiteInstance() {}

SiteInstanceImpl* NavigationRequest::GetSourceSiteInstance() {}

bool NavigationRequest::IsRendererInitiated() {}

blink::mojom::NavigationInitiatorActivationAndAdStatus
NavigationRequest::GetNavigationInitiatorActivationAndAdStatus() {}

bool NavigationRequest::IsSameOrigin() {}

bool NavigationRequest::WasServerRedirect() {}

const std::vector<GURL>& NavigationRequest::GetRedirectChain() {}

base::TimeTicks NavigationRequest::NavigationStart() {}

base::TimeTicks NavigationRequest::NavigationInputStart() {}

const NavigationHandleTiming& NavigationRequest::GetNavigationHandleTiming() {}

bool NavigationRequest::IsPost() {}

std::string NavigationRequest::GetRequestMethod() {}

const blink::mojom::Referrer& NavigationRequest::GetReferrer() {}

void NavigationRequest::SetReferrer(blink::mojom::ReferrerPtr referrer) {}

bool NavigationRequest::HasUserGesture() {}

ui::PageTransition NavigationRequest::GetPageTransition() {}

NavigationUIData* NavigationRequest::GetNavigationUIData() {}

net::Error NavigationRequest::GetNetErrorCode() {}

// The RenderFrameHost that will commit the navigation or an error page.
// This is computed when the response is received, or when the navigation
// fails and error page should be displayed.
RenderFrameHostImpl* NavigationRequest::GetRenderFrameHost() const {}

NavigationRequest::AssociatedRenderFrameHostType
NavigationRequest::GetAssociatedRFHType() const {}

void NavigationRequest::SetAssociatedRFHType(
    AssociatedRenderFrameHostType type) {}

const net::HttpRequestHeaders& NavigationRequest::GetRequestHeaders() {}

const std::optional<net::SSLInfo>& NavigationRequest::GetSSLInfo() {}

const std::optional<net::AuthChallengeInfo>&
NavigationRequest::GetAuthChallengeInfo() {}

net::ResolveErrorInfo NavigationRequest::GetResolveErrorInfo() {}

net::IsolationInfo NavigationRequest::GetIsolationInfo() {}

bool NavigationRequest::HasSubframeNavigationEntryCommitted() {}

bool NavigationRequest::DidReplaceEntry() {}

bool NavigationRequest::ShouldUpdateHistory() {}

const GURL& NavigationRequest::GetPreviousPrimaryMainFrameURL() {}

const GURL& NavigationRequest::GetPreviousMainFrameURL() const {}

bool NavigationRequest::WasStartedFromContextMenu() {}

const GURL& NavigationRequest::GetSearchableFormURL() {}

const std::string& NavigationRequest::GetSearchableFormEncoding() {}

ReloadType NavigationRequest::GetReloadType() const {}

RestoreType NavigationRequest::GetRestoreType() const {}

const GURL& NavigationRequest::GetBaseURLForDataURL() {}

const GlobalRequestID& NavigationRequest::GetGlobalRequestID() {}

bool NavigationRequest::IsDownload() {}

bool NavigationRequest::IsFormSubmission() {}

bool NavigationRequest::WasInitiatedByLinkClick() {}

const std::string& NavigationRequest::GetHrefTranslate() {}

const std::optional<blink::Impression>& NavigationRequest::GetImpression() {}

const std::optional<blink::LocalFrameToken>&
NavigationRequest::GetInitiatorFrameToken() {}

int NavigationRequest::GetInitiatorProcessId() {}

const std::optional<url::Origin>& NavigationRequest::GetInitiatorOrigin() {}

const std::optional<GURL>& NavigationRequest::GetInitiatorBaseUrl() {}

const std::vector<std::string>& NavigationRequest::GetDnsAliases() {}

bool NavigationRequest::IsSameProcess() {}

NavigationEntry* NavigationRequest::GetNavigationEntry() const {}

int NavigationRequest::GetNavigationEntryOffset() {}

GlobalRenderFrameHostId NavigationRequest::GetPreviousRenderFrameHostId() {}

int NavigationRequest::GetExpectedRenderProcessHostId() {}

bool NavigationRequest::IsServedFromBackForwardCache() {}

void NavigationRequest::SetIsOverridingUserAgent(bool override_ua) {}

void NavigationRequest::SetSilentlyIgnoreErrors() {}

void NavigationRequest::SetVisitedLinkSalt(uint64_t salt) {}

// static
NavigationRequest* NavigationRequest::From(NavigationHandle* handle) {}

// static
ReloadType NavigationRequest::NavigationTypeToReloadType(
    blink::mojom::NavigationType type) {}

bool NavigationRequest::IsNavigationStarted() const {}

bool NavigationRequest::RequiresInitiatorBasedSourceSiteInstance() const {}

void NavigationRequest::SetSourceSiteInstanceToInitiatorIfNeeded() {}

void NavigationRequest::ForceEnableOriginTrials(
    const std::vector<std::string>& trials) {}

network::CrossOriginEmbedderPolicy
NavigationRequest::ComputeCrossOriginEmbedderPolicy() {}

// [spec]:
// https://html.spec.whatwg.org/C/#check-a-navigation-response's-adherence-to-its-embedder-policy
//
// Return whether the child's |coep| is compatible with its parent's COEP. It
// also sends COEP reports if needed.
bool NavigationRequest::CheckResponseAdherenceToCoep(const GURL& url) {}

std::optional<network::mojom::BlockedByResponseReason>
NavigationRequest::EnforceCOEP() {}

bool NavigationRequest::CoopCoepSanityCheck() {}

bool NavigationRequest::IsFencedFrameRequiredPolicyFeatureAllowed(
    const url::Origin& origin,
    const blink::mojom::PermissionsPolicyFeature feature) {}

bool NavigationRequest::CheckPermissionsPoliciesForFencedFrames(
    const url::Origin& origin) {}

std::unique_ptr<input::PeakGpuMemoryTracker>
NavigationRequest::TakePeakGpuMemoryTracker() {}

std::unique_ptr<NavigationEarlyHintsManager>
NavigationRequest::TakeEarlyHintsManager() {}

network::mojom::ClientSecurityStatePtr
NavigationRequest::BuildClientSecurityStateForNavigationFetch() {}

network::mojom::ClientSecurityStatePtr
NavigationRequest::BuildClientSecurityStateForCommittedDocument() {}

std::string NavigationRequest::GetUserAgentOverride() {}

NavigationControllerImpl* NavigationRequest::GetNavigationController() const {}

PrerenderHostRegistry& NavigationRequest::GetPrerenderHostRegistry() {}

mojo::PendingRemote<network::mojom::CookieAccessObserver>
NavigationRequest::CreateCookieAccessObserver() {}

mojo::PendingRemote<network::mojom::TrustTokenAccessObserver>
NavigationRequest::CreateTrustTokenAccessObserver() {}

mojo::PendingRemote<network::mojom::SharedDictionaryAccessObserver>
NavigationRequest::CreateSharedDictionaryAccessObserver() {}

void NavigationRequest::OnCookiesAccessed(
    std::vector<network::mojom::CookieAccessDetailsPtr> details_vector) {}

void NavigationRequest::Clone(
    mojo::PendingReceiver<network::mojom::CookieAccessObserver> observer) {}

std::vector<mojo::PendingReceiver<network::mojom::CookieAccessObserver>>
NavigationRequest::TakeCookieObservers() {}

void NavigationRequest::OnTrustTokensAccessed(
    network::mojom::TrustTokenAccessDetailsPtr details) {}

void NavigationRequest::Clone(
    mojo::PendingReceiver<network::mojom::TrustTokenAccessObserver> observer) {}

std::vector<mojo::PendingReceiver<network::mojom::TrustTokenAccessObserver>>
NavigationRequest::TakeTrustTokenObservers() {}

void NavigationRequest::OnSharedDictionaryAccessed(
    network::mojom::SharedDictionaryAccessDetailsPtr details) {}

void NavigationRequest::Clone(
    mojo::PendingReceiver<network::mojom::SharedDictionaryAccessObserver>
        observer) {}

std::vector<
    mojo::PendingReceiver<network::mojom::SharedDictionaryAccessObserver>>
NavigationRequest::TakeSharedDictionaryAccessObservers() {}

RenderFrameHostImpl* NavigationRequest::GetInitiatorDocumentRenderFrameHost() {}

void NavigationRequest::RecordAddressSpaceFeature() {}

void NavigationRequest::ComputePoliciesToCommit() {}

void NavigationRequest::ComputePoliciesToCommitForError() {}

void NavigationRequest::CheckStateTransition(NavigationState state) const {}

void NavigationRequest::SetState(NavigationState state) {}

bool NavigationRequest::MaybeCancelFailedNavigation() {}

bool NavigationRequest::ShouldRenderFallbackContentForResponse(
    const net::HttpResponseHeaders& http_headers) const {}

// https://html.spec.whatwg.org/multipage/browsing-the-web.html#navigating-across-documents:hh-replace
bool NavigationRequest::ShouldReplaceCurrentEntryForSameUrlNavigation() const {}

bool NavigationRequest::
    ShouldReplaceCurrentEntryForNavigationFromInitialEmptyDocumentOrEntry()
        const {}

bool NavigationRequest::ShouldReplaceCurrentEntryForFailedNavigation() const {}

const std::optional<FencedFrameProperties>&
NavigationRequest::ComputeFencedFrameProperties(
    FencedFramePropertiesNodeSource node_source) const {}

const std::optional<base::UnguessableToken>
NavigationRequest::ComputeFencedFrameNonce() const {}

void NavigationRequest::RenderFallbackContentForObjectTag() {}

std::optional<base::UnguessableToken>
NavigationRequest::GetNavigationTokenForDeferringSubframes() {}

void NavigationRequest::AddDeferredSubframeNavigationThrottle(
    base::WeakPtr<SubframeHistoryNavigationThrottle> throttle) {}

void NavigationRequest::UnblockPendingSubframeNavigationRequestsIfNeeded() {}

void NavigationRequest::MaybeDispatchNavigateEventForCrossDocumentTraversal() {}

bool NavigationRequest::IsServedFromBackForwardCache() const {}

bool NavigationRequest::IsPageActivation() const {}

std::unique_ptr<NavigationEntryImpl>
NavigationRequest::TakePrerenderNavigationEntry() {}

bool NavigationRequest::IsWaitingForBeforeUnload() {}

void NavigationRequest::AddDeferredConsoleMessage(
    blink::mojom::ConsoleMessageLevel level,
    std::string message) {}

void NavigationRequest::SendDeferredConsoleMessages() {}

std::optional<AgentClusterKey::CrossOriginIsolationKey>
NavigationRequest::ComputeCrossOriginIsolationKey() {}

std::optional<WebExposedIsolationInfo>
NavigationRequest::ComputeWebExposedIsolationInfo() {}

std::optional<url::Origin> NavigationRequest::ComputeCommonCoopOrigin() {}

void NavigationRequest::MaybeAssignInvalidPrerenderFrameTreeNodeId() {}

void NavigationRequest::RendererCancellationWindowEnded() {}

bool NavigationRequest::ShouldWaitForRendererCancellationWindowToEnd() {}

NavigationRequest::ScopedCrashKeys::ScopedCrashKeys(
    NavigationRequest& navigation_request)
    :{}

NavigationRequest::ScopedCrashKeys::~ScopedCrashKeys() = default;

PreloadingTriggerType NavigationRequest::GetPrerenderTriggerType() {}

std::string NavigationRequest::GetPrerenderEmbedderHistogramSuffix() {}

#if BUILDFLAG(IS_ANDROID)
const base::android::JavaRef<jobject>&
NavigationRequest::GetJavaNavigationHandle() {
  return navigation_handle_proxy_->java_navigation_handle();
}
#endif

void NavigationRequest::SetViewTransitionState(
    std::unique_ptr<ScopedViewTransitionResources> resources,
    blink::ViewTransitionState view_transition_state) {}

void NavigationRequest::ResetViewTransitionState() {}

bool NavigationRequest::IsDisabledEmbedderInitiatedFencedFrameNavigation() {}

blink::RuntimeFeatureStateContext&
NavigationRequest::GetMutableRuntimeFeatureStateContext() {}

const blink::RuntimeFeatureStateContext&
NavigationRequest::GetRuntimeFeatureStateContext() {}

// The NavigationDownloadPolicy is currently computed by the renderer process.
// The problem: not every navigation are initiated from the renderer. Most
// fields from the bitfield can be computed from the browser process. This
// function is a partial attempt at doing it.
void NavigationRequest::ComputeDownloadPolicy() {}

bool NavigationRequest::ShouldQueueDueToExistingPendingCommitRFH() const {}

void NavigationRequest::RecordMetricsForBlockedGetFrameHostAttempt(
    bool commit_attempt) {}

void NavigationRequest::PostResumeCommitTask() {}

void NavigationRequest::CheckSoftNavigationHeuristicsInvariants() {}

StoragePartition* NavigationRequest::GetStoragePartitionWithCurrentSiteInfo() {}

void NavigationRequest::CreateWebUIIfNeeded(RenderFrameHostImpl* frame_host) {}

bool NavigationRequest::IsDeferred() {}

void NavigationRequest::OnResponseBodyReady(MojoResult) {}

void NavigationRequest::RecordEarlyRenderFrameHostSwapMetrics() {}

std::pair<url::Origin, std::string>
NavigationRequest::GetOriginForURLLoaderFactoryUncheckedWithDebugInfo() {}

url::Origin NavigationRequest::GetOriginForURLLoaderFactoryUnchecked() {}

bool NavigationRequest::HasLoader() const {}

blink::mojom::PageSwapEventParamsPtr NavigationRequest::WillDispatchPageSwap() {}

std::optional<NavigationDiscardReason>
NavigationRequest::GetNavigationDiscardReason() {}

NavigationDiscardReason NavigationRequest::GetTypeForNavigationDiscardReason() {}

void NavigationRequest::MaybeRecordTraceEventsAndHistograms() {}

void NavigationRequest::SanitizeDocumentIsolationPolicyHeader() {}

}  // namespace content