Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

120 KB
Raw Blame
use super::*;

use crate::content_security_policy::{
    ContentSecurityPolicyDisposition, ContentSecurityPolicyNonUrlKind,
    ContentSecurityPolicyRedirectStatus, ContentSecurityPolicyReportingEndpoints,
    ContentSecurityPolicyResourceKind, ContentSecurityPolicyScriptElementRequest,
    ContentSecurityPolicyStyleElementRequest, ContentSecurityPolicyUrlViolation,
    ContentSecurityPolicyViolationEventFields, TrustedTypesForScriptRequirements,
    content_security_policy_allows_trusted_type_policy_name,
    content_security_policy_allows_trusted_types_eval,
    content_security_policy_frame_ancestors_violation_with_disposition_and_reporting_endpoints,
    content_security_policy_headers,
    content_security_policy_inline_script_element_violation_with_disposition_and_reporting_endpoints,
    content_security_policy_inline_source_violation_with_disposition_and_reporting_endpoints,
    content_security_policy_inline_style_element_violation_with_disposition_and_reporting_endpoints,
    content_security_policy_non_url_violation_with_source,
    content_security_policy_report_only_headers,
    content_security_policy_requires_trusted_types_for_script,
    content_security_policy_script_element_url_violation_with_redirect_status_disposition_reporting_endpoints_and_request,
    content_security_policy_style_element_url_violation_with_redirect_status_disposition_reporting_endpoints_and_request,
    content_security_policy_trusted_types_sink_violation_with_disposition_and_reporting_endpoints,
    content_security_policy_url_violation_with_redirect_status_disposition_and_reporting_endpoints,
    create_security_policy_violation_event,
};
use crate::util::v8str;

pub(crate) type DocumentContentSecurityPolicyViolation = ContentSecurityPolicyUrlViolation;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum DocumentSubresourceCspKind {
    Image,
    Manifest,
    Media,
}

impl DocumentSubresourceCspKind {
    fn resource_kind(self) -> ContentSecurityPolicyResourceKind {
        match self {
            Self::Image => ContentSecurityPolicyResourceKind::DocumentImage,
            Self::Manifest => ContentSecurityPolicyResourceKind::DocumentManifest,
            Self::Media => ContentSecurityPolicyResourceKind::DocumentMedia,
        }
    }
}

#[must_use = "report-only and enforced CSP results must be handled together"]
pub(crate) struct DocumentContentSecurityPolicyCheck {
    report_only_violation: Option<DocumentContentSecurityPolicyViolation>,
    enforced_violation: Option<DocumentContentSecurityPolicyViolation>,
}

impl DocumentContentSecurityPolicyCheck {
    pub(crate) fn has_no_violations(&self) -> bool {
        self.report_only_violation.is_none() && self.enforced_violation.is_none()
    }

    pub(crate) fn into_violations(
        self,
    ) -> (
        Option<DocumentContentSecurityPolicyViolation>,
        Option<DocumentContentSecurityPolicyViolation>,
    ) {
        (self.report_only_violation, self.enforced_violation)
    }

    #[cfg(test)]
    fn report_only_violation(&self) -> Option<&DocumentContentSecurityPolicyViolation> {
        self.report_only_violation.as_ref()
    }

    #[cfg(test)]
    fn enforced_violation(&self) -> Option<&DocumentContentSecurityPolicyViolation> {
        self.enforced_violation.as_ref()
    }
}

#[derive(Clone, Copy, Debug)]
pub(crate) enum DocumentNavigationEmbeddingContext<'a> {
    TopLevel,
    Nested(&'a [Option<Url>]),
}

#[derive(Debug, Clone)]
pub(crate) struct DocumentConnectPolicySnapshot {
    enforce_policies: Vec<ContentSecurityPolicy>,
    report_only_policies: Vec<ContentSecurityPolicy>,
    reporting_endpoints: ContentSecurityPolicyReportingEndpoints,
}

impl DocumentConnectPolicySnapshot {
    pub(crate) fn font_violation(
        &self,
        document_url: &Url,
        request_url: &Url,
        disposition: ContentSecurityPolicyDisposition,
        redirect_status: ContentSecurityPolicyRedirectStatus,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let policies = match disposition {
            ContentSecurityPolicyDisposition::Enforce => &self.enforce_policies,
            ContentSecurityPolicyDisposition::Report => &self.report_only_policies,
        };
        document_url_policy_violation(
            policies,
            &self.reporting_endpoints,
            document_url,
            request_url,
            ContentSecurityPolicyResourceKind::DocumentFont,
            redirect_status,
            disposition,
        )
    }

    pub(crate) fn from_policy_container(policy: &DocumentPolicyContainer) -> Self {
        let mut enforce_policies = policy.response_content_security_policies.clone();
        enforce_policies.extend(policy.document_content_security_policies.iter().cloned());
        Self {
            enforce_policies,
            report_only_policies: policy
                .response_content_security_report_only_policies
                .clone(),
            reporting_endpoints: policy.content_security_reporting_endpoints.clone(),
        }
    }

    pub(crate) fn enforce_violation(
        &self,
        document_url: &Url,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        document_connect_policy_violation(
            &self.enforce_policies,
            &self.reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Enforce,
        )
    }

    pub(crate) fn report_only_violation(
        &self,
        document_url: &Url,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        document_connect_policy_violation(
            &self.report_only_policies,
            &self.reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Report,
        )
    }
}

impl DocumentPolicyContainer {
    pub(crate) fn from_navigation_response_headers(
        headers: &[(String, Vec<u8>)],
        final_url: &Url,
    ) -> Self {
        let response_content_security_policies =
            response_content_security_policies_from_headers(headers);
        let sandbox = DocumentSandboxPolicy::from_response_content_security_policies(
            &response_content_security_policies,
        );
        let origin = if sandbox.forces_opaque_origin {
            url::Origin::new_opaque()
        } else {
            final_url.origin()
        };
        Self {
            referrer_policy: crate::referrer_policy::response_referrer_policy_from_headers(headers),
            cross_origin_embedder_policy:
                crate::cross_origin_isolation::cross_origin_embedder_policy_from_headers(headers),
            document_isolation_policy:
                crate::cross_origin_isolation::document_isolation_policy_from_headers(headers),
            cross_origin_isolated:
                crate::cross_origin_isolation::response_headers_enable_cross_origin_isolation(
                    final_url, headers,
                ),
            document_content_security_policies: response_content_security_policies.clone(),
            sandbox,
            response_content_security_policies,
            response_content_security_report_only_policies:
                response_content_security_report_only_policies_from_headers(headers),
            content_security_reporting_endpoints:
                crate::content_security_policy::content_security_policy_reporting_endpoints_from_headers(
                    headers,
                    final_url,
                ),
            permissions_policy:
                crate::permissions_policy::DocumentPermissionsPolicy::from_navigation_response_headers(
                    headers,
                    final_url,
                ).for_document_origin(&origin),
            ..Self::default()
        }
    }

    pub(crate) fn navigation_response_frame_ancestors_check(
        &self,
        protected_url: &Url,
        embedding_context: DocumentNavigationEmbeddingContext<'_>,
    ) -> DocumentContentSecurityPolicyCheck {
        let DocumentNavigationEmbeddingContext::Nested(ancestor_origins) = embedding_context else {
            return DocumentContentSecurityPolicyCheck {
                report_only_violation: None,
                enforced_violation: None,
            };
        };
        DocumentContentSecurityPolicyCheck {
            report_only_violation:
                content_security_policy_frame_ancestors_violation_with_disposition_and_reporting_endpoints(
                    &self.response_content_security_report_only_policies,
                    protected_url,
                    ancestor_origins,
                    ContentSecurityPolicyDisposition::Report,
                    &self.content_security_reporting_endpoints,
                ),
            enforced_violation:
                content_security_policy_frame_ancestors_violation_with_disposition_and_reporting_endpoints(
                    &self.response_content_security_policies,
                    protected_url,
                    ancestor_origins,
                    ContentSecurityPolicyDisposition::Enforce,
                    &self.content_security_reporting_endpoints,
                ),
        }
    }

    pub(crate) fn clear_content_security_policy_for_bypass(&mut self) {
        self.document_content_security_policies.clear();
        self.response_content_security_policies.clear();
        self.response_content_security_report_only_policies.clear();
        self.content_security_reporting_endpoints = Default::default();
        self.sandbox = DocumentSandboxPolicy::default();
    }

    pub(crate) fn with_content_security_policy_bypass(mut self, bypass: bool) -> Self {
        if bypass {
            self.clear_content_security_policy_for_bypass();
        }
        self
    }
}

impl DocumentRuntime {
    #[inline]
    pub(super) fn apply_style_csp_mutation_followups<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        attribute_mutations: &[super::mutation_commands::InlineStyleAttributeCspMutation],
        connected_roots: &[DomHandle],
        stylesheet_owner_changes: &[crate::dom::native::DomStylesheetOwnerChange],
    ) {
        if attribute_mutations.is_empty()
            && connected_roots.is_empty()
            && stylesheet_owner_changes.is_empty()
        {
            return;
        }
        self.apply_nonempty_style_csp_mutation_followups(
            scope,
            host_ptr,
            attribute_mutations,
            connected_roots,
            stylesheet_owner_changes,
        );
    }

    fn apply_nonempty_style_csp_mutation_followups<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        attribute_mutations: &[super::mutation_commands::InlineStyleAttributeCspMutation],
        connected_roots: &[DomHandle],
        stylesheet_owner_changes: &[crate::dom::native::DomStylesheetOwnerChange],
    ) {
        let mut checked_attributes = HashSet::new();
        for mutation in attribute_mutations {
            let target = mutation.target();
            checked_attributes.insert(target);
            self.apply_inline_style_attribute_csp_check(
                scope,
                host_ptr,
                target,
                mutation.new_value(),
            );
        }

        let mut stylesheet_owners = Vec::new();
        for change in stylesheet_owner_changes {
            let owner = change.owner();
            let is_inline_style = self.dom_host.is_inline_style_sheet_owner(owner);
            let is_link = self.dom_host.is_html_element_named(owner, "link");
            let reprocesses_owner = match change.kind() {
                DomStylesheetOwnerChangeKind::Registered
                | DomStylesheetOwnerChangeKind::OwnerDocumentChanged
                | DomStylesheetOwnerChangeKind::TreeConnectionChanged { connected: true } => true,
                DomStylesheetOwnerChangeKind::Contents
                | DomStylesheetOwnerChangeKind::ParsingFinished => is_inline_style,
                DomStylesheetOwnerChangeKind::Attribute {
                    namespace,
                    local_name,
                } => {
                    namespace.is_none()
                        && ((is_inline_style && local_name == "type")
                            || (is_link && attribute_reprocesses_connected_stylesheet(local_name)))
                }
                DomStylesheetOwnerChangeKind::Unregistered
                | DomStylesheetOwnerChangeKind::TreeConnectionChanged { connected: false } => {
                    self.set_stylesheet_owner_csp_disposition(
                        host_ptr,
                        owner,
                        super::StylesheetOwnerCspDisposition::Allowed,
                    );
                    false
                }
            };
            if reprocesses_owner
                && (is_inline_style || is_link)
                && !stylesheet_owners.contains(&owner)
            {
                stylesheet_owners.push(owner);
            }
        }
        for &root in connected_roots {
            let mut stack = vec![root];
            while let Some(handle) = stack.pop() {
                if self.dom_host.node(handle).is_some_and(Node::is_element) {
                    if !checked_attributes.contains(&handle)
                        && unsafe { &*host_ptr }.element_inline_style_csp_state(handle)
                            == crate::style_engine::InlineStyleCspState::Unchecked
                        && let Some(source) = self.dom_host.get_attribute(handle, "style")
                    {
                        checked_attributes.insert(handle);
                        self.apply_inline_style_attribute_csp_check(
                            scope,
                            host_ptr,
                            handle,
                            Some(&source),
                        );
                    }
                    if (self.dom_host.is_inline_style_sheet_owner(handle)
                        || self.dom_host.is_html_element_named(handle, "link"))
                        && !stylesheet_owners.contains(&handle)
                    {
                        stylesheet_owners.push(handle);
                    }
                }
                if let Some(shadow_root) = self.dom_host.shadow_root_handle(handle) {
                    stack.push(shadow_root);
                }
                let mut child = self.dom_host.first_child(handle);
                while let Some(current) = child {
                    stack.push(current);
                    child = self.dom_host.next_sibling(current);
                }
            }
        }

        for owner in stylesheet_owners {
            if self.dom_host.is_inline_style_sheet_owner(owner) {
                if self.dom_host.is_style_element_parsing_children(owner) {
                    continue;
                }
                self.apply_inline_style_element_csp_check(scope, host_ptr, owner);
            } else {
                self.apply_link_style_element_csp_check(scope, host_ptr, owner);
            }
        }
    }

    fn set_stylesheet_owner_csp_disposition(
        &mut self,
        host_ptr: *mut JsContextHost,
        owner: DomHandle,
        disposition: super::StylesheetOwnerCspDisposition,
    ) {
        self.stylesheet_lifecycle
            .owner_states
            .set_csp_disposition(owner, disposition);
        unsafe { &mut *host_ptr }
            .set_owner_style_sheet_csp_suppressed(owner, disposition.is_blocked());
    }

    pub(crate) fn stylesheet_owner_is_csp_blocked(&self, owner: DomHandle) -> bool {
        self.stylesheet_lifecycle
            .owner_states
            .csp_disposition(owner)
            .is_blocked()
    }

    fn apply_inline_style_attribute_csp_check<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        target: DomHandle,
        source: Option<&str>,
    ) {
        let Some(source) = source else {
            unsafe { &mut *host_ptr }.set_element_inline_style_csp_state(
                target,
                crate::style_engine::InlineStyleCspState::Unchecked,
            );
            return;
        };
        let (report_only_violation, enforced_violation) = self
            .inline_source_csp_check(
                ContentSecurityPolicyNonUrlKind::DocumentInlineStyleAttribute,
                source,
            )
            .into_violations();
        unsafe { &mut *host_ptr }.set_element_inline_style_csp_state(
            target,
            if enforced_violation.is_some() {
                crate::style_engine::InlineStyleCspState::BlockedAttribute
            } else {
                crate::style_engine::InlineStyleCspState::AllowedAttribute
            },
        );
        for violation in [report_only_violation, enforced_violation]
            .into_iter()
            .flatten()
        {
            self.queue_content_security_policy_violation_event_for_element_best_effort(
                scope, host_ptr, target, &violation,
            );
        }
    }

    fn apply_inline_style_element_csp_check<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        owner: DomHandle,
    ) {
        if !self.dom_host.is_connected(owner) {
            return;
        }
        let Some(element) = self.dom_host.node(owner).and_then(Node::as_element) else {
            return;
        };
        let source = self.dom_host.text_content(owner).unwrap_or_default();
        let nonce = element.cryptographic_nonce().map(str::to_owned);
        let is_declarative_css_module =
            super::stylesheet_runtime::is_declarative_css_module_style_element(element);
        let (style_report_only_violation, style_enforced_violation) = self
            .inline_style_element_csp_check(
                &source,
                ContentSecurityPolicyStyleElementRequest {
                    nonce: nonce.as_deref(),
                },
            )
            .into_violations();
        let (script_report_only_violation, script_enforced_violation) = if is_declarative_css_module
        {
            // A declarative CSS module is not a script element and carries no
            // creator-script trust to propagate through `strict-dynamic`.
            // Use the parser-inserted request shape even when script created.
            self.inline_script_element_csp_check(
                &source,
                ContentSecurityPolicyScriptElementRequest::parser_inserted_with_nonce(
                    nonce.as_deref(),
                ),
            )
            .into_violations()
        } else {
            (None, None)
        };
        self.set_stylesheet_owner_csp_disposition(
            host_ptr,
            owner,
            super::StylesheetOwnerCspDisposition::from_blocked(
                style_enforced_violation.is_some() || script_enforced_violation.is_some(),
            ),
        );
        for violation in [
            style_report_only_violation,
            style_enforced_violation,
            script_report_only_violation,
            script_enforced_violation,
        ]
        .into_iter()
        .flatten()
        {
            self.queue_content_security_policy_violation_event_for_element_best_effort(
                scope, host_ptr, owner, &violation,
            );
        }
    }

    fn apply_link_style_element_csp_check<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        owner: DomHandle,
    ) {
        if !self.dom_host.is_connected(owner) {
            return;
        }
        let nonce = self
            .dom_host
            .node(owner)
            .and_then(Node::as_element)
            .and_then(|element| element.cryptographic_nonce())
            .map(str::to_owned);
        let node_id = NodeId::new(owner.index());
        let request_url =
            crate::stylesheet_blocking::stylesheet_link_disposition(&self.dom_host, node_id)
                .map(|disposition| disposition.url().clone())
                .or_else(|| {
                    crate::stylesheet_blocking::stylesheet_preload_link_request(
                        &self.dom_host,
                        node_id,
                    )
                    .map(|request| request.url().clone())
                });
        let Some(request_url) = request_url else {
            self.set_stylesheet_owner_csp_disposition(
                host_ptr,
                owner,
                super::StylesheetOwnerCspDisposition::Allowed,
            );
            return;
        };
        let (report_only_violation, enforced_violation) = self
            .style_element_request_csp_check(
                &request_url,
                ContentSecurityPolicyStyleElementRequest {
                    nonce: nonce.as_deref(),
                },
            )
            .into_violations();
        self.set_stylesheet_owner_csp_disposition(
            host_ptr,
            owner,
            super::StylesheetOwnerCspDisposition::from_blocked(enforced_violation.is_some()),
        );
        for violation in [report_only_violation, enforced_violation]
            .into_iter()
            .flatten()
        {
            self.queue_content_security_policy_violation_event_for_element_best_effort(
                scope, host_ptr, owner, &violation,
            );
        }
    }

    pub(crate) fn document_policy_container(&self) -> &DocumentPolicyContainer {
        &self.policy_container
    }

    /// An initial empty Document inherits the complete creator policy,
    /// including sandbox flags supplied by an embedding iframe.
    pub(crate) fn set_initial_document_policy_container(
        &mut self,
        policy: DocumentPolicyContainer,
    ) {
        self.policy_container = policy;
    }

    pub(crate) fn set_main_navigation_policy_container(
        &mut self,
        mut policy: DocumentPolicyContainer,
    ) {
        policy.sandbox = DocumentSandboxPolicy::from_response_content_security_policies(
            &policy.response_content_security_policies,
        );
        self.policy_container = policy;
    }

    pub(crate) fn set_bypass_content_security_policy(&mut self, bypass: bool) {
        self.bypass_content_security_policy = bypass;
    }

    pub(crate) fn bypass_content_security_policy(&self) -> bool {
        self.bypass_content_security_policy
    }

    pub(crate) fn document_content_security_policies(&self) -> &[ContentSecurityPolicy] {
        self.policy_container
            .document_content_security_policies
            .as_slice()
    }

    #[cfg(test)]
    pub(crate) fn set_response_content_security_policies(&mut self, policies: &[String]) {
        self.policy_container.response_content_security_policies =
            policies.iter().cloned().map(Into::into).collect();
        self.policy_container.sandbox =
            DocumentSandboxPolicy::from_response_content_security_policies(
                &self.policy_container.response_content_security_policies,
            );
    }

    pub(crate) fn response_content_security_policies(&self) -> &[ContentSecurityPolicy] {
        &self.policy_container.response_content_security_policies
    }

    #[cfg(test)]
    pub(crate) fn set_response_content_security_report_only_policies(
        &mut self,
        policies: &[String],
    ) {
        self.policy_container
            .response_content_security_report_only_policies = policies
            .iter()
            .cloned()
            .map(|policy| {
                ContentSecurityPolicy::from_header(policy, ContentSecurityPolicyDisposition::Report)
            })
            .collect();
    }

    #[cfg(test)]
    pub(crate) fn set_response_referrer_policy(&mut self, policy: Option<String>) {
        self.policy_container.referrer_policy = policy;
    }

    pub(crate) fn response_referrer_policy(&self) -> Option<&str> {
        self.policy_container.referrer_policy.as_deref()
    }

    pub(crate) fn cross_origin_embedder_policy(
        &self,
    ) -> crate::cross_origin_isolation::CrossOriginEmbedderPolicy {
        self.policy_container.cross_origin_embedder_policy
    }

    pub(crate) fn document_isolation_policy(
        &self,
    ) -> crate::cross_origin_isolation::DocumentIsolationPolicy {
        self.policy_container.document_isolation_policy
    }

    pub(crate) fn cross_origin_isolated(&self) -> bool {
        self.policy_container.cross_origin_isolated
    }

    pub(crate) fn ensure_credentialless_storage_nonce(
        &mut self,
        browser_context_runtime: &crate::runtime::RendererBrowserContextRuntime,
    ) -> moli_storage_key::OpaqueOriginNonce {
        if let Some(nonce) = self.policy_container.credentialless_storage_nonce {
            return nonce;
        }
        let nonce = browser_context_runtime.next_web_storage_opaque_context_nonce();
        self.policy_container.credentialless_storage_nonce = Some(nonce);
        nonce
    }

    pub(crate) fn document_sandbox_policy(&self) -> DocumentSandboxPolicy {
        self.policy_container.sandbox
    }

    pub(crate) fn response_content_security_report_only_policies(
        &self,
    ) -> &[ContentSecurityPolicy] {
        &self
            .policy_container
            .response_content_security_report_only_policies
    }

    #[cfg(test)]
    pub(crate) fn set_content_security_reporting_endpoints(
        &mut self,
        endpoints: ContentSecurityPolicyReportingEndpoints,
    ) {
        self.policy_container.content_security_reporting_endpoints = endpoints;
    }

    pub(crate) fn content_security_reporting_endpoints(
        &self,
    ) -> &ContentSecurityPolicyReportingEndpoints {
        &self.policy_container.content_security_reporting_endpoints
    }

    #[cfg(test)]
    pub(crate) fn script_element_request_csp_violation(
        &self,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_violation_with_nonce(request_url, None)
    }

    pub(crate) fn script_element_request_csp_violation_with_nonce(
        &self,
        request_url: &Url,
        nonce: Option<&str>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_violation_with_request(
            request_url,
            ContentSecurityPolicyScriptElementRequest::parser_inserted_with_nonce(nonce),
        )
    }

    pub(crate) fn script_element_request_csp_violation_with_request(
        &self,
        request_url: &Url,
        request: ContentSecurityPolicyScriptElementRequest<'_>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_violation_with_redirect_status(
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            request,
        )
    }

    pub(crate) fn script_element_request_csp_violation_with_redirect_status(
        &self,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
        request: ContentSecurityPolicyScriptElementRequest<'_>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let document_url = self.document_url();
        let policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        document_script_element_url_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Enforce,
            request,
        )
    }

    #[cfg(test)]
    pub(crate) fn script_element_request_csp_report_only_violation(
        &self,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_report_only_violation_with_nonce(request_url, None)
    }

    pub(crate) fn script_element_request_csp_report_only_violation_with_nonce(
        &self,
        request_url: &Url,
        nonce: Option<&str>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_report_only_violation_with_request(
            request_url,
            ContentSecurityPolicyScriptElementRequest::parser_inserted_with_nonce(nonce),
        )
    }

    pub(crate) fn script_element_request_csp_report_only_violation_with_request(
        &self,
        request_url: &Url,
        request: ContentSecurityPolicyScriptElementRequest<'_>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_report_only_violation_with_redirect_status(
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            request,
        )
    }

    pub(crate) fn script_element_request_csp_report_only_violation_with_redirect_status(
        &self,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
        request: ContentSecurityPolicyScriptElementRequest<'_>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let document_url = self.document_url();
        document_script_element_url_policy_violation(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Report,
            request,
        )
    }

    pub(crate) fn document_connect_csp_check_with_redirect_status(
        &self,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
    ) -> DocumentContentSecurityPolicyCheck {
        let document_url = self.document_url();
        let policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let enforced_violation = document_connect_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Enforce,
        );
        let report_only_violation = document_connect_policy_violation(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
            self.document_url(),
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Report,
        );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn document_subresource_csp_check(
        &self,
        request_url: &Url,
        kind: DocumentSubresourceCspKind,
    ) -> DocumentContentSecurityPolicyCheck {
        self.document_subresource_csp_check_for_document(
            Some(self.document_handle()),
            self.document_url(),
            &self.policy_container,
            request_url,
            kind,
        )
    }

    pub(crate) fn document_subresource_csp_check_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        policy_container: &DocumentPolicyContainer,
        request_url: &Url,
        kind: DocumentSubresourceCspKind,
    ) -> DocumentContentSecurityPolicyCheck {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            &policy_container.response_content_security_policies,
            &policy_container.content_security_reporting_endpoints,
        );
        let enforced_violation = document_url_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            kind.resource_kind(),
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Enforce,
        );
        let report_only_violation = document_url_policy_violation(
            &policy_container.response_content_security_report_only_policies,
            &policy_container.content_security_reporting_endpoints,
            document_url,
            request_url,
            kind.resource_kind(),
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Report,
        );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn inline_source_csp_check(
        &self,
        kind: ContentSecurityPolicyNonUrlKind,
        source: &str,
    ) -> DocumentContentSecurityPolicyCheck {
        self.inline_source_csp_check_for_document(
            Some(self.document_handle()),
            self.document_url(),
            &self.policy_container.response_content_security_policies,
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
            kind,
            source,
        )
    }

    pub(crate) fn inline_script_element_csp_check(
        &self,
        source: &str,
        request: ContentSecurityPolicyScriptElementRequest<'_>,
    ) -> DocumentContentSecurityPolicyCheck {
        self.inline_script_element_csp_check_for_document(
            Some(self.document_handle()),
            self.document_url(),
            &self.policy_container.response_content_security_policies,
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
            source,
            request,
        )
    }

    pub(crate) fn inline_style_element_csp_check(
        &self,
        source: &str,
        request: ContentSecurityPolicyStyleElementRequest<'_>,
    ) -> DocumentContentSecurityPolicyCheck {
        let document_url = self.document_url();
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let enforced_violation =
            document_inline_style_element_policy_violation_from_document_policies(
                enforced_policies,
                document_url,
                source,
                request,
                ContentSecurityPolicyDisposition::Enforce,
            );
        let report_only_policies = document_response_content_security_policies(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let report_only_violation =
            document_inline_style_element_policy_violation_from_document_policies(
                report_only_policies,
                document_url,
                source,
                request,
                ContentSecurityPolicyDisposition::Report,
            );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn style_element_request_csp_check(
        &self,
        request_url: &Url,
        request: ContentSecurityPolicyStyleElementRequest<'_>,
    ) -> DocumentContentSecurityPolicyCheck {
        let document_url = self.document_url();
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let enforced_violation = document_style_element_url_policy_violation_from_document_policies(
            enforced_policies,
            document_url,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Enforce,
            request,
        );
        let report_only_policies = document_response_content_security_policies(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let report_only_violation =
            document_style_element_url_policy_violation_from_document_policies(
                report_only_policies,
                document_url,
                request_url,
                ContentSecurityPolicyRedirectStatus::NoRedirect,
                ContentSecurityPolicyDisposition::Report,
                request,
            );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn response_style_element_request_csp_check(
        &self,
        request_url: &Url,
        request: ContentSecurityPolicyStyleElementRequest<'_>,
    ) -> DocumentContentSecurityPolicyCheck {
        let document_url = self.document_url();
        let enforced_policies = document_response_content_security_policies(
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let enforced_violation = document_style_element_url_policy_violation_from_document_policies(
            enforced_policies,
            document_url,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Enforce,
            request,
        );
        let report_only_policies = document_response_content_security_policies(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        let report_only_violation =
            document_style_element_url_policy_violation_from_document_policies(
                report_only_policies,
                document_url,
                request_url,
                ContentSecurityPolicyRedirectStatus::NoRedirect,
                ContentSecurityPolicyDisposition::Report,
                request,
            );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    #[allow(clippy::too_many_arguments)]
    pub(crate) fn inline_script_element_csp_check_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        source: &str,
        request: ContentSecurityPolicyScriptElementRequest<'_>,
    ) -> DocumentContentSecurityPolicyCheck {
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        let enforced_violation =
            document_inline_script_element_policy_violation_from_document_policies(
                enforced_policies,
                document_url,
                source,
                request,
                ContentSecurityPolicyDisposition::Enforce,
            );
        let report_only_policies = document_response_content_security_policies(
            response_report_only_policies,
            response_reporting_endpoints,
        );
        let report_only_violation =
            document_inline_script_element_policy_violation_from_document_policies(
                report_only_policies,
                document_url,
                source,
                request,
                ContentSecurityPolicyDisposition::Report,
            );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn inline_source_csp_check_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        kind: ContentSecurityPolicyNonUrlKind,
        source: &str,
    ) -> DocumentContentSecurityPolicyCheck {
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        let enforced_violation = document_inline_source_policy_violation_from_document_policies(
            enforced_policies,
            document_url,
            kind,
            source,
            ContentSecurityPolicyDisposition::Enforce,
        );
        let report_only_policies = document_response_content_security_policies(
            response_report_only_policies,
            response_reporting_endpoints,
        );
        let report_only_violation = document_inline_source_policy_violation_from_document_policies(
            report_only_policies,
            document_url,
            kind,
            source,
            ContentSecurityPolicyDisposition::Report,
        );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn non_url_csp_check_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        kind: ContentSecurityPolicyNonUrlKind,
        source: Option<&str>,
    ) -> DocumentContentSecurityPolicyCheck {
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        let enforced_violation = document_non_url_policy_violation_from_document_policies(
            enforced_policies,
            document_url,
            kind,
            source,
            ContentSecurityPolicyDisposition::Enforce,
        );
        let report_only_policies = document_response_content_security_policies(
            response_report_only_policies,
            response_reporting_endpoints,
        );
        let report_only_violation = document_non_url_policy_violation_from_document_policies(
            report_only_policies,
            document_url,
            kind,
            source,
            ContentSecurityPolicyDisposition::Report,
        );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    #[cfg(test)]
    pub(crate) fn document_frame_csp_violation(
        &self,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let document_url = self.document_url();
        let policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        document_frame_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Enforce,
        )
    }

    pub(crate) fn script_element_request_csp_violation_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_violation_for_document_with_redirect_status(
            document_handle,
            document_url,
            response_policies,
            response_reporting_endpoints,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            None,
        )
    }

    pub(crate) fn script_element_request_csp_violation_for_document_with_redirect_status(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
        nonce: Option<&str>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        document_script_element_url_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Enforce,
            ContentSecurityPolicyScriptElementRequest::parser_inserted_with_nonce(nonce),
        )
    }

    pub(crate) fn script_element_request_csp_report_only_violation_for_document(
        &self,
        document_url: &Url,
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.script_element_request_csp_report_only_violation_for_document_with_redirect_status(
            document_url,
            response_report_only_policies,
            response_reporting_endpoints,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            None,
        )
    }

    pub(crate) fn script_element_request_csp_report_only_violation_for_document_with_redirect_status(
        &self,
        document_url: &Url,
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
        nonce: Option<&str>,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        document_script_element_url_policy_violation(
            response_report_only_policies,
            response_reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Report,
            ContentSecurityPolicyScriptElementRequest::parser_inserted_with_nonce(nonce),
        )
    }

    #[allow(clippy::too_many_arguments)]
    pub(crate) fn document_connect_csp_check_for_document_with_redirect_status(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
        redirect_status: ContentSecurityPolicyRedirectStatus,
    ) -> DocumentContentSecurityPolicyCheck {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        let enforced_violation = document_connect_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Enforce,
        );
        let report_only_violation = document_connect_policy_violation(
            response_report_only_policies,
            response_reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            ContentSecurityPolicyDisposition::Report,
        );
        DocumentContentSecurityPolicyCheck {
            report_only_violation,
            enforced_violation,
        }
    }

    pub(crate) fn document_frame_csp_violation_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        document_frame_policy_violation_from_document_policies(
            policies,
            document_url,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Enforce,
        )
    }

    pub(crate) fn document_frame_csp_report_only_violation_for_document(
        &self,
        document_url: &Url,
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        request_url: &Url,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        document_frame_policy_violation(
            response_report_only_policies,
            response_reporting_endpoints,
            document_url,
            request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
            ContentSecurityPolicyDisposition::Report,
        )
    }

    pub(crate) fn inline_script_csp_violation_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        document_non_url_policy_violation_from_document_policies(
            policies,
            document_url,
            ContentSecurityPolicyNonUrlKind::DocumentInlineScript,
            None,
            ContentSecurityPolicyDisposition::Enforce,
        )
    }

    pub(crate) fn inline_script_csp_report_only_violation_for_document(
        &self,
        document_url: &Url,
        response_report_only_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let policies = document_response_content_security_policies(
            response_report_only_policies,
            response_reporting_endpoints,
        );
        document_non_url_policy_violation_from_document_policies(
            policies,
            document_url,
            ContentSecurityPolicyNonUrlKind::DocumentInlineScript,
            None,
            ContentSecurityPolicyDisposition::Report,
        )
    }

    #[cfg(test)]
    pub(crate) fn wasm_eval_csp_violation(&self) -> Option<DocumentContentSecurityPolicyViolation> {
        self.non_url_csp_violation(
            ContentSecurityPolicyNonUrlKind::WasmEval,
            None,
            ContentSecurityPolicyDisposition::Enforce,
        )
    }

    #[cfg(test)]
    fn non_url_csp_violation(
        &self,
        kind: ContentSecurityPolicyNonUrlKind,
        source: Option<&str>,
        disposition: ContentSecurityPolicyDisposition,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let document_url = self.document_url();
        let policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        document_non_url_policy_violation_from_document_policies(
            policies,
            document_url,
            kind,
            source,
            disposition,
        )
    }

    #[cfg(test)]
    fn non_url_csp_report_only_violation(
        &self,
        kind: ContentSecurityPolicyNonUrlKind,
        source: Option<&str>,
        disposition: ContentSecurityPolicyDisposition,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let document_url = self.document_url();
        let policies = document_response_content_security_policies(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        document_non_url_policy_violation_from_document_policies(
            policies,
            document_url,
            kind,
            source,
            disposition,
        )
    }

    #[cfg(test)]
    pub(crate) fn wasm_eval_csp_report_only_violation(
        &self,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        self.non_url_csp_report_only_violation(
            ContentSecurityPolicyNonUrlKind::WasmEval,
            None,
            ContentSecurityPolicyDisposition::Report,
        )
    }

    #[cfg(test)]
    pub(crate) fn trusted_types_sink_csp_report_only_violation(
        &self,
        sink: &str,
        sample: &str,
    ) -> Option<DocumentContentSecurityPolicyViolation> {
        let document_url = self.document_url();
        let policies = document_response_content_security_policies(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        document_trusted_types_sink_policy_violation_from_document_policies(
            policies,
            document_url,
            sink,
            sample,
            ContentSecurityPolicyDisposition::Report,
        )
    }

    #[cfg(test)]
    pub(crate) fn trusted_types_for_script_requirements(
        &self,
    ) -> TrustedTypesForScriptRequirements {
        let enforced = self.requires_trusted_types_for_script();
        let report_only_policies = document_response_content_security_policies(
            &self
                .policy_container
                .response_content_security_report_only_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        TrustedTypesForScriptRequirements::new(
            enforced,
            document_policies_require_trusted_types_for_script(&report_only_policies),
        )
    }

    pub(crate) fn trusted_types_for_script_requirements_for_document(
        &self,
        document_handle: Option<DomHandle>,
        response_policies: &[ContentSecurityPolicy],
        report_only_policies: &[ContentSecurityPolicy],
        reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    ) -> TrustedTypesForScriptRequirements {
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            reporting_endpoints,
        );
        let report_only_policies =
            document_response_content_security_policies(report_only_policies, reporting_endpoints);
        TrustedTypesForScriptRequirements::new(
            document_policies_require_trusted_types_for_script(&enforced_policies),
            document_policies_require_trusted_types_for_script(&report_only_policies),
        )
    }

    pub(crate) fn trusted_types_sink_csp_violations_for_document(
        &self,
        document_handle: Option<DomHandle>,
        document_url: &Url,
        response_policies: &[ContentSecurityPolicy],
        report_only_policies: &[ContentSecurityPolicy],
        reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        sink: &str,
        sample: &str,
    ) -> Vec<DocumentContentSecurityPolicyViolation> {
        let report_only_policies =
            document_response_content_security_policies(report_only_policies, reporting_endpoints);
        let enforced_policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            reporting_endpoints,
        );
        let mut violations = iter_document_trusted_types_sink_policy_violations(
            enforced_policies,
            document_url,
            sink,
            sample,
            ContentSecurityPolicyDisposition::Enforce,
        )
        .collect::<Vec<_>>();
        violations.extend(iter_document_trusted_types_sink_policy_violations(
            report_only_policies,
            document_url,
            sink,
            sample,
            ContentSecurityPolicyDisposition::Report,
        ));
        violations
    }

    pub(crate) fn requires_trusted_types_for_script(&self) -> bool {
        let policies = self.document_content_security_policies_for_optional_document(
            Some(self.document_handle()),
            &self.policy_container.response_content_security_policies,
            &self.policy_container.content_security_reporting_endpoints,
        );
        document_policies_require_trusted_types_for_script(&policies)
    }

    pub(crate) fn allows_trusted_types_eval_for_document(
        &self,
        document_handle: Option<DomHandle>,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    ) -> bool {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        document_policies_allow_trusted_types_eval(&policies)
    }

    pub(crate) fn allows_trusted_type_policy_name_for_document(
        &self,
        document_handle: Option<DomHandle>,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
        policy_name: &str,
    ) -> bool {
        let policies = self.document_content_security_policies_for_optional_document(
            document_handle,
            response_policies,
            response_reporting_endpoints,
        );
        document_policies_allow_trusted_type_policy_name(policies, policy_name)
    }

    pub(crate) fn queue_content_security_policy_violation_event_best_effort<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        violation: &DocumentContentSecurityPolicyViolation,
    ) {
        if let Err(error) =
            self.queue_content_security_policy_violation_event(scope, host_ptr, violation)
        {
            tracing::error!(
                blocked_uri = violation.blocked_uri.as_str(),
                message = error.to_string().as_str(),
                "securitypolicyviolation queueing failed"
            );
        }
    }

    pub(crate) fn queue_content_security_policy_violation_event_for_element_best_effort<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        target: DomHandle,
        violation: &DocumentContentSecurityPolicyViolation,
    ) {
        if let Err(error) = self.queue_content_security_policy_violation_event_for_target(
            scope,
            host_ptr,
            Some(target),
            violation,
            true,
        ) {
            tracing::error!(
                blocked_uri = violation.blocked_uri.as_str(),
                message = error.to_string().as_str(),
                "element securitypolicyviolation queueing failed"
            );
        }
    }

    pub(crate) fn queue_content_security_policy_violation_event_without_report_best_effort<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        violation: &DocumentContentSecurityPolicyViolation,
    ) {
        if let Err(error) = self.queue_content_security_policy_violation_event_for_target(
            scope, host_ptr, None, violation, false,
        ) {
            tracing::error!(
                blocked_uri = violation.blocked_uri.as_str(),
                message = error.to_string().as_str(),
                "securitypolicyviolation event-only queueing failed"
            );
        }
    }

    pub(crate) fn queue_content_security_policy_violation_event<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        violation: &DocumentContentSecurityPolicyViolation,
    ) -> anyhow::Result<()> {
        self.queue_content_security_policy_violation_event_for_target(
            scope, host_ptr, None, violation, true,
        )
    }

    fn queue_content_security_policy_violation_event_for_target<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        target: Option<DomHandle>,
        violation: &DocumentContentSecurityPolicyViolation,
        send_report: bool,
    ) -> anyhow::Result<()> {
        self.record_content_security_policy_inspector_issue(target, violation);
        let host = unsafe { &mut *host_ptr };
        let document_owner = host
            .current_main_document_task_owner()
            .ok_or_else(|| anyhow::anyhow!("main CSP violation document owner is unavailable"))?;
        if send_report {
            let fields = ContentSecurityPolicyViolationEventFields::from(violation);
            crate::network_host::send_content_security_policy_reports_for_window(
                scope,
                host,
                document_owner,
                None,
                &fields,
                &violation.report_uri_endpoints,
                &violation.report_to_endpoints,
            );
        }
        let event_task = match target {
            Some(target) => {
                crate::page_task_queue::ContentSecurityPolicyViolationEventTask::for_element(
                    document_owner,
                    target,
                    violation.clone(),
                )
            }
            None => crate::page_task_queue::ContentSecurityPolicyViolationEventTask::new(
                document_owner,
                violation.clone(),
            ),
        };
        let work = PostParseLifecycleWork::DispatchContentSecurityPolicyViolation(event_task);
        if self.has_active_parser_write_insertion_point() {
            self.enqueue_parser_boundary_lifecycle_work(work);
        } else if !self.dom_content_loaded_dispatched() {
            self.enqueue_parser_owned_pre_domcontentloaded_page_owned_work(
                PostParsePageOwnedWork::lifecycle_work(work),
            );
        } else {
            self.script_lifecycle
                .scripts_mut()
                .enqueue_post_parse_lifecycle_work(work);
        }
        Ok(())
    }

    pub(crate) fn dispatch_content_security_policy_violation_event_page_task<'s>(
        &mut self,
        scope: &mut v8::PinScope<'s, '_>,
        host_ptr: *mut JsContextHost,
        task: &crate::page_task_queue::ContentSecurityPolicyViolationEventTask,
    ) -> anyhow::Result<()> {
        if unsafe { &*host_ptr }.current_main_document_task_owner() != Some(task.owner()) {
            return Ok(());
        }
        let violation = task.violation();
        let event_target =
            EventTargetHandle::Node(task.target().unwrap_or_else(|| self.document_handle()));
        let event_target_value =
            event_target_value(scope, host_ptr, event_target).map_err(anyhow::Error::msg)?;
        let event = create_content_security_policy_violation_event(
            scope,
            event_target_value,
            event_target_value,
            violation,
        )
        .map_err(anyhow::Error::msg)?;
        self.dispatch_public_event_best_effort(
            scope,
            host_ptr,
            event_target,
            event,
            "securitypolicyviolation",
        )
        .map_err(anyhow::Error::msg)?;
        Ok(())
    }

    fn document_content_security_policies_for_optional_document(
        &self,
        document_handle: Option<DomHandle>,
        response_policies: &[ContentSecurityPolicy],
        response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    ) -> Vec<DocumentContentSecurityPolicy> {
        let mut policies = document_response_content_security_policies(
            response_policies,
            response_reporting_endpoints,
        );
        if let Some(handle) = document_handle {
            policies.extend(
                self.meta_content_security_policies_for_document(handle)
                    .into_iter()
                    .map(|policy| DocumentContentSecurityPolicy {
                        policy,
                        report_uri_enabled: false,
                        reporting_endpoints: response_reporting_endpoints.clone(),
                    }),
            );
        }
        policies
    }

    pub(crate) fn meta_content_security_policies_for_document(
        &self,
        document_handle: DomHandle,
    ) -> Vec<ContentSecurityPolicy> {
        let candidates = self
            .dom_host
            .html_elements_by_local_name_in_document_tree_order(document_handle, "meta")
            .into_iter();
        for handle in candidates {
            self.process_meta_content_security_policy_handle(document_handle, handle);
        }
        self.delivered_meta_content_security_policies
            .borrow()
            .get(&document_handle)
            .cloned()
            .unwrap_or_default()
    }

    pub(crate) fn process_parser_meta_content_security_policy(&self, handle: DomHandle) {
        self.process_meta_content_security_policy_handle(self.document_handle(), handle);
    }

    fn process_meta_content_security_policy_handle(
        &self,
        document_handle: DomHandle,
        handle: DomHandle,
    ) {
        if self.dom_host.owner_document_handle(handle) != Some(document_handle)
            || self
                .processed_meta_content_security_policy_handles
                .borrow()
                .contains(&(document_handle, handle))
        {
            return;
        }
        let policy = {
            let Some(element) = self
                .dom_host
                .node(handle)
                .and_then(|node| node.as_element())
            else {
                return;
            };
            if element.namespace() != "http://www.w3.org/1999/xhtml"
                || !element.local_name().eq_ignore_ascii_case("meta")
                || !element
                    .attribute("http-equiv")
                    .is_some_and(|value| value.eq_ignore_ascii_case("content-security-policy"))
            {
                return;
            }
            element
                .attribute("content")
                .map(str::trim_ascii)
                .filter(|content| !content.is_empty())
                .map(str::to_owned)
        };
        if !self
            .processed_meta_content_security_policy_handles
            .borrow_mut()
            .insert((document_handle, handle))
            || self.bypass_content_security_policy
        {
            return;
        }
        if let Some(policy) = policy {
            self.delivered_meta_content_security_policies
                .borrow_mut()
                .entry(document_handle)
                .or_default()
                .push(ContentSecurityPolicy::from_meta(policy));
        }
    }
}

fn document_connect_policy_violation(
    policies: &[ContentSecurityPolicy],
    reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    document_url_policy_violation(
        policies,
        reporting_endpoints,
        document_url,
        request_url,
        ContentSecurityPolicyResourceKind::DocumentConnect,
        redirect_status,
        disposition,
    )
}

fn document_frame_policy_violation(
    policies: &[ContentSecurityPolicy],
    reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    document_url_policy_violation(
        policies,
        reporting_endpoints,
        document_url,
        request_url,
        ContentSecurityPolicyResourceKind::DocumentFrame,
        redirect_status,
        disposition,
    )
}

fn document_url_policy_violation(
    policies: &[ContentSecurityPolicy],
    reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    document_url: &Url,
    request_url: &Url,
    kind: ContentSecurityPolicyResourceKind,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    content_security_policy_url_violation_with_redirect_status_disposition_and_reporting_endpoints(
        policies,
        document_url,
        request_url,
        kind,
        redirect_status,
        disposition,
        reporting_endpoints,
    )
}

fn document_script_element_url_policy_violation(
    policies: &[ContentSecurityPolicy],
    reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
    request: ContentSecurityPolicyScriptElementRequest<'_>,
) -> Option<DocumentContentSecurityPolicyViolation> {
    content_security_policy_script_element_url_violation_with_redirect_status_disposition_reporting_endpoints_and_request(
        policies,
        document_url,
        request_url,
        redirect_status,
        disposition,
        reporting_endpoints,
        request,
    )
}

fn document_style_element_url_policy_violation(
    policies: &[ContentSecurityPolicy],
    reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
    request: ContentSecurityPolicyStyleElementRequest<'_>,
) -> Option<DocumentContentSecurityPolicyViolation> {
    content_security_policy_style_element_url_violation_with_redirect_status_disposition_reporting_endpoints_and_request(
        policies,
        document_url,
        request_url,
        redirect_status,
        disposition,
        reporting_endpoints,
        request,
    )
}

#[derive(Debug, Clone)]
struct DocumentContentSecurityPolicy {
    policy: ContentSecurityPolicy,
    report_uri_enabled: bool,
    reporting_endpoints: ContentSecurityPolicyReportingEndpoints,
}

fn document_response_content_security_policies(
    response_policies: &[ContentSecurityPolicy],
    response_reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
) -> Vec<DocumentContentSecurityPolicy> {
    response_policies
        .iter()
        .map(|policy| DocumentContentSecurityPolicy {
            policy: policy.to_owned(),
            report_uri_enabled: true,
            reporting_endpoints: response_reporting_endpoints.clone(),
        })
        .collect()
}

fn document_connect_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    document_url_policy_violation_from_document_policies(
        policies,
        document_url,
        request_url,
        ContentSecurityPolicyResourceKind::DocumentConnect,
        redirect_status,
        disposition,
    )
}

fn document_frame_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    document_url_policy_violation_from_document_policies(
        policies,
        document_url,
        request_url,
        ContentSecurityPolicyResourceKind::DocumentFrame,
        redirect_status,
        disposition,
    )
}

fn document_url_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    request_url: &Url,
    kind: ContentSecurityPolicyResourceKind,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let single_policy = [policy.policy.clone()];
        let mut violation = document_url_policy_violation(
            &single_policy,
            &policy.reporting_endpoints,
            document_url,
            request_url,
            kind,
            redirect_status,
            disposition,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_script_element_url_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
    request: ContentSecurityPolicyScriptElementRequest<'_>,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let single_policy = [policy.policy.clone()];
        let mut violation = document_script_element_url_policy_violation(
            &single_policy,
            &policy.reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            disposition,
            request,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_style_element_url_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    request_url: &Url,
    redirect_status: ContentSecurityPolicyRedirectStatus,
    disposition: ContentSecurityPolicyDisposition,
    request: ContentSecurityPolicyStyleElementRequest<'_>,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let single_policy = [policy.policy.clone()];
        let mut violation = document_style_element_url_policy_violation(
            &single_policy,
            &policy.reporting_endpoints,
            document_url,
            request_url,
            redirect_status,
            disposition,
            request,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_non_url_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    kind: ContentSecurityPolicyNonUrlKind,
    source: Option<&str>,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let mut violation = content_security_policy_non_url_violation_with_source(
            &policy.policy,
            document_url,
            kind,
            source,
            disposition,
            &policy.reporting_endpoints,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_inline_source_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    kind: ContentSecurityPolicyNonUrlKind,
    source: &str,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let mut violation = content_security_policy_inline_source_violation_with_disposition_and_reporting_endpoints(
            &policy.policy,
            document_url,
            kind,
            source,
            disposition,
            &policy.reporting_endpoints,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_inline_script_element_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    source: &str,
    request: ContentSecurityPolicyScriptElementRequest<'_>,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let mut violation = content_security_policy_inline_script_element_violation_with_disposition_and_reporting_endpoints(
            &policy.policy,
            document_url,
            source,
            request,
            disposition,
            &policy.reporting_endpoints,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_inline_style_element_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    source: &str,
    request: ContentSecurityPolicyStyleElementRequest<'_>,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    policies.into_iter().find_map(|policy| {
        let mut violation = content_security_policy_inline_style_element_violation_with_disposition_and_reporting_endpoints(
            &policy.policy,
            document_url,
            source,
            request,
            disposition,
            &policy.reporting_endpoints,
        )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

#[cfg(test)]
fn document_trusted_types_sink_policy_violation_from_document_policies(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &Url,
    sink: &str,
    sample: &str,
    disposition: ContentSecurityPolicyDisposition,
) -> Option<DocumentContentSecurityPolicyViolation> {
    iter_document_trusted_types_sink_policy_violations(
        policies,
        document_url,
        sink,
        sample,
        disposition,
    )
    .next()
}

fn iter_document_trusted_types_sink_policy_violations<'a>(
    policies: Vec<DocumentContentSecurityPolicy>,
    document_url: &'a Url,
    sink: &'a str,
    sample: &'a str,
    disposition: ContentSecurityPolicyDisposition,
) -> impl Iterator<Item = DocumentContentSecurityPolicyViolation> + 'a {
    policies.into_iter().filter_map(move |policy| {
        let single_policy = [policy.policy.clone()];
        let mut violation =
            content_security_policy_trusted_types_sink_violation_with_disposition_and_reporting_endpoints(
                &single_policy,
                document_url,
                sink,
                sample,
                disposition,
                &policy.reporting_endpoints,
            )?;
        apply_document_policy_reporting_flags(&mut violation, &policy);
        Some(violation)
    })
}

fn document_policies_allow_trusted_type_policy_name(
    policies: Vec<DocumentContentSecurityPolicy>,
    policy_name: &str,
) -> bool {
    policies.into_iter().all(|policy| {
        content_security_policy_allows_trusted_type_policy_name(&[policy.policy], policy_name)
    })
}

fn document_policies_require_trusted_types_for_script(
    policies: &[DocumentContentSecurityPolicy],
) -> bool {
    policies.iter().any(|policy| {
        content_security_policy_requires_trusted_types_for_script(std::slice::from_ref(
            &policy.policy,
        ))
    })
}

fn document_policies_allow_trusted_types_eval(policies: &[DocumentContentSecurityPolicy]) -> bool {
    let policies = policies
        .iter()
        .map(|policy| policy.policy.clone())
        .collect::<Vec<_>>();
    content_security_policy_allows_trusted_types_eval(&policies)
}

fn apply_document_policy_reporting_flags(
    violation: &mut DocumentContentSecurityPolicyViolation,
    policy: &DocumentContentSecurityPolicy,
) {
    if !policy.report_uri_enabled {
        violation.report_uri_endpoints.clear();
    }
}

pub(crate) fn document_content_security_policy_error_message(
    violation: &DocumentContentSecurityPolicyViolation,
    operation: &'static str,
) -> String {
    format!(
        "{operation}: blocked by Content Security Policy for `{}`.",
        violation.blocked_uri
    )
}

pub(crate) fn create_content_security_policy_violation_event<'s>(
    scope: &mut v8::PinScope<'s, '_>,
    current_target: v8::Local<'s, v8::Value>,
    target: v8::Local<'s, v8::Value>,
    violation: &DocumentContentSecurityPolicyViolation,
) -> anyhow::Result<v8::Local<'s, v8::Object>> {
    let event = create_security_policy_violation_event(
        scope,
        &ContentSecurityPolicyViolationEventFields::from(violation),
    )
    .ok_or_else(|| anyhow::anyhow!("failed to create CSP violation event"))?;
    let _ = crate::context_bootstrap::event_backing(scope, event).set(
        scope,
        v8str(scope, "target").into(),
        target,
    );
    let _ = crate::context_bootstrap::event_backing(scope, event).set(
        scope,
        v8str(scope, "srcElement").into(),
        target,
    );
    let _ = crate::context_bootstrap::event_backing(scope, event).set(
        scope,
        v8str(scope, "currentTarget").into(),
        current_target,
    );
    Ok(event)
}

pub(crate) fn response_content_security_policies_from_headers(
    headers: &[(String, Vec<u8>)],
) -> Vec<ContentSecurityPolicy> {
    content_security_policy_headers(headers)
}

pub(crate) fn response_content_security_report_only_policies_from_headers(
    headers: &[(String, Vec<u8>)],
) -> Vec<ContentSecurityPolicy> {
    content_security_policy_report_only_headers(headers)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::parser::HtmlParser;

    fn runtime_for_html(html: &str) -> DocumentRuntime {
        let document_url = Url::parse("https://example.test/page").expect("document url");
        let document = HtmlParser::SCRIPTING_ENABLED.parse(document_url, html.to_owned());
        DocumentRuntime::from_document(document)
    }

    fn runtime_with_response_csp(policy: &str) -> DocumentRuntime {
        let mut runtime = runtime_for_html("<!doctype html>");
        runtime.set_response_content_security_policies(&[policy.to_owned()]);
        runtime
    }

    fn runtime_with_response_csp_report_only(policy: &str) -> DocumentRuntime {
        let mut runtime = runtime_for_html("<!doctype html>");
        runtime.set_response_content_security_report_only_policies(&[policy.to_owned()]);
        runtime
    }

    #[test]
    fn trusted_types_report_only_requirements_ignore_enforced_meta_policies() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy"
                  content="require-trusted-types-for 'script'">"#,
        );

        let requirements = runtime.trusted_types_for_script_requirements();
        assert!(requirements.requires_conversion());
        assert!(requirements.is_enforced());
        assert!(
            runtime
                .trusted_types_sink_csp_report_only_violation("Element innerHTML", "plain")
                .is_none()
        );
    }

    #[test]
    fn trusted_types_report_only_response_requires_conversion_without_enforcement() {
        let runtime = runtime_with_response_csp_report_only(
            "require-trusted-types-for 'script'; report-to csp",
        );

        let requirements = runtime.trusted_types_for_script_requirements();
        assert!(requirements.requires_conversion());
        assert!(!requirements.is_enforced());
        let violation = runtime
            .trusted_types_sink_csp_report_only_violation("Element innerHTML", "plain")
            .expect("report-only Trusted Types sink should produce a violation");
        assert_eq!(
            violation.disposition,
            ContentSecurityPolicyDisposition::Report
        );
    }

    #[test]
    fn response_csp_sandbox_updates_current_document_sandbox_policy_record() {
        let mut runtime = runtime_for_html("<!doctype html>");
        assert_eq!(
            runtime.document_sandbox_policy(),
            DocumentSandboxPolicy::default()
        );

        runtime.set_response_content_security_policies(&[String::from("sandbox")]);
        assert_eq!(
            runtime.document_sandbox_policy(),
            DocumentSandboxPolicy {
                forces_opaque_origin: true,
                allows_scripts: false,
                allows_modals: false,
                allows_top_navigation: false,
                allows_popups_to_escape: false,
                sandboxes_document_domain: true,
            }
        );

        runtime.set_response_content_security_policies(&[String::from(
            "sandbox allow-scripts allow-same-origin allow-modals allow-popups-to-escape-sandbox",
        )]);
        assert_eq!(
            runtime.document_sandbox_policy(),
            DocumentSandboxPolicy {
                forces_opaque_origin: false,
                allows_scripts: true,
                allows_modals: true,
                allows_top_navigation: false,
                allows_popups_to_escape: true,
                sandboxes_document_domain: true,
            }
        );

        runtime.set_response_content_security_policies(&[
            String::from("sandbox allow-scripts allow-modals allow-popups-to-escape-sandbox"),
            String::from("sandbox allow-same-origin"),
        ]);
        assert_eq!(
            runtime.document_sandbox_policy(),
            DocumentSandboxPolicy {
                forces_opaque_origin: true,
                allows_scripts: false,
                allows_modals: false,
                allows_top_navigation: false,
                allows_popups_to_escape: false,
                sandboxes_document_domain: true,
            }
        );

        runtime.set_response_content_security_policies(&[String::from("script-src 'self'")]);
        assert_eq!(
            runtime.document_sandbox_policy(),
            DocumentSandboxPolicy::default()
        );
    }

    fn reporting_endpoints() -> ContentSecurityPolicyReportingEndpoints {
        crate::content_security_policy::content_security_policy_reporting_endpoints_from_headers(
            &[(
                "Reporting-Endpoints".to_owned(),
                b"csp=\"/reports/csp\"".to_vec(),
            )],
            &Url::parse("https://example.test/page").unwrap(),
        )
    }

    #[test]
    fn csp_script_src_self_blocks_cross_origin_script_element_request() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src 'self' 'unsafe-inline'">
            "#,
        );
        let blocked_url = Url::parse("https://cdn.example.test/module.wasm").unwrap();
        let violation = runtime
            .script_element_request_csp_violation(&blocked_url)
            .expect("cross-origin request should violate script-src self");

        assert_eq!(violation.effective_directive, "script-src-elem");
        assert_eq!(
            violation.original_policy,
            "script-src 'self' 'unsafe-inline'"
        );
        assert_eq!(
            violation.disposition,
            ContentSecurityPolicyDisposition::Enforce
        );
    }

    #[test]
    fn delivered_meta_csp_policy_ignores_later_content_attribute_changes() {
        let mut runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="img-src 'none'">
            "#,
        );
        let request_url = Url::parse("https://example.test/image.png").expect("image URL");
        let initial_check =
            runtime.document_subresource_csp_check(&request_url, DocumentSubresourceCspKind::Image);
        let initial = initial_check
            .enforced_violation()
            .expect("initial meta CSP should block image");
        assert_eq!(initial.original_policy, "img-src 'none'");

        let meta = runtime
            .dom_host()
            .html_elements_by_local_name_in_document_tree_order(runtime.document_handle(), "meta")
            .into_iter()
            .next()
            .expect("meta element");
        assert!(
            runtime
                .dom_host_mut()
                .set_attribute(meta, "content", "img-src *")
        );

        let after_mutation_check =
            runtime.document_subresource_csp_check(&request_url, DocumentSubresourceCspKind::Image);
        let after_mutation = after_mutation_check
            .enforced_violation()
            .expect("delivered meta CSP should remain enforced");
        assert_eq!(after_mutation.original_policy, "img-src 'none'");
    }

    #[test]
    fn child_document_meta_csp_does_not_leak_into_main_document() {
        let mut runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src 'unsafe-eval'">
            "#,
        );
        let child_document = runtime.dom_host_mut().create_detached_html_document();
        let child_meta = runtime.dom_host_mut().create_element("meta");
        assert_eq!(
            runtime
                .dom_host_mut()
                .adopt_node(child_document, child_meta),
            Some(child_meta)
        );
        assert!(runtime.dom_host_mut().set_attribute(
            child_meta,
            "http-equiv",
            "Content-Security-Policy"
        ));
        assert!(runtime.dom_host_mut().set_attribute(
            child_meta,
            "content",
            "require-trusted-types-for 'script'"
        ));
        assert!(
            runtime
                .dom_host_mut()
                .append_child(child_document, child_meta)
        );
        let reporting_endpoints = ContentSecurityPolicyReportingEndpoints::default();

        assert!(
            runtime
                .trusted_types_for_script_requirements_for_document(
                    Some(child_document),
                    &[],
                    &[],
                    &reporting_endpoints,
                )
                .is_enforced()
        );
        assert!(
            !runtime.requires_trusted_types_for_script(),
            "a child document's meta policy must not affect the parent document"
        );
        assert!(
            runtime
                .trusted_types_for_script_requirements_for_document(
                    Some(child_document),
                    &[],
                    &[],
                    &reporting_endpoints,
                )
                .is_enforced(),
            "checking the parent must not discard the child document's delivered policy"
        );
    }

    #[test]
    fn child_image_meta_csp_uses_own_reporting_endpoints() {
        let mut runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="img-src 'none'; report-to csp">
            "#,
        );
        runtime.set_content_security_reporting_endpoints(reporting_endpoints());
        let child_document = runtime.dom_host_mut().create_detached_html_document();
        let child_meta = runtime.dom_host_mut().create_element("meta");
        assert_eq!(
            runtime
                .dom_host_mut()
                .adopt_node(child_document, child_meta),
            Some(child_meta)
        );
        assert!(runtime.dom_host_mut().set_attribute(
            child_meta,
            "http-equiv",
            "Content-Security-Policy"
        ));
        assert!(runtime.dom_host_mut().set_attribute(
            child_meta,
            "content",
            "img-src 'none'; report-to csp; report-uri /ignored-meta-report"
        ));
        assert!(
            runtime
                .dom_host_mut()
                .append_child(child_document, child_meta)
        );

        let child_url = Url::parse("https://child.example.test/page").unwrap();
        let request_url = child_url.join("image.png").unwrap();
        let child_policy = DocumentPolicyContainer::from_navigation_response_headers(
            &[(
                "Reporting-Endpoints".to_owned(),
                b"csp=\"/child-reports\"".to_vec(),
            )],
            &child_url,
        );
        for (policy, expected) in [
            (
                child_policy,
                vec!["https://child.example.test/child-reports".to_owned()],
            ),
            (DocumentPolicyContainer::default(), Vec::new()),
        ] {
            let check = runtime.document_subresource_csp_check_for_document(
                Some(child_document),
                &child_url,
                &policy,
                &request_url,
                DocumentSubresourceCspKind::Image,
            );
            let violation = check
                .enforced_violation()
                .expect("child meta CSP must block");
            assert_eq!(
                violation.report_to_endpoints, expected,
                "a child must not resolve its report group using the parent's endpoints"
            );
            assert!(violation.report_uri_endpoints.is_empty());
        }

        let parent_check =
            runtime.document_subresource_csp_check(&request_url, DocumentSubresourceCspKind::Image);
        assert_eq!(
            parent_check
                .enforced_violation()
                .expect("parent meta CSP must block")
                .report_to_endpoints,
            vec!["https://example.test/reports/csp".to_owned()],
            "checking the child must preserve the parent's own report group"
        );
    }

    #[test]
    fn document_open_does_not_reuse_replaced_document_meta_csp() {
        let mut runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy"
                  content="require-trusted-types-for 'script'">
            "#,
        );
        assert!(runtime.requires_trusted_types_for_script());

        runtime.open_document();

        assert!(
            !runtime.requires_trusted_types_for_script(),
            "the replacement document must not inherit delivered meta policies"
        );
    }

    #[test]
    fn csp_bypass_does_not_clear_policy_installed_in_current_document() {
        let mut runtime = runtime_with_response_csp("img-src 'none'");
        let request_url = Url::parse("https://example.test/image.png").expect("image URL");

        runtime.set_bypass_content_security_policy(true);

        assert!(
            runtime
                .document_subresource_csp_check(&request_url, DocumentSubresourceCspKind::Image,)
                .enforced_violation()
                .is_some(),
            "Page.setBypassCSP affects future document policy installation, not the current document's installed CSP"
        );
    }

    #[test]
    fn meta_csp_seen_while_bypass_is_enabled_is_not_installed_later() {
        let mut runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="img-src 'none'">
            "#,
        );
        let request_url = Url::parse("https://example.test/image.png").expect("image URL");

        runtime.set_bypass_content_security_policy(true);
        assert!(
            runtime
                .document_subresource_csp_check(&request_url, DocumentSubresourceCspKind::Image,)
                .enforced_violation()
                .is_none()
        );

        runtime.set_bypass_content_security_policy(false);
        assert!(
            runtime
                .document_subresource_csp_check(&request_url, DocumentSubresourceCspKind::Image,)
                .enforced_violation()
                .is_none(),
            "a meta policy ignored at delivery time must not be installed retroactively"
        );
    }

    #[test]
    fn document_subresource_csp_check_keeps_report_and_enforce_results_together() {
        let mut runtime = runtime_with_response_csp("img-src 'none'; media-src 'none'");
        runtime.set_response_content_security_report_only_policies(&[String::from(
            "img-src 'none'; media-src 'none'",
        )]);
        let request_url = Url::parse("https://example.test/resource").expect("resource URL");

        for (kind, directive) in [
            (DocumentSubresourceCspKind::Image, "img-src"),
            (DocumentSubresourceCspKind::Media, "media-src"),
        ] {
            let check = runtime.document_subresource_csp_check(&request_url, kind);
            let report_only = check
                .report_only_violation()
                .expect("report-only policy should produce a violation");
            let enforced = check
                .enforced_violation()
                .expect("enforced policy should produce a violation");

            assert_eq!(report_only.effective_directive, directive);
            assert_eq!(
                report_only.disposition,
                ContentSecurityPolicyDisposition::Report
            );
            assert_eq!(enforced.effective_directive, directive);
            assert_eq!(
                enforced.disposition,
                ContentSecurityPolicyDisposition::Enforce
            );
        }
    }

    #[test]
    fn csp_script_src_self_allows_same_origin_script_element_request() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src 'self' 'unsafe-inline'">
            "#,
        );
        let allowed_url = Url::parse("https://example.test/module.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&allowed_url)
                .is_none()
        );
    }

    #[test]
    fn csp_host_source_path_allows_directory_descendants_only() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://cdn.example.test/trusted/">
            "#,
        );
        let allowed = Url::parse("https://cdn.example.test/trusted/module.wasm").unwrap();
        let blocked = Url::parse("https://cdn.example.test/evil/module.wasm").unwrap();
        let percent_encoded_slash =
            Url::parse("https://cdn.example.test/trusted%2Fevil.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&allowed)
                .is_none()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&blocked)
                .is_some()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&percent_encoded_slash)
                .is_some()
        );
    }

    #[test]
    fn csp_host_source_path_without_trailing_slash_requires_exact_path() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://cdn.example.test/trusted/module.wasm">
            "#,
        );
        let allowed = Url::parse("https://cdn.example.test/trusted/module.wasm").unwrap();
        let blocked = Url::parse("https://cdn.example.test/trusted/module.wasm.extra").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&allowed)
                .is_none()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&blocked)
                .is_some()
        );
    }

    #[test]
    fn csp_host_source_without_path_still_allows_any_path() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://cdn.example.test">
            "#,
        );
        let allowed = Url::parse("https://cdn.example.test/any/module.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&allowed)
                .is_none()
        );
    }

    #[test]
    fn csp_wildcard_host_source_allows_subdomains_but_not_bare_host() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://*.example.test">
            "#,
        );
        let subdomain = Url::parse("https://cdn.example.test/module.wasm").unwrap();
        let nested_subdomain = Url::parse("https://a.b.example.test/module.wasm").unwrap();
        let bare_host = Url::parse("https://example.test/module.wasm").unwrap();
        let similar_suffix = Url::parse("https://badexample.test/module.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&subdomain)
                .is_none()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&nested_subdomain)
                .is_none()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&bare_host)
                .is_some()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&similar_suffix)
                .is_some()
        );
    }

    #[test]
    fn csp_exact_host_source_still_allows_bare_host() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://example.test">
            "#,
        );
        let bare_host = Url::parse("https://example.test/module.wasm").unwrap();
        let subdomain = Url::parse("https://cdn.example.test/module.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&bare_host)
                .is_none()
        );
        assert!(
            runtime
                .script_element_request_csp_violation(&subdomain)
                .is_some()
        );
    }

    #[test]
    fn csp_host_source_without_port_does_not_allow_non_default_ports() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://cdn.example.test">
            "#,
        );
        let blocked = Url::parse("https://cdn.example.test:444/module.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&blocked)
                .is_some()
        );
    }

    #[test]
    fn csp_host_source_rejects_query_without_path() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src https://cdn.example.test?ignored">
            "#,
        );
        let blocked = Url::parse("https://cdn.example.test/module.wasm").unwrap();

        assert!(
            runtime
                .script_element_request_csp_violation(&blocked)
                .is_some()
        );
    }

    #[test]
    fn csp_script_element_report_only_uses_shared_url_helper() {
        let runtime = runtime_with_response_csp_report_only("default-src 'none'");
        let request_url = Url::parse("https://example.test/app.js").unwrap();

        let violation = runtime
            .script_element_request_csp_report_only_violation(&request_url)
            .expect("report-only default-src should report external script violation");
        assert_eq!(violation.effective_directive, "script-src-elem");
        assert_eq!(violation.blocked_uri, request_url.to_string());
        assert_eq!(
            violation.disposition,
            ContentSecurityPolicyDisposition::Report
        );
    }

    #[test]
    fn csp_meta_script_report_uri_is_not_a_network_report_endpoint() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="script-src 'none'; report-uri /csp-report">
            "#,
        );
        let request_url = Url::parse("https://example.test/app.js").unwrap();

        let violation = runtime
            .script_element_request_csp_violation(&request_url)
            .expect("meta script-src should block external script");
        assert_eq!(violation.effective_directive, "script-src-elem");
        assert!(violation.report_uri_endpoints.is_empty());
    }

    #[test]
    fn csp_response_report_to_attaches_reporting_api_endpoint() {
        let mut runtime =
            runtime_with_response_csp("connect-src 'none'; report-uri /legacy; report-to csp");
        runtime.set_content_security_reporting_endpoints(reporting_endpoints());
        let request_url = Url::parse("https://api.example.test/data.json").unwrap();

        let check = runtime.document_connect_csp_check_with_redirect_status(
            &request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
        );
        let violation = check
            .enforced_violation()
            .expect("connect-src none should block request");

        assert!(violation.report_uri_endpoints.is_empty());
        assert_eq!(
            violation.report_to_endpoints,
            vec!["https://example.test/reports/csp".to_owned()]
        );
    }

    #[test]
    fn csp_response_report_to_attaches_inline_and_wasm_reporting_api_endpoint() {
        let mut runtime = runtime_with_response_csp("script-src 'none'; report-to csp");
        runtime.set_content_security_reporting_endpoints(reporting_endpoints());

        let inline = runtime
            .inline_script_csp_violation_for_document(
                Some(runtime.document_handle()),
                runtime.document_url(),
                &["script-src 'none'; report-to csp".into()],
                &reporting_endpoints(),
            )
            .expect("inline script should violate script-src none");
        let wasm = runtime
            .wasm_eval_csp_violation()
            .expect("wasm eval should violate script-src none");

        assert_eq!(
            inline.report_to_endpoints,
            vec!["https://example.test/reports/csp".to_owned()]
        );
        assert_eq!(
            wasm.report_to_endpoints,
            vec!["https://example.test/reports/csp".to_owned()]
        );
    }

    #[test]
    fn csp_wasm_eval_uses_script_src_or_default_src() {
        let default_blocked = runtime_with_response_csp("default-src 'self' 'unsafe-inline'");
        let default_violation = default_blocked
            .wasm_eval_csp_violation()
            .expect("default-src should block wasm eval when unsafe wasm sources are absent");
        assert_eq!(default_violation.blocked_uri, "wasm-eval");
        assert_eq!(
            default_violation.original_policy,
            "default-src 'self' 'unsafe-inline'"
        );

        let script_blocked =
            runtime_with_response_csp("script-src 'self' 'unsafe-inline'; default-src *");
        assert!(script_blocked.wasm_eval_csp_violation().is_some());
    }

    #[test]
    fn csp_report_only_wasm_eval_returns_report_disposition() {
        let runtime = runtime_with_response_csp_report_only("script-src 'self' 'unsafe-inline'");
        let violation = runtime
            .wasm_eval_csp_report_only_violation()
            .expect("report-only script-src without wasm unsafe eval should report");

        assert_eq!(violation.blocked_uri, "wasm-eval");
        assert_eq!(
            violation.disposition,
            ContentSecurityPolicyDisposition::Report
        );
    }

    #[test]
    fn csp_document_connect_uses_connect_src_before_default_src() {
        let runtime = runtime_with_response_csp("connect-src 'self'; default-src *");
        let same_origin = Url::parse("https://example.test/api").unwrap();
        let cross_origin = Url::parse("https://api.example.test/data").unwrap();

        let same_origin_check = runtime.document_connect_csp_check_with_redirect_status(
            &same_origin,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
        );
        assert!(same_origin_check.enforced_violation().is_none());

        let check = runtime.document_connect_csp_check_with_redirect_status(
            &cross_origin,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
        );
        let violation = check
            .enforced_violation()
            .expect("connect-src should block cross-origin document fetch");
        assert_eq!(violation.effective_directive, "connect-src");
        assert_eq!(violation.blocked_uri, cross_origin.to_string());
        assert_eq!(
            violation.disposition,
            ContentSecurityPolicyDisposition::Enforce
        );
    }

    #[test]
    fn csp_document_connect_falls_back_to_default_src() {
        let runtime = runtime_with_response_csp("default-src 'self'");
        let blocked = Url::parse("https://api.example.test/data").unwrap();

        let check = runtime.document_connect_csp_check_with_redirect_status(
            &blocked,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
        );
        let violation = check
            .enforced_violation()
            .expect("default-src should apply when connect-src is absent");
        assert_eq!(violation.effective_directive, "connect-src");
        assert_eq!(violation.original_policy, "default-src 'self'");
    }

    #[test]
    fn csp_document_connect_report_only_returns_report_disposition() {
        let runtime = runtime_with_response_csp_report_only("connect-src 'none'");
        let request_url = Url::parse("https://example.test/api").unwrap();

        let check = runtime.document_connect_csp_check_with_redirect_status(
            &request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
        );
        let violation = check
            .report_only_violation()
            .expect("report-only connect-src should produce a report violation");
        assert_eq!(violation.effective_directive, "connect-src");
        assert_eq!(violation.blocked_uri, request_url.to_string());
        assert_eq!(
            violation.disposition,
            ContentSecurityPolicyDisposition::Report
        );
    }

    #[test]
    fn csp_document_connect_check_keeps_report_only_and_enforce_together() {
        let mut runtime = runtime_with_response_csp("connect-src 'none'");
        runtime.set_response_content_security_report_only_policies(&[String::from(
            "connect-src 'none'",
        )]);
        let request_url = Url::parse("https://api.example.test/redirected").unwrap();

        let check = runtime.document_connect_csp_check_with_redirect_status(
            &request_url,
            ContentSecurityPolicyRedirectStatus::FollowedRedirect,
        );
        let report_only = check
            .report_only_violation()
            .expect("report-only connect-src should be included in the combined check");
        let enforced = check
            .enforced_violation()
            .expect("enforced connect-src should be included in the combined check");

        assert_eq!(
            report_only.disposition,
            ContentSecurityPolicyDisposition::Report
        );
        assert_eq!(
            enforced.disposition,
            ContentSecurityPolicyDisposition::Enforce
        );
    }

    #[test]
    fn csp_document_connect_enforce_includes_meta_policies() {
        let runtime = runtime_for_html(
            r#"<!doctype html>
            <meta http-equiv="Content-Security-Policy" content="connect-src 'none'">
            "#,
        );
        let request_url = Url::parse("https://example.test/api").unwrap();

        let check = runtime.document_connect_csp_check_with_redirect_status(
            &request_url,
            ContentSecurityPolicyRedirectStatus::NoRedirect,
        );
        let violation = check
            .enforced_violation()
            .expect("meta connect-src should block document connect request");
        assert_eq!(violation.original_policy, "connect-src 'none'");
    }

    #[test]
    fn csp_frame_navigation_uses_frame_src_with_child_src_fallback() {
        let blocked_url = Url::parse("https://frames.example.test/child.html").unwrap();
        let frame_src_runtime = runtime_with_response_csp("frame-src 'none'; child-src *");
        let frame_src_violation = frame_src_runtime
            .document_frame_csp_violation(&blocked_url)
            .expect("frame-src should block iframe navigation before child-src fallback");
        assert_eq!(frame_src_violation.effective_directive, "frame-src");
        assert_eq!(
            frame_src_violation.original_policy,
            "frame-src 'none'; child-src *"
        );

        let child_src_runtime = runtime_with_response_csp("child-src 'none'");
        let child_src_violation = child_src_runtime
            .document_frame_csp_violation(&blocked_url)
            .expect("child-src should block iframe navigation when frame-src is absent");
        assert_eq!(child_src_violation.effective_directive, "frame-src");
        assert_eq!(child_src_violation.original_policy, "child-src 'none'");
    }

    #[test]
    fn csp_wasm_eval_allows_wasm_unsafe_eval_and_unsafe_eval() {
        let wasm_allowed =
            runtime_with_response_csp("default-src 'self' 'unsafe-inline' 'wasm-unsafe-eval'");
        assert!(wasm_allowed.wasm_eval_csp_violation().is_none());

        let unsafe_eval_allowed =
            runtime_with_response_csp("script-src 'self' 'unsafe-inline' 'unsafe-eval'");
        assert!(unsafe_eval_allowed.wasm_eval_csp_violation().is_none());
    }

    #[test]
    fn csp_response_header_blocks_child_document_script_requests() {
        let runtime = runtime_for_html("<!doctype html>");
        let document_url = Url::parse("https://example.test/popup.html").unwrap();
        let response_policies = vec!["script-src 'self'".into()];
        let blocked = Url::parse("https://cdn.example.test/popup.js").unwrap();
        let reporting_endpoints = ContentSecurityPolicyReportingEndpoints::default();

        let violation = runtime
            .script_element_request_csp_violation_for_document(
                None,
                &document_url,
                &response_policies,
                &reporting_endpoints,
                &blocked,
            )
            .expect("child response CSP should block cross-origin script request");

        assert_eq!(violation.effective_directive, "script-src-elem");
        assert_eq!(violation.blocked_uri, blocked.to_string());
        assert_eq!(violation.document_uri, document_url.to_string());
    }

    #[test]
    fn csp_response_header_blocks_child_inline_scripts_without_unsafe_inline() {
        let runtime = runtime_for_html("<!doctype html>");
        let document_url = Url::parse("https://example.test/popup.html").unwrap();
        let blocking_policies = vec!["script-src 'self'".into()];
        let allowing_policies = vec!["script-src 'unsafe-inline'".into()];
        let reporting_endpoints = ContentSecurityPolicyReportingEndpoints::default();

        let violation = runtime
            .inline_script_csp_violation_for_document(
                None,
                &document_url,
                &blocking_policies,
                &reporting_endpoints,
            )
            .expect("child response CSP should block inline script without unsafe-inline");

        assert_eq!(violation.effective_directive, "script-src-elem");
        assert_eq!(violation.blocked_uri, "inline");
        assert!(
            runtime
                .inline_script_csp_violation_for_document(
                    None,
                    &document_url,
                    &allowing_policies,
                    &reporting_endpoints,
                )
                .is_none()
        );
    }

    #[test]
    fn csp_response_header_extraction_is_case_insensitive() {
        assert_eq!(
            response_content_security_policies_from_headers(&[
                (
                    "Content-Security-Policy".to_owned(),
                    b" default-src 'self' ".to_vec()
                ),
                (
                    "content-security-policy-report-only".to_owned(),
                    b"default-src 'none'".to_vec()
                ),
                ("X-Other".to_owned(), b"ignored".to_vec()),
            ])
            .iter()
            .map(|policy| policy.as_str())
            .collect::<Vec<_>>(),
            vec!["default-src 'self'"]
        );
        assert_eq!(
            response_content_security_report_only_policies_from_headers(&[
                (
                    "Content-Security-Policy".to_owned(),
                    b"default-src 'self'".to_vec()
                ),
                (
                    "content-security-policy-report-only".to_owned(),
                    b" default-src 'none' ".to_vec()
                ),
                ("X-Other".to_owned(), b"ignored".to_vec()),
            ])
            .iter()
            .map(|policy| policy.as_str())
            .collect::<Vec<_>>(),
            vec!["default-src 'none'"]
        );
    }

    #[test]
    fn navigation_response_headers_build_one_complete_document_policy_container() {
        let final_url = Url::parse("https://example.test/page").unwrap();
        let headers: Vec<(String, Vec<u8>)> = vec![
            (
                "Content-Security-Policy".to_owned(),
                b"sandbox allow-scripts; frame-ancestors 'self'".to_vec(),
            ),
            (
                "Content-Security-Policy-Report-Only".to_owned(),
                b"frame-ancestors https://embedder.test; report-to csp".to_vec(),
            ),
            ("Referrer-Policy".to_owned(), b"no-referrer".to_vec()),
            (
                "Reporting-Endpoints".to_owned(),
                b"csp=\"/reports/csp\"".to_vec(),
            ),
            (
                "Cross-Origin-Embedder-Policy".to_owned(),
                b"require-corp".to_vec(),
            ),
            (
                "Cross-Origin-Opener-Policy".to_owned(),
                b"same-origin".to_vec(),
            ),
        ];

        let policy =
            DocumentPolicyContainer::from_navigation_response_headers(&headers, &final_url);

        assert_eq!(
            policy.document_content_security_policies,
            policy.response_content_security_policies
        );
        assert_eq!(
            policy
                .response_content_security_policies
                .iter()
                .map(|policy| policy.as_str())
                .collect::<Vec<_>>(),
            vec!["sandbox allow-scripts; frame-ancestors 'self'"]
        );
        assert_eq!(
            policy
                .response_content_security_report_only_policies
                .iter()
                .map(|policy| policy.as_str())
                .collect::<Vec<_>>(),
            vec!["frame-ancestors https://embedder.test; report-to csp"]
        );
        assert_eq!(policy.referrer_policy.as_deref(), Some("no-referrer"));
        assert_eq!(
            policy.cross_origin_embedder_policy,
            crate::cross_origin_isolation::CrossOriginEmbedderPolicy::RequireCorp
        );
        assert!(policy.cross_origin_isolated);
        assert!(policy.sandbox.forces_opaque_origin);
        assert!(policy.sandbox.allows_scripts);
        assert_eq!(
            policy
                .content_security_reporting_endpoints
                .endpoint_for_group("csp"),
            Some("https://example.test/reports/csp")
        );
    }

    #[test]
    fn navigation_response_frame_ancestors_check_distinguishes_top_level_and_nested() {
        let protected_url = Url::parse("https://child.test/frame.html").unwrap();
        let policy = DocumentPolicyContainer {
            response_content_security_policies: vec!["frame-ancestors 'self'".into()],
            response_content_security_report_only_policies: vec![
                "frame-ancestors https://reported.test".into(),
            ],
            ..Default::default()
        };

        assert!(
            policy
                .navigation_response_frame_ancestors_check(
                    &protected_url,
                    DocumentNavigationEmbeddingContext::TopLevel,
                )
                .has_no_violations()
        );

        let ancestors = [Some(Url::parse("https://embedder.test").unwrap())];
        let (report_only, enforced) = policy
            .navigation_response_frame_ancestors_check(
                &protected_url,
                DocumentNavigationEmbeddingContext::Nested(&ancestors),
            )
            .into_violations();
        assert_eq!(
            report_only.unwrap().disposition,
            ContentSecurityPolicyDisposition::Report
        );
        assert_eq!(
            enforced.unwrap().disposition,
            ContentSecurityPolicyDisposition::Enforce
        );
    }
}