Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
use std::pin::pin;
use std::sync::Arc;
use std::time::Instant;
use tracing::debug;
use url::Url;
use super::ScriptVm;
use super::eval_exec::RuntimePendingWorkFlushOutcome;
use super::native_module::RuntimeModuleScriptGraphStart;
use super::post_parse::dynamic_script_execute_is_runnable_before_dom_content_loaded;
use super::runtime_script_continuation::RuntimeScriptOwnerAdvance;
use crate::document_runtime::{
DocumentProcessingAction, DomHandle, FollowupPageTaskDisposition, PostParseOwnerDriverStep,
RuntimeScriptWorkPauseKind,
};
use crate::document_script_scheduler::{DocumentScriptExecutionLane, PageOwnedDocumentScriptWork};
#[cfg(test)]
use crate::dom::NodeId;
use crate::dynamic_script_owner::{
DynamicModuleScriptContinuationWork, DynamicScriptOwnerId, DynamicScriptPageTaskClaim,
DynamicScriptRunnable, DynamicScriptServiceWorkerContext,
};
use crate::frame_owner_model::{
FrameDocumentTaskOwner, MainDocumentScriptLoadDelayKind, MainDocumentScriptLoadDelayLease,
MainDocumentScriptLoadDelayRelease,
};
use crate::host::{
RuntimeScriptAdmission, ScriptEventKind, ScriptHandleSource, ScriptPageTaskExecutionKind,
};
use crate::module_script_continuation::{
ModuleScriptContinuation, ModuleScriptEvaluationContinuation, ModuleScriptEvaluationUpdate,
};
use crate::native_bridge::JsContextHost;
use crate::network::ResourceRequestClient;
use crate::page_task_queue::PageTaskQueue;
use crate::page_task_queue::{
PostParseLifecycleQueueStats, PostParseLifecycleWork, PostParsePageOwnedWork,
post_parse_lifecycle_queue_stats,
};
use crate::planning::PreparedScript;
use crate::script_vm::{
ImmediateRuntimeScriptWorkSignal, ParserFinishDomContentLoadedTask,
ParserFinishDomContentLoadedWork, PostParseDriverStep, PostParseLifecycleAdvance,
PostParseLifecycleCompletionAction, PostParseLifecycleDriver, PostParseLifecycleRound,
PostParsePageOwnedTask, PostParseProcessingAction, PostParseProcessingStep,
PostParseRuntimeDriverStep, PostParseTaskExecutionToken, ReadyPostParseAction,
select_post_parse_driver_step,
};
#[cfg(test)]
use crate::script_vm::{MainDocumentLifecycleBody, NonScriptPageTaskExecutionOutcome};
use crate::types::{ScriptExecutionReport, SubresourceResourceType};
use crate::types::{ScriptKind, ScriptMode, ScriptSourceKind, SubresourceRequestInitiatorType};
fn preload_like_resource_initiator_type(resource_type: SubresourceResourceType) -> &'static str {
match resource_type {
SubresourceResourceType::Script => "link",
SubresourceResourceType::Image => "img",
SubresourceResourceType::Audio => "audio",
SubresourceResourceType::Media => "video",
SubresourceResourceType::Video => "video",
SubresourceResourceType::TextTrack => "track",
SubresourceResourceType::Fetch
| SubresourceResourceType::EventSource
| SubresourceResourceType::Font
| SubresourceResourceType::Ping
| SubresourceResourceType::CspReport
| SubresourceResourceType::Dictionary
| SubresourceResourceType::Manifest
| SubresourceResourceType::Xhr
| SubresourceResourceType::WebSocket
| SubresourceResourceType::Stylesheet => "link",
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct RuntimeScriptFailureTerminalBodySettlement {
activity: crate::script_vm::ScriptTerminalBodyActivity,
load_gate_release: MainDocumentScriptLoadDelayRelease,
}
/// Bounded result of settling the runtime-module failures produced by one
/// already-selected graph terminal.
///
/// It deliberately separates event-dispatch activity from the load-gate
/// transition. The ResourceCompletion task needs the former to choose its
/// checkpoint follow-up and the latter to prime lifecycle only after that
/// checkpoint; neither fact is scheduler metadata.
#[must_use = "module failure settlement determines resource-task completion"]
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct RuntimeOwnedModuleFailureBodySettlement {
activity: crate::script_vm::ScriptTerminalBodyActivity,
lifecycle_unblocked_owner: Option<FrameDocumentTaskOwner>,
}
impl RuntimeOwnedModuleFailureBodySettlement {
pub(crate) const fn none() -> Self {
Self {
activity: crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch,
lifecycle_unblocked_owner: None,
}
}
pub(crate) const fn activity(self) -> crate::script_vm::ScriptTerminalBodyActivity {
self.activity
}
pub(crate) const fn lifecycle_unblocked_owner(self) -> Option<FrameDocumentTaskOwner> {
self.lifecycle_unblocked_owner
}
}
impl ScriptVm {
pub(crate) fn admit_main_document_runtime_script_task(
&mut self,
loader: &ResourceRequestClient,
task_runner: crate::network::RendererResourceTaskRunner,
admission: RuntimeScriptAdmission,
) {
// Check CSP before starting the source fetch. A CORS or network failure
// must not bypass CSP reporting by skipping the execution boundary.
let (payload, binding) = admission.into_parts();
let payload = match payload {
crate::host::RuntimeScriptAdmissionPayload::Script(script)
if script.source_kind == crate::types::ScriptSourceKind::External =>
{
let request = self.content_security_policy_script_element_request(&script);
if let Some(violation) = self
.document_runtime
.script_element_request_csp_violation_with_request(&script.url, request)
{
if let Some(report_only) = self
.document_runtime
.script_element_request_csp_report_only_violation_with_request(
&script.url,
request,
)
{
self.queue_content_security_policy_violation_event_best_effort(
&report_only,
);
}
self.queue_content_security_policy_violation_event_best_effort(&violation);
let message = format!(
"Refused to load script `{}` because it violates the document Content Security Policy directive `{}`",
script.url, violation.effective_directive,
);
let failure_kind = if script.kind == crate::types::ScriptKind::Module {
crate::host::QueuedScriptFailureKind::ModuleTopLevelLoad
} else {
crate::host::QueuedScriptFailureKind::Immediate
};
crate::host::RuntimeScriptAdmissionPayload::Failed(
crate::host::FailedDynamicScript {
script,
message,
failure_kind,
},
)
} else {
crate::host::RuntimeScriptAdmissionPayload::Script(script)
}
}
payload => payload,
};
let admission = RuntimeScriptAdmission::from_boxed_payload(Box::new(payload), binding);
let document_character_set = self.document_runtime.document_character_set().to_owned();
let service_worker_context = {
let host = self._context_host.borrow();
DynamicScriptServiceWorkerContext {
browser_context_runtime: host.browser_context_runtime(),
client_id: host.service_worker_client_id_for_window_fetch(None),
document_url: self.document_runtime.document_url().clone(),
}
};
let request_origin = self
.current_main_document_resource_loader()
.expect("dynamic script requires its Document authority")
.fetch_context()
.request_origin();
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.enqueue_admission(
loader,
request_origin,
task_runner,
admission,
Some(&document_character_set),
Some(&service_worker_context),
);
self.handle_runtime_script_work_at_explicit_boundary(true);
}
pub(super) fn handle_runtime_script_work_at_explicit_boundary(
&mut self,
enqueue_continuation_now: bool,
) {
self.pause_runtime_script_work_for_stable_continuation();
if enqueue_continuation_now && self.runtime_script_work_should_signal_immediate_progress() {
self.enqueue_runtime_script_work_continuation_if_ready();
}
}
pub(super) fn resume_runtime_script_work_after_deferred_page_tasks(&mut self) {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.disable_continuation_enqueue();
self.document_runtime
.runtime_script_work_mut()
.resume_after_deferred_page_tasks();
}
pub(super) fn runtime_script_work_has_immediately_runnable_work(&mut self) -> bool {
self.document_runtime.accept_ready_runtime_script_events();
self.document_runtime
.runtime_script_work_mut()
.has_immediately_runnable_work()
}
pub(crate) fn prepared_script_uses_runtime_owned_page_task_execution(
&self,
script: &PreparedScript,
) -> bool {
if script.kind == ScriptKind::ImportMap && script.source_kind == ScriptSourceKind::Inline {
return false;
}
script.host_script_handle.as_deref().and_then(|handle| {
self.document_runtime
.script_handle_page_task_execution_kind(handle)
}) == Some(ScriptPageTaskExecutionKind::RuntimeOwned)
}
pub(super) fn plan_script_load_lifecycle_work_for_prepared_script(
&mut self,
script: &PreparedScript,
) -> Option<PostParseLifecycleWork> {
if !self
.document_runtime
.script_event_requires_dispatch_for_script(ScriptEventKind::Load, script)
{
return None;
}
let handle =
self.required_host_script_handle_for_observable_script_followup(script, "script load")?;
self.document_runtime
.plan_script_event_task_for_script(ScriptEventKind::Load, script, handle)
.map(PostParseLifecycleWork::DispatchScriptEvent)
}
fn claim_runtime_script_page_owned_execution(
&mut self,
id: DynamicScriptOwnerId,
script: PreparedScript,
source_network_result: Option<crate::types::SharedNavigationResponseResult>,
) -> PostParsePageOwnedWork {
let runtime_script_claim = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.claim_page_owned_execution(id)
.expect(
"an admitted runtime script must transfer its exact load-delay lease to the page-owned execution task",
);
PostParsePageOwnedWork::document_script_work(PageOwnedDocumentScriptWork::Script {
lane: DocumentScriptExecutionLane::AsyncPhase,
script: Box::new(script),
runtime_script_claim: Some(runtime_script_claim),
source_network_result,
load_delay_binding: None,
})
}
pub(super) fn emit_ready_runtime_page_owned_work(
&mut self,
mut enqueue_work: impl FnMut(PostParsePageOwnedWork),
) -> Option<RuntimeScriptOwnerAdvance> {
self.refresh_script_vm_local_document_state();
let mut advance = None;
let dom_content_loaded_dispatched = self.document_runtime.dom_content_loaded_dispatched();
let runnable = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.next_runnable_script_matching(|script| {
dom_content_loaded_dispatched
|| dynamic_script_execute_is_runnable_before_dom_content_loaded(
&self.document_runtime,
script,
)
});
match runnable {
Some(DynamicScriptRunnable::Execute {
id,
script,
source_network_result,
}) if self.prepared_script_uses_runtime_owned_page_task_execution(&script)
&& script.kind == crate::types::ScriptKind::Module =>
{
match self.start_runtime_module_script_graph_for_owner(&script, id) {
RuntimeModuleScriptGraphStart::Started(actions) => {
if let Some(network_result) = source_network_result.as_deref() {
self.record_script_subresource_network_result(
script.initiator_url.clone(),
script.url.clone(),
network_result,
);
}
self.commit_runtime_module_graph_start_actions(actions);
advance = Some(RuntimeScriptOwnerAdvance::StartedModuleGraph);
}
RuntimeModuleScriptGraphStart::NotModuleScript => {
// `data:` module scripts deliberately use the ordinary
// prepared-script executor. They still become a
// concrete DocumentScript task; the runtime
// continuation must not execute them as a fallback.
let work = self.claim_runtime_script_page_owned_execution(
id,
script,
source_network_result,
);
enqueue_work(work);
advance = Some(RuntimeScriptOwnerAdvance::PublishedDocumentScript);
}
}
}
Some(DynamicScriptRunnable::Execute {
id,
script,
source_network_result,
}) if self.prepared_script_uses_runtime_owned_page_task_execution(&script) => {
let work = self.claim_runtime_script_page_owned_execution(
id,
script,
source_network_result,
);
enqueue_work(work);
advance = Some(RuntimeScriptOwnerAdvance::PublishedDocumentScript);
}
Some(DynamicScriptRunnable::Execute {
id,
script,
source_network_result,
}) => {
let _ = (id, source_network_result);
panic!(
"production DynamicScriptOwner admissions must carry runtime-owned Page execution identity: {}",
script.url
);
}
Some(DynamicScriptRunnable::ContinueModuleScriptGraph { id, continuation }) => {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.requeue_module_script_graph_ready_front(id, continuation);
advance = Some(RuntimeScriptOwnerAdvance::PublishedModuleContinuation);
}
Some(DynamicScriptRunnable::ContinueModuleScriptEvaluation { id, evaluation }) => {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.requeue_module_script_evaluation_ready_front(id, evaluation);
advance = Some(RuntimeScriptOwnerAdvance::PublishedModuleContinuation);
}
Some(DynamicScriptRunnable::DispatchError {
id,
script,
message,
module_failure_policy,
source_network_result,
error_constructor,
..
}) if self.prepared_script_uses_runtime_owned_page_task_execution(&script) => {
self.record_runtime_warning(format_args!(
"dynamic script load failed for `{}`: {message}",
script.url
));
let runtime_script_claim = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.claim_page_owned_execution(id)
.expect(
"an admitted runtime source failure must transfer its exact load-delay lease to the page-owned terminal task",
);
enqueue_work(PostParsePageOwnedWork::document_script_work(
PageOwnedDocumentScriptWork::AsyncSourceFailure {
lane: crate::document_script_scheduler::DocumentScriptSourceFailureLane::AsyncPhase,
script: Box::new(script),
failure: crate::document_script_scheduler::PageOwnedDocumentScriptSourceFailure::runtime_terminal(
message,
module_failure_policy,
error_constructor,
),
source_network_result,
runtime_script_claim: Some(runtime_script_claim),
load_delay_binding: None,
},
));
advance = Some(RuntimeScriptOwnerAdvance::PublishedSourceFailure);
}
Some(DynamicScriptRunnable::DispatchError {
id,
script,
message,
kind,
module_failure_policy,
source_network_result,
error_constructor,
}) => {
let _ = (
id,
message,
kind,
module_failure_policy,
source_network_result,
error_constructor,
);
panic!(
"production DynamicScriptOwner failures must carry runtime-owned Page execution identity: {}",
script.url
);
}
None => {}
};
advance
}
pub(crate) fn note_runtime_owned_module_script_graph_fetch_suspended(
&mut self,
id: DynamicScriptOwnerId,
load_ids: Vec<u64>,
joined_clients: Vec<moli_module_script_tree::SingleModuleClientToken>,
continuation: Box<ModuleScriptContinuation>,
) {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.note_module_script_graph_fetch_suspended(id, load_ids, joined_clients, continuation);
}
pub(crate) fn take_runtime_owned_module_script_graph_pending_fetch(
&mut self,
load_id: u64,
) -> Option<ModuleScriptContinuation> {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.take_module_script_graph_pending_fetch(load_id)
}
pub(crate) fn take_runtime_owned_module_script_graph_pending_joined_client(
&mut self,
client: moli_module_script_tree::SingleModuleClientToken,
) -> Option<ModuleScriptContinuation> {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.take_module_script_graph_pending_joined_client(client)
}
pub(crate) fn restore_runtime_owned_module_script_graph_pending_continuation(
&mut self,
id: DynamicScriptOwnerId,
continuation: Box<ModuleScriptContinuation>,
) -> bool {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.restore_module_script_graph_pending_continuation(id, continuation)
}
#[cfg(test)]
pub(crate) fn has_pending_runtime_owned_module_script_graph(&mut self) -> bool {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.has_pending_module_script_graph()
}
pub(crate) fn note_runtime_owned_module_script_graph_ready(
&mut self,
id: DynamicScriptOwnerId,
continuation: Box<ModuleScriptContinuation>,
) -> bool {
let ready = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.note_module_script_graph_ready(id, continuation);
if ready {
let _ = self.enqueue_runtime_owned_module_continuation();
}
ready
}
pub(crate) fn note_runtime_owned_module_script_evaluation_suspended(
&mut self,
id: DynamicScriptOwnerId,
evaluation: Box<ModuleScriptEvaluationContinuation>,
) {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.note_module_script_evaluation_suspended(id, evaluation);
}
pub(crate) fn enqueue_runtime_owned_module_continuation(&mut self) -> bool {
let Some(document_owner) = self.current_main_document_task_owner() else {
self.record_runtime_warning(format_args!(
"runtime module continuation became ready without a current main Document owner"
));
return false;
};
if self.queued_main_document_module_continuation_owner == Some(document_owner) {
return true;
}
let queued = self
.page_runtime_wake_tx
.bind_main_document_runtime_continuation(document_owner)
.send_runtime_module_continuation()
.is_ok();
if queued {
self.queued_main_document_module_continuation_owner = Some(document_owner);
} else {
self.record_runtime_warning(format_args!(
"main-Document runtime route closed before module continuation admission"
));
}
queued
}
pub(crate) fn begin_runtime_owned_module_continuation_turn(
&mut self,
document_owner: crate::frame_owner_model::FrameDocumentTaskOwner,
) {
if self.queued_main_document_module_continuation_owner == Some(document_owner) {
self.queued_main_document_module_continuation_owner = None;
}
}
pub(crate) fn mark_runtime_owned_module_script_evaluation_fulfilled(
&mut self,
reaction_id: u64,
) -> Option<ModuleScriptEvaluationUpdate> {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.mark_module_script_evaluation_fulfilled(reaction_id)
}
pub(crate) fn mark_runtime_owned_module_script_evaluation_rejected(
&mut self,
reaction_id: u64,
reason: String,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
) -> Option<ModuleScriptEvaluationUpdate> {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.mark_module_script_evaluation_rejected(reaction_id, reason, error_constructor)
}
#[cfg(test)]
pub(crate) fn has_pending_runtime_owned_module_script_evaluation(&mut self) -> bool {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.has_pending_module_script_evaluation()
}
pub(crate) fn take_ready_runtime_owned_module_script_continuation_work(
&mut self,
) -> Option<DynamicModuleScriptContinuationWork> {
self.refresh_script_vm_local_document_state();
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.take_ready_module_script_continuation()
}
pub(super) fn send_ready_runtime_tasks(&mut self) -> Option<RuntimeScriptOwnerAdvance> {
let mut work_items = Vec::new();
let materialized = self.emit_ready_runtime_page_owned_work(|work| {
work_items.push(work);
});
for work in work_items {
self.enqueue_main_document_runtime_work(work);
}
if self.has_ready_runtime_owned_module_owner_actions() {
let _ = self.enqueue_runtime_owned_module_continuation();
}
materialized
}
fn has_main_document_runtime_route(&self) -> bool {
self.page_runtime_wake_tx.has_main_document_runtime_route()
}
/// Publish concrete runtime follow-ups produced by one selected
/// post-parse action.
///
/// This is an action-settlement boundary, not a generic readiness scan:
/// lifecycle polling and protocol waits must never call it to discover
/// hidden work. Runtime/module producers outside this boundary publish
/// their own typed continuation directly.
fn publish_post_parse_action_runtime_followups(&mut self) {
debug_assert!(
self.has_main_document_runtime_route(),
"post-parse action settlement requires the stable Page route"
);
if self.has_ready_runtime_owned_module_owner_actions() {
let _ = self.enqueue_runtime_owned_module_continuation();
}
self.enqueue_runtime_script_signal_if_needed();
}
async fn flush_pending_runtime_script_work_until_document_owner_stable(
&mut self,
loader: &ResourceRequestClient,
initial_wait_for_dynamic_loads: bool,
yield_after_one_runnable: bool,
pause_kind_on_yield: Option<RuntimeScriptWorkPauseKind>,
) -> std::result::Result<RuntimePendingWorkFlushOutcome, String> {
let mut wait_for_dynamic_loads = initial_wait_for_dynamic_loads;
loop {
let document_owner_before = self.current_main_document_task_owner();
let outcome = self
.flush_pending_work_with_turn_budget(
loader,
wait_for_dynamic_loads,
yield_after_one_runnable,
)
.await?;
if self.current_main_document_task_owner() != document_owner_before {
// A script replaced the Document while this bounded flush was
// running. Reconcile the new exact runtime owner before
// publishing an outcome for the post-parse caller.
wait_for_dynamic_loads = true;
continue;
}
if let Some(pause_kind) = pause_kind_on_yield
&& yield_after_one_runnable
&& self.has_pending_runtime_script_work()
&& !self
.document_runtime
.runtime_script_work_mut()
.is_paused_for_deferred_page_tasks()
{
match pause_kind {
RuntimeScriptWorkPauseKind::StablePageTurnContinuation => {
self.pause_runtime_script_work_for_stable_continuation();
}
}
}
return Ok(outcome);
}
}
fn prepare_post_parse_round_page_owned_work(
&mut self,
work: Vec<PostParsePageOwnedWork>,
) -> Vec<PostParsePageOwnedWork> {
if self.document_runtime.take_post_parse_schedule_rebuild() {
return self.prepare_rebuilt_post_parse_round_page_owned_work();
}
let mut work = self.prepare_main_document_lifecycle_page_owned_work(work);
self.bind_post_parse_page_owned_script_handles(&mut work);
work
}
fn rebuild_post_parse_round_page_owned_work(&mut self) -> Option<Vec<PostParsePageOwnedWork>> {
self.document_runtime
.take_post_parse_schedule_rebuild()
.then(|| self.prepare_rebuilt_post_parse_round_page_owned_work())
}
fn prepare_rebuilt_post_parse_round_page_owned_work(&mut self) -> Vec<PostParsePageOwnedWork> {
// document.open() already replaced the old Document's owner source.
// Do not clear it again here: the replacement live parser can publish
// new-owner work before this invalidation is observed.
self.refresh_script_vm_local_document_state();
let mut work = self.prepare_main_document_lifecycle_page_owned_work(Vec::new());
self.bind_post_parse_page_owned_script_handles(&mut work);
work
}
fn prepare_main_document_lifecycle_page_owned_work(
&mut self,
mut work: Vec<PostParsePageOwnedWork>,
) -> Vec<PostParsePageOwnedWork> {
let Some(owner) = self.current_main_document_task_owner() else {
self.record_runtime_warning(format_args!(
"main post-parse lifecycle has no current document owner"
));
return work;
};
// The live document.open()/Page.setDocumentContent parser accepts
// defer-like scripts as it encounters them, but unlike phase one it
// has no separate parser-to-phase-two handoff. Finalize that same
// parser-owned queue here, at the common EOF-to-lifecycle boundary.
// The legacy pending-document path already seals and arms its queue
// while projecting handoffs, so do not create a second marker for it.
if self.document_runtime.main_parser_deferred_scripts_owner() != Some(owner) {
if let Err(error) = self.start_pending_main_parser_deferred_scripts() {
self.record_runtime_warning(format_args!(
"failed to start replacement parser-deferred scripts: {error}"
));
}
if let Some(marker) = self.seal_main_parser_deferred_scripts(owner) {
work.push(marker);
}
}
let interactive = self.finish_current_main_document_parsing(owner);
let mut work = self
.document_runtime
.prepare_post_parse_lifecycle_page_owned_work(owner, work);
if let Some(interactive) = interactive {
tracing::debug!(
?owner,
"queued document-owned main interactive transition before deferred scripts"
);
work.insert(
0,
PostParsePageOwnedWork::main_document_interactive(interactive),
);
}
work
}
pub(super) fn rebuild_post_parse_round_page_owned_work_if_invalidated(
&mut self,
) -> Option<Vec<PostParsePageOwnedWork>> {
self.rebuild_post_parse_round_page_owned_work()
}
pub(super) async fn restart_post_parse_lifecycle_round_if_invalidated(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
) -> bool {
let Some(work) = self.rebuild_post_parse_round_page_owned_work_if_invalidated() else {
return false;
};
page_task_queue.clear_document_owned_tasks();
let _ = self.begin_post_parse_lifecycle_round(page_task_queue, report, work);
true
}
pub(crate) async fn start_post_parse_lifecycle_round(
&mut self,
stage: crate::renderer::PageVmInitStage,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
work: Vec<PostParsePageOwnedWork>,
) -> PostParseLifecycleDriver {
let work = self.prepare_post_parse_round_page_owned_work(work);
let round = self.begin_post_parse_lifecycle_round(page_task_queue, report, work);
PostParseLifecycleDriver::new(stage, round)
}
pub(crate) fn resume_post_parse_lifecycle_driver_for_existing_queue(
&self,
stage: crate::renderer::PageVmInitStage,
) -> PostParseLifecycleDriver {
let round = PostParseLifecycleRound {
queue_stats: PostParseLifecycleQueueStats::default(),
phase_started: Instant::now(),
};
PostParseLifecycleDriver::new(stage, round)
}
pub(super) async fn prepare_post_parse_task_execution(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
token: PostParseTaskExecutionToken,
) -> bool {
self.restart_post_parse_lifecycle_round_if_task_allows_invalidation(
page_task_queue,
report,
token,
)
.await
}
async fn restart_post_parse_lifecycle_round_if_task_allows_invalidation(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
token: PostParseTaskExecutionToken,
) -> bool {
token.allows_invalidation_restart()
&& self
.restart_post_parse_lifecycle_round_if_invalidated(page_task_queue, report)
.await
}
async fn complete_post_parse_page_owned_task(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
task: PostParsePageOwnedTask,
) -> Option<PostParseLifecycleCompletionAction> {
let token = task.completion.token;
if self
.restart_post_parse_lifecycle_round_if_task_allows_invalidation(
page_task_queue,
report,
token,
)
.await
{
// A same-document DCL handler can invalidate the post-parse round by
// scheduling post-DCL work. Restart the round so stale tasks are not
// reused, but do not make a DCL-boundary wait consume the new
// post-DCL backlog.
if matches!(
token.boundary_completion,
Some(PostParseLifecycleCompletionAction::ReturnAtStage(
"DOMContentLoaded"
))
) && self.document_runtime.dom_content_loaded_dispatched()
{
return token.boundary_completion;
}
return None;
}
if token.requires_runtime_followup_publication {
self.finish_executed_post_parse_action(page_task_queue, true);
}
token.boundary_completion
}
pub(super) async fn finish_completed_post_parse_page_owned_task_or_continue(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
completed_task: Option<PostParsePageOwnedTask>,
) -> std::result::Result<Option<PostParseLifecycleAdvance>, String> {
let Some(task) = completed_task else {
return Ok(None);
};
let completion_action = self
.complete_post_parse_page_owned_task(page_task_queue, report, task)
.await;
Ok(completion_action.map(PostParseLifecycleAdvance::Complete))
}
fn take_exact_domcontentloaded_after_main_parser_finish(
&mut self,
page_task_queue: &mut PageTaskQueue,
owner: FrameDocumentTaskOwner,
) -> Option<PostParsePageOwnedWork> {
if self.current_main_document_task_owner() != Some(owner) {
tracing::debug!(
?owner,
current_owner = ?self.current_main_document_task_owner(),
"discarded stale parser-finish permit before DOMContentLoaded claim"
);
return None;
}
if self
._context_host
.borrow()
.current_main_document_domcontentloaded_transition_is_ready(owner)
!= Some(true)
{
tracing::debug!(
?owner,
"parser-finish permit found no ready DOMContentLoaded transition"
);
return None;
}
let exact_dcl_is_front = page_task_queue.post_parse_front().is_some_and(|work| {
work.is_domcontentloaded_task() && work.main_document_lifecycle_owner() == Some(owner)
});
if !exact_dcl_is_front {
tracing::debug!(
?owner,
"parser-finish permit found no exact DOMContentLoaded queue successor"
);
return None;
}
Some(
page_task_queue
.post_parse_pop_front()
.expect("an observed exact DOMContentLoaded successor must remain queued"),
)
}
/// Claim the exact parse-time DOMContentLoaded successor of a drained
/// main-parser queue. Queue inspection and removal remain inside the
/// lifecycle authority; the caller receives only already-claimed work.
pub(crate) fn claim_parse_time_domcontentloaded_after_main_parser_finish(
&mut self,
page_task_queue: &mut PageTaskQueue,
owner: FrameDocumentTaskOwner,
) -> Option<ParserFinishDomContentLoadedWork> {
if self.has_pending_location_navigation() {
return None;
}
let work =
self.take_exact_domcontentloaded_after_main_parser_finish(page_task_queue, owner)?;
let PostParsePageOwnedWork::Lifecycle(work) = work else {
unreachable!("an exact DOMContentLoaded successor must be lifecycle work");
};
Some(ParserFinishDomContentLoadedWork::new(owner, *work))
}
/// Consume the completed parser task and claim only its exact, already
/// queued DOMContentLoaded successor.
///
/// This is intentionally not a lifecycle poll. It neither scans for work
/// nor considers runtime candidates: the caller already holds a one-shot
/// parser-finish permit, and this method accepts exactly one same-Document
/// DCL action from the existing authoritative queue.
pub(crate) async fn claim_domcontentloaded_after_main_parser_finish(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
driver: PostParseLifecycleDriver,
completed_parser_task: PostParsePageOwnedTask,
owner: FrameDocumentTaskOwner,
) -> std::result::Result<Option<ParserFinishDomContentLoadedTask>, String> {
let boundary_completion = self
.complete_post_parse_page_owned_task(page_task_queue, report, completed_parser_task)
.await;
if boundary_completion.is_some() {
return Err(
"a parser-deferred task unexpectedly completed the lifecycle boundary".to_owned(),
);
}
let Some(work) =
self.take_exact_domcontentloaded_after_main_parser_finish(page_task_queue, owner)
else {
return Ok(None);
};
let execution =
driver.task_execution_for_action(PostParseProcessingAction::from_page_owned_work(work));
if self
.prepare_post_parse_task_execution(page_task_queue, report, execution.token)
.await
{
tracing::debug!(
?owner,
"parser-finish DOMContentLoaded claim invalidated the lifecycle round"
);
return Ok(None);
}
Ok(Some(ParserFinishDomContentLoadedTask::new(
owner,
execution.into_page_owned_task(),
)))
}
pub(super) fn begin_post_parse_lifecycle_round(
&mut self,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
work: Vec<PostParsePageOwnedWork>,
) -> PostParseLifecycleRound {
let queue_stats = post_parse_lifecycle_queue_stats(&work);
self.queue_initial_connected_style_loads_for_current_owner();
self.document_runtime.drain_document_processing_wakes();
self.document_runtime
.enqueue_post_parse_lifecycle_page_owned_work(page_task_queue, work, report);
PostParseLifecycleRound {
queue_stats,
phase_started: Instant::now(),
}
}
pub(super) fn bind_post_parse_page_owned_script_handles(
&mut self,
work: &mut [PostParsePageOwnedWork],
) {
for item in work {
if let Some(script) = item.as_script_mut() {
self.bind_prepared_script_handle_if_needed(script, ScriptHandleSource::ParserOwned);
}
}
}
pub(crate) fn has_post_domcontentloaded_runtime_work_for_wait(&mut self) -> bool {
self.refresh_script_vm_local_document_state();
self.document_runtime.dom_content_loaded_dispatched()
&& self.has_pending_runtime_script_work()
}
pub(crate) fn check_main_document_completion(
&self,
owner: crate::frame_owner_model::FrameDocumentTaskOwner,
) -> Option<bool> {
self._context_host
.borrow()
.current_main_document_complete_transition_is_ready(owner)
}
#[cfg(test)]
pub(crate) fn execute_post_parse_lifecycle_work_best_effort(
&mut self,
work: PostParseLifecycleWork,
) -> std::result::Result<NonScriptPageTaskExecutionOutcome, String> {
if let Some(body) = MainDocumentLifecycleBody::from_post_parse_work(&work) {
return self
.execute_main_document_lifecycle_body(body)
.into_legacy_post_parse_outcome();
}
let result = self.execute_post_parse_lifecycle_work_best_effort_inner(work);
self.finish_runtime_turn_with_style_drain(
crate::style_engine::StyleInvalidationTurnExitBoundary::NonScriptPageTask,
result,
)
}
#[cfg(test)]
fn execute_post_parse_lifecycle_work_best_effort_inner(
&mut self,
work: PostParseLifecycleWork,
) -> std::result::Result<NonScriptPageTaskExecutionOutcome, String> {
match work {
PostParseLifecycleWork::SeedDocumentOwnedBlockingStylesheets(inputs) => {
let Some(owner) = self.current_main_document_task_owner() else {
tracing::warn!(
input_count = inputs.len(),
"dropping stylesheet seed without current main document owner"
);
return Ok(NonScriptPageTaskExecutionOutcome::None);
};
self.accept_main_document_blocking_stylesheet_inputs(owner, &inputs);
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::AdvanceMainParserDeferredScripts { .. } => {
unreachable!(
"main parser-deferred adapter work must use async page-owned execution"
)
}
PostParseLifecycleWork::RecordDocumentScriptRun { .. } => {
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::DispatchContentSecurityPolicyViolation(task) => {
self.dispatch_content_security_policy_violation_event_page_task_best_effort(&task);
self.drain_deferred_page_tasks_best_effort();
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::DispatchScriptEvent(task) => {
self.dispatch_script_event_and_checkpoint_for_test(&task);
self.drain_deferred_page_tasks_best_effort();
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::ReportWindowScriptFailure(task) => {
self.report_window_script_failure_task_and_checkpoint_for_test(&task);
self.drain_deferred_page_tasks_best_effort();
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::SettleMainDocumentScriptLoadDelay(binding) => {
let owner = binding.owner();
let kind = binding.kind();
let load_delay_token = binding.load_delay_token();
let settled = self
._context_host
.borrow_mut()
.release_main_document_script_load_delay(binding);
debug!(
?owner,
?kind,
?load_delay_token,
settled = ?settled,
"settled main async script lifecycle binding after observable follow-up"
);
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::ApplyMainDocumentInteractive(_)
| PostParseLifecycleWork::DispatchDomContentLoaded { .. }
| PostParseLifecycleWork::DispatchWindowLoad { .. } => unreachable!(
"main-document lifecycle work must retain its typed body execution fact"
),
PostParseLifecycleWork::CheckMainDocumentCompletion { owner } => {
unreachable!(
"main document completion rechecks must not enter the V8 lifecycle executor: {owner:?}"
)
}
PostParseLifecycleWork::RecordDetachedPostParseRuns(_) => {
Ok(NonScriptPageTaskExecutionOutcome::None)
}
PostParseLifecycleWork::DispatchConnectedStyleLoad(_) => {
unreachable!(
"connected style load lifecycle work must use async page-owned execution path"
)
}
}
}
pub(crate) fn finish_runtime_owned_script_success(
&mut self,
dynamic_script_owner_id: DynamicScriptOwnerId,
script: &PreparedScript,
) {
let lease = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.finish_script_terminal(dynamic_script_owner_id);
let Some(lease) = self.exact_runtime_script_terminal_lease_or_warn(
dynamic_script_owner_id,
script,
lease,
) else {
return;
};
self.apply_runtime_script_success_terminal(script, lease);
debug!(
?dynamic_script_owner_id,
url = %script.url,
"completed runtime-owned script terminal inside its selected action"
);
}
/// Apply the synchronous terminal portion of a selected DocumentScript
/// body without claiming that the surrounding HTML task has ended.
///
/// The caller owns the task-end checkpoint and lifecycle prime. This keeps
/// `script -> script reactions -> terminal callback -> terminal reactions`
/// observable while preventing the terminal helper from becoming a second
/// completion authority.
pub(crate) fn finish_claimed_runtime_owned_script_success_body(
&mut self,
claim: DynamicScriptPageTaskClaim,
script: &PreparedScript,
) -> crate::script_vm::ScriptTerminalBodyActivity {
let (dynamic_script_owner_id, lease) = claim.into_parts();
let activity = self.apply_runtime_script_success_terminal_body(script, lease);
debug!(
?dynamic_script_owner_id,
url = %script.url,
?activity,
"completed claimed runtime-owned script success body"
);
activity
}
pub(crate) fn finish_runtime_owned_script_success_body(
&mut self,
dynamic_script_owner_id: DynamicScriptOwnerId,
script: &PreparedScript,
) -> crate::script_vm::ScriptTerminalBodyActivity {
let lease = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.finish_script_terminal(dynamic_script_owner_id);
let Some(lease) = self.exact_runtime_script_terminal_lease_or_warn(
dynamic_script_owner_id,
script,
lease,
) else {
return crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch;
};
self.apply_runtime_script_success_terminal_body(script, lease)
}
pub(crate) fn restore_runtime_owned_script_page_task_claim(
&mut self,
claim: DynamicScriptPageTaskClaim,
) {
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.restore_page_owned_execution_claim(claim);
}
pub(crate) fn finish_claimed_runtime_owned_script_failure_body(
&mut self,
claim: DynamicScriptPageTaskClaim,
script: &PreparedScript,
message: &str,
module_failure_policy: Option<crate::host::ModuleFailurePolicy>,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
) -> crate::script_vm::ScriptTerminalBodyActivity {
let (dynamic_script_owner_id, lease) = claim.into_parts();
let settlement = self.apply_runtime_script_failure_terminal_body(
script,
message,
module_failure_policy,
error_constructor,
lease,
);
debug!(
?dynamic_script_owner_id,
url = %script.url,
activity = ?settlement.activity,
"completed claimed runtime-owned script failure body"
);
settlement.activity
}
pub(crate) fn cancel_claimed_runtime_owned_script_load_delay_body(
&mut self,
claim: DynamicScriptPageTaskClaim,
script: &PreparedScript,
) {
let (dynamic_script_owner_id, lease) = claim.into_parts();
self.release_runtime_script_load_delay_lease_body(script, lease);
debug!(
?dynamic_script_owner_id,
url = %script.url,
"released claimed runtime-owned script load-delay lease inside selected body"
);
}
pub(super) fn apply_runtime_script_success_terminal(
&mut self,
script: &PreparedScript,
lease: MainDocumentScriptLoadDelayLease,
) {
if let Some(PostParseLifecycleWork::DispatchScriptEvent(task)) =
self.plan_script_load_lifecycle_work_for_prepared_script(script)
{
self.dispatch_runtime_script_terminal_event_and_finish_checkpoint_best_effort(&task);
}
self.release_runtime_script_load_delay_lease(script, lease);
}
pub(super) fn apply_runtime_script_failure_terminal(
&mut self,
script: &PreparedScript,
message: &str,
module_failure_policy: Option<crate::host::ModuleFailurePolicy>,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
lease: MainDocumentScriptLoadDelayLease,
) {
let work = self.document_runtime.plan_script_failure_lifecycle_work(
script,
message,
module_failure_policy,
error_constructor,
);
for terminal in work {
match terminal {
PostParseLifecycleWork::DispatchScriptEvent(task) => {
self.dispatch_runtime_script_terminal_event_and_finish_checkpoint_best_effort(
&task,
);
}
PostParseLifecycleWork::ReportWindowScriptFailure(task) => {
self.report_runtime_script_failure_terminal_and_finish_checkpoint_best_effort(
&task,
);
}
other => unreachable!(
"runtime script failure planning produced non-terminal work: {other:?}"
),
}
}
self.release_runtime_script_load_delay_lease(script, lease);
}
fn apply_runtime_script_success_terminal_body(
&mut self,
script: &PreparedScript,
lease: MainDocumentScriptLoadDelayLease,
) -> crate::script_vm::ScriptTerminalBodyActivity {
let activity = if let Some(PostParseLifecycleWork::DispatchScriptEvent(task)) =
self.plan_script_load_lifecycle_work_for_prepared_script(script)
{
self.dispatch_script_event_body_best_effort(&task);
crate::script_vm::ScriptTerminalBodyActivity::EventDispatchAttempted
} else {
crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch
};
self.release_runtime_script_load_delay_lease_body(script, lease);
activity
}
fn apply_runtime_script_failure_terminal_body(
&mut self,
script: &PreparedScript,
message: &str,
module_failure_policy: Option<crate::host::ModuleFailurePolicy>,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
lease: MainDocumentScriptLoadDelayLease,
) -> RuntimeScriptFailureTerminalBodySettlement {
let work = self.document_runtime.plan_script_failure_lifecycle_work(
script,
message,
module_failure_policy,
error_constructor,
);
let mut activity = crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch;
for terminal in work {
match terminal {
PostParseLifecycleWork::DispatchScriptEvent(task) => {
self.dispatch_script_event_body_best_effort(&task);
activity = crate::script_vm::ScriptTerminalBodyActivity::EventDispatchAttempted;
}
PostParseLifecycleWork::ReportWindowScriptFailure(task) => {
self.report_window_error_body_best_effort(
&task.message,
task.filename.as_deref(),
task.error_constructor,
);
activity = crate::script_vm::ScriptTerminalBodyActivity::EventDispatchAttempted;
}
other => unreachable!(
"runtime script failure planning produced non-terminal work: {other:?}"
),
}
}
let load_gate_release = self.release_runtime_script_load_delay_lease_body(script, lease);
RuntimeScriptFailureTerminalBodySettlement {
activity,
load_gate_release,
}
}
pub(super) fn release_runtime_script_load_delay_lease(
&mut self,
script: &PreparedScript,
lease: MainDocumentScriptLoadDelayLease,
) {
let release = self.release_runtime_script_load_delay_lease_body(script, lease);
self.prime_lifecycle_after_script_load_gate_release(release);
}
fn release_runtime_script_load_delay_lease_body(
&mut self,
script: &PreparedScript,
lease: MainDocumentScriptLoadDelayLease,
) -> MainDocumentScriptLoadDelayRelease {
let owner = lease.owner();
let kind = lease.kind();
let load_delay_token = lease.load_delay_token();
let release = self
._context_host
.borrow_mut()
.release_main_document_script_load_delay(lease);
debug!(
?owner,
?kind,
?load_delay_token,
?release,
script_node_id = ?script.node_id,
script_url = %script.url,
"released runtime script load-delay lease after observable terminal body"
);
release
}
pub(super) fn exact_runtime_script_terminal_lease_or_warn(
&mut self,
dynamic_script_owner_id: DynamicScriptOwnerId,
script: &PreparedScript,
lease: Option<MainDocumentScriptLoadDelayLease>,
) -> Option<MainDocumentScriptLoadDelayLease> {
if lease.is_none() {
tracing::warn!(
?dynamic_script_owner_id,
script_node_id = ?script.node_id,
script_url = %script.url,
"ignored runtime script terminal without its exact load-delay lease"
);
}
lease
}
fn prime_lifecycle_after_script_load_gate_release(
&mut self,
release: MainDocumentScriptLoadDelayRelease,
) {
if release == MainDocumentScriptLoadDelayRelease::BecameUnblocked {
self.prime_document_lifecycle_processing_and_record_stylesheet_network_results();
}
}
pub(crate) fn accept_main_document_script_load_delay_binding(
&mut self,
owner: FrameDocumentTaskOwner,
kind: MainDocumentScriptLoadDelayKind,
) -> Option<MainDocumentScriptLoadDelayLease> {
self._context_host
.borrow_mut()
.acquire_current_main_document_script_load_delay(owner, kind)
}
pub(crate) fn cancel_runtime_owned_script_load_delay_body(
&mut self,
script: &PreparedScript,
dynamic_script_owner_id: DynamicScriptOwnerId,
) {
let lease = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.finish_script_terminal(dynamic_script_owner_id);
let Some(lease) = lease else {
return;
};
let release = self.release_runtime_script_load_delay_lease_body(script, lease);
debug!(
?dynamic_script_owner_id,
?release,
url = %script.url,
"released dropped runtime-owned script load-delay lease inside selected body"
);
}
pub(crate) fn finish_runtime_owned_script_failure(
&mut self,
dynamic_script_owner_id: Option<DynamicScriptOwnerId>,
script: &PreparedScript,
message: &str,
) {
self.finish_runtime_owned_script_failure_with_kind(
dynamic_script_owner_id,
script,
message,
crate::dynamic_script_owner::DynamicScriptOwner::legacy_message_failure_kind(
script, message,
),
None,
None,
);
}
pub(crate) fn finish_runtime_owned_script_failure_body_with_kind(
&mut self,
dynamic_script_owner_id: Option<DynamicScriptOwnerId>,
script: &PreparedScript,
message: &str,
kind: crate::dynamic_script_owner::DynamicScriptFailureKind,
module_failure_policy: Option<crate::host::ModuleFailurePolicy>,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
) -> crate::script_vm::ScriptTerminalBodyActivity {
if let Some(id) = dynamic_script_owner_id {
if kind == crate::dynamic_script_owner::DynamicScriptFailureKind::Immediate {
let lease = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.finish_script_terminal(id);
let Some(lease) =
self.exact_runtime_script_terminal_lease_or_warn(id, script, lease)
else {
return crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch;
};
return self
.apply_runtime_script_failure_terminal_body(
script,
message,
module_failure_policy,
error_constructor,
lease,
)
.activity;
}
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.note_script_failed_with_kind_and_error_constructor(
id,
script,
message.to_owned(),
kind,
module_failure_policy,
error_constructor,
);
self.enqueue_immediate_runtime_script_work_if_needed();
return crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch;
}
if kind == crate::dynamic_script_owner::DynamicScriptFailureKind::Immediate {
let dispatch_current_script_error_immediately = script.source_kind
== ScriptSourceKind::External
&& self.prepared_script_uses_runtime_owned_page_task_execution(script);
if dispatch_current_script_error_immediately {
let activity = self.dispatch_current_prepared_script_error_body_best_effort(
script,
message,
module_failure_policy,
error_constructor,
);
self.enqueue_immediate_runtime_script_work_if_needed();
return activity;
}
match self.enqueue_script_failure_lifecycle_work_for_prepared_script(
script,
message,
module_failure_policy,
error_constructor,
) {
Ok(FollowupPageTaskDisposition::Skipped) => {}
Ok(
disposition @ (FollowupPageTaskDisposition::Deferred
| FollowupPageTaskDisposition::Enqueued),
) => {
if self.pause_runtime_script_work_at_followup_task_boundary(disposition) {
return crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch;
}
}
Err(error) => {
self.record_runtime_warning(format_args!(
"script failure page-task enqueue failed for `{}`: {error}",
script.url
));
}
}
self.enqueue_immediate_runtime_script_work_if_needed();
return crate::script_vm::ScriptTerminalBodyActivity::NoEventDispatch;
}
panic!("runtime-owned deferrable script failure should carry dynamic owner id");
}
/// Records a deferrable module-graph failure without publishing a second
/// concrete runtime continuation yet.
///
/// The selected graph-terminal action owns a bounded settlement pass after
/// all of its failures have been recorded. Keeping publication out of this
/// method lets that pass preserve DynamicScriptOwner's lane ordering while
/// still dispatching every now-runnable error in the same owner action.
pub(crate) fn record_runtime_owned_module_failure_for_selected_action(
&mut self,
dynamic_script_owner_id: DynamicScriptOwnerId,
script: &PreparedScript,
message: String,
kind: crate::dynamic_script_owner::DynamicScriptFailureKind,
module_failure_policy: Option<crate::host::ModuleFailurePolicy>,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
) {
debug_assert!(
kind.is_deferrable_module(),
"selected-action recording is only for ordered module graph failures"
);
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.note_script_failed_with_kind_and_error_constructor(
dynamic_script_owner_id,
script,
message,
kind,
module_failure_policy,
error_constructor,
);
}
/// Settles only error terminals carried by the currently selected owner
/// action. DynamicScriptOwner remains the ordering authority; encountering
/// any unrelated head stops this pass instead of draining it.
fn take_runtime_owned_module_failure_terminal_for_selected_action(
&mut self,
action_owner_ids: &[DynamicScriptOwnerId],
) -> Option<(
crate::dynamic_script_owner::DynamicScriptFailureTerminal,
Option<MainDocumentScriptLoadDelayLease>,
)> {
let terminal = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.take_runnable_failure_terminal_for_action(action_owner_ids)?;
self.record_runtime_warning(format_args!(
"dynamic script load failed for `{}`: {}",
terminal.script.url, terminal.message
));
if let Some(network_result) = terminal.source_network_result.as_deref() {
self.record_script_subresource_network_result(
terminal.script.initiator_url.clone(),
terminal.script.url.clone(),
network_result,
);
}
let lease = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.finish_script_terminal(terminal.id);
let lease =
self.exact_runtime_script_terminal_lease_or_warn(terminal.id, &terminal.script, lease);
Some((terminal, lease))
}
pub(crate) fn settle_runtime_owned_module_failures_for_selected_action(
&mut self,
action_owner_ids: &[DynamicScriptOwnerId],
) -> usize {
let mut settled = 0;
loop {
let Some((terminal, lease)) = self
.take_runtime_owned_module_failure_terminal_for_selected_action(action_owner_ids)
else {
break;
};
let crate::dynamic_script_owner::DynamicScriptFailureTerminal {
id,
script,
message,
kind,
module_failure_policy,
source_network_result: _,
error_constructor,
} = terminal;
if let Some(lease) = lease {
self.apply_runtime_script_failure_terminal(
&script,
&message,
module_failure_policy,
error_constructor,
lease,
);
}
debug!(
dynamic_script_owner_id = ?id,
url = %script.url,
?kind,
"settled runtime module failure inside its selected graph-terminal action"
);
settled += 1;
}
settled
}
/// Body-only counterpart used by the selected ResourceCompletion task.
/// It preserves DynamicScriptOwner ordering, but neither performs a
/// microtask checkpoint nor primes lifecycle. Those obligations are
/// returned to the unique Page task-end coordinator.
pub(crate) fn settle_runtime_owned_module_failures_for_selected_action_body(
&mut self,
action_owner_ids: &[DynamicScriptOwnerId],
) -> RuntimeOwnedModuleFailureBodySettlement {
let mut settlement = RuntimeOwnedModuleFailureBodySettlement::none();
loop {
let Some((terminal, lease)) = self
.take_runtime_owned_module_failure_terminal_for_selected_action(action_owner_ids)
else {
break;
};
let crate::dynamic_script_owner::DynamicScriptFailureTerminal {
id,
script,
message,
kind,
module_failure_policy,
source_network_result: _,
error_constructor,
} = terminal;
if let Some(lease) = lease {
let lease_owner = lease.owner();
let terminal = self.apply_runtime_script_failure_terminal_body(
&script,
&message,
module_failure_policy,
error_constructor,
lease,
);
if terminal.activity
== crate::script_vm::ScriptTerminalBodyActivity::EventDispatchAttempted
{
settlement.activity =
crate::script_vm::ScriptTerminalBodyActivity::EventDispatchAttempted;
}
if matches!(
terminal.load_gate_release,
MainDocumentScriptLoadDelayRelease::BecameUnblocked
) {
if let Some(previous_owner) = settlement.lifecycle_unblocked_owner {
assert_eq!(
previous_owner, lease_owner,
"one selected module graph terminal cannot unblock two main Documents"
);
}
settlement.lifecycle_unblocked_owner = Some(lease_owner);
}
}
debug!(
dynamic_script_owner_id = ?id,
url = %script.url,
?kind,
"settled runtime module failure body inside its selected graph-terminal action"
);
}
settlement
}
pub(crate) fn finish_runtime_owned_script_failure_with_kind(
&mut self,
dynamic_script_owner_id: Option<DynamicScriptOwnerId>,
script: &PreparedScript,
message: &str,
kind: crate::dynamic_script_owner::DynamicScriptFailureKind,
module_failure_policy: Option<crate::host::ModuleFailurePolicy>,
error_constructor: Option<crate::types::ScriptErrorConstructorKind>,
) {
if let Some(id) = dynamic_script_owner_id {
if kind == crate::dynamic_script_owner::DynamicScriptFailureKind::Immediate {
let lease = self
.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.finish_script_terminal(id);
if let Some(lease) =
self.exact_runtime_script_terminal_lease_or_warn(id, script, lease)
{
self.apply_runtime_script_failure_terminal(
script,
message,
module_failure_policy,
error_constructor,
lease,
);
}
return;
}
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.note_script_failed_with_kind_and_error_constructor(
id,
script,
message.to_owned(),
kind,
module_failure_policy,
error_constructor,
);
debug!(
dynamic_script_owner_id = ?id,
url = %script.url,
?kind,
"queued runtime-owned script failure follow-up"
);
self.enqueue_immediate_runtime_script_work_if_needed();
return;
}
if kind == crate::dynamic_script_owner::DynamicScriptFailureKind::Immediate {
let dispatch_current_script_error_immediately = script.source_kind
== ScriptSourceKind::External
&& self.prepared_script_uses_runtime_owned_page_task_execution(script);
if dispatch_current_script_error_immediately {
self.dispatch_unclaimed_runtime_script_failure_and_finish_terminal_best_effort(
script,
message,
module_failure_policy,
error_constructor,
);
self.enqueue_immediate_runtime_script_work_if_needed();
return;
}
match self.enqueue_script_failure_lifecycle_work_for_prepared_script(
script,
message,
module_failure_policy,
error_constructor,
) {
Ok(FollowupPageTaskDisposition::Skipped) => {}
Ok(
disposition @ (FollowupPageTaskDisposition::Deferred
| FollowupPageTaskDisposition::Enqueued),
) => {
if self.pause_runtime_script_work_at_followup_task_boundary(disposition) {
return;
}
}
Err(error) => {
self.record_runtime_warning(format_args!(
"script failure page-task enqueue failed for `{}`: {error}",
script.url
));
}
}
self.enqueue_immediate_runtime_script_work_if_needed();
return;
}
panic!("runtime-owned deferrable script failure should carry dynamic owner id");
}
pub(super) fn publish_post_parse_action_followups(
&mut self,
_page_task_queue: &mut PageTaskQueue,
) {
self.publish_post_parse_action_runtime_followups();
}
pub(super) fn finish_executed_post_parse_action(
&mut self,
page_task_queue: &mut PageTaskQueue,
requires_runtime_followup_publication: bool,
) {
if !requires_runtime_followup_publication {
return;
}
self.publish_post_parse_action_followups(page_task_queue);
}
fn poll_post_parse_runtime_driver_step(
&mut self,
page_task_queue: &mut PageTaskQueue,
) -> PostParseRuntimeDriverStep {
if self.has_post_domcontentloaded_runtime_backlog(page_task_queue) {
PostParseRuntimeDriverStep::PendingBacklog
} else {
PostParseRuntimeDriverStep::Idle
}
}
pub(super) fn poll_next_post_parse_driver_step(
&mut self,
page_task_queue: &mut PageTaskQueue,
) -> PostParseDriverStep {
let has_post_domcontentloaded_load_delaying_runtime_work =
self.has_post_domcontentloaded_load_delaying_runtime_work();
self.prime_document_lifecycle_processing_and_record_stylesheet_network_results();
let owner_step = self
.document_runtime
.poll_next_post_parse_owner_driver_step(
page_task_queue,
has_post_domcontentloaded_load_delaying_runtime_work,
);
self.record_ready_stylesheet_network_results();
if let PostParseOwnerDriverStep::Ready(action) = owner_step {
return self.select_ready_owner_post_parse_driver_step(*action, page_task_queue);
}
let runtime_step = self.poll_post_parse_runtime_driver_step(page_task_queue);
select_post_parse_driver_step(owner_step, runtime_step)
}
fn select_ready_owner_post_parse_driver_step(
&mut self,
action: DocumentProcessingAction,
page_task_queue: &mut PageTaskQueue,
) -> PostParseDriverStep {
let PostParseProcessingAction {
work,
reached_boundary,
invalidation_policy,
} = PostParseProcessingAction::from_document_processing_action(action);
if !(work.is_domcontentloaded_task() || work.is_window_load_task()) {
return PostParseDriverStep::Ready(Box::new(ReadyPostParseAction::Processing(
Box::new(PostParseProcessingAction {
work,
reached_boundary,
invalidation_policy,
}),
)));
}
if work.is_domcontentloaded_task()
&& let Some(owner) = work.main_document_lifecycle_owner()
&& self
._context_host
.borrow()
.current_main_document_domcontentloaded_transition_is_ready(owner)
== Some(false)
{
tracing::debug!(
?owner,
"main DOMContentLoaded delivery remains blocked by document lifecycle"
);
page_task_queue.enqueue_front_post_parse_work_preserving_order(vec![work]);
return self.select_runtime_post_parse_step_while_owner_is_blocked(page_task_queue);
}
let is_window_load_task = work.is_window_load_task();
if is_window_load_task
&& let Some(owner) = work.main_document_lifecycle_owner()
&& self
._context_host
.borrow()
.current_main_document_complete_transition_is_ready(owner)
== Some(false)
{
tracing::debug!(
?owner,
"main window-load delivery remains blocked by document lifecycle"
);
page_task_queue.enqueue_front_post_parse_work_preserving_order(vec![work]);
return self.select_runtime_post_parse_step_while_owner_is_blocked(page_task_queue);
}
let runtime_step = if is_window_load_task {
self.poll_post_parse_load_delaying_runtime_driver_step(page_task_queue)
} else {
self.poll_post_parse_runtime_driver_step(page_task_queue)
};
match runtime_step {
PostParseRuntimeDriverStep::PendingBacklog if is_window_load_task => {
page_task_queue.enqueue_front_post_parse_work_preserving_order(vec![work]);
PostParseDriverStep::AwaitProgress
}
PostParseRuntimeDriverStep::PendingBacklog | PostParseRuntimeDriverStep::Idle => {
PostParseDriverStep::Ready(Box::new(ReadyPostParseAction::Processing(Box::new(
PostParseProcessingAction {
work,
reached_boundary,
invalidation_policy,
},
))))
}
}
}
fn select_runtime_post_parse_step_while_owner_is_blocked(
&mut self,
page_task_queue: &mut PageTaskQueue,
) -> PostParseDriverStep {
match self.poll_post_parse_runtime_driver_step(page_task_queue) {
PostParseRuntimeDriverStep::PendingBacklog | PostParseRuntimeDriverStep::Idle => {
PostParseDriverStep::AwaitProgress
}
}
}
fn poll_post_parse_load_delaying_runtime_driver_step(
&mut self,
page_task_queue: &mut PageTaskQueue,
) -> PostParseRuntimeDriverStep {
let _ = page_task_queue;
if self.has_post_domcontentloaded_load_delaying_runtime_work() {
PostParseRuntimeDriverStep::PendingBacklog
} else {
PostParseRuntimeDriverStep::Idle
}
}
pub(super) async fn next_post_parse_processing_step(
&mut self,
loader: &ResourceRequestClient,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
) -> std::result::Result<PostParseProcessingStep, String> {
loop {
if self
.restart_post_parse_lifecycle_round_if_invalidated(page_task_queue, report)
.await
{
continue;
}
if !self.document_runtime.dom_content_loaded_dispatched()
&& !self
.document_runtime
.has_parser_owned_pre_domcontentloaded_page_tasks()
&& self.runtime_script_work_has_pre_domcontentloaded_dynamic_candidate()
{
self.resume_runtime_script_work_after_deferred_page_tasks();
match self
.flush_pending_runtime_script_work_until_document_owner_stable(
loader, true, false, None,
)
.await?
{
RuntimePendingWorkFlushOutcome::Complete => continue,
RuntimePendingWorkFlushOutcome::WaitingForSource => {
return Ok(PostParseProcessingStep::AwaitProgress);
}
}
}
match self.poll_next_post_parse_driver_step(page_task_queue) {
PostParseDriverStep::Ready(action) => match *action {
ReadyPostParseAction::Processing(action) => {
return Ok(PostParseProcessingStep::Action(action));
}
},
PostParseDriverStep::NeedsContinuation => {
return Ok(PostParseProcessingStep::NeedsContinuation);
}
PostParseDriverStep::AwaitProgress => {
return Ok(PostParseProcessingStep::AwaitProgress);
}
PostParseDriverStep::Idle => {
return Ok(PostParseProcessingStep::Idle);
}
}
}
}
pub(super) async fn next_post_parse_lifecycle_advance_from_driver(
&mut self,
loader: &ResourceRequestClient,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
driver: PostParseLifecycleDriver,
) -> std::result::Result<PostParseLifecycleAdvance, String> {
loop {
match self
.next_post_parse_processing_step(loader, page_task_queue, report)
.await?
{
PostParseProcessingStep::Action(action) => {
let execution = driver.task_execution_for_action(*action);
if self
.prepare_post_parse_task_execution(page_task_queue, report, execution.token)
.await
{
continue;
}
return Ok(PostParseLifecycleAdvance::PageOwnedTask(Box::new(
execution.into_page_owned_task(),
)));
}
PostParseProcessingStep::NeedsContinuation => {
return Ok(PostParseLifecycleAdvance::NeedsContinuation);
}
PostParseProcessingStep::AwaitProgress => {
return Ok(PostParseLifecycleAdvance::AwaitProgress);
}
PostParseProcessingStep::Idle => {
return Ok(PostParseLifecycleAdvance::Complete(
driver.idle_completion_action(),
));
}
}
}
}
pub(crate) async fn advance_post_parse_lifecycle(
&mut self,
loader: &ResourceRequestClient,
page_task_queue: &mut PageTaskQueue,
report: &mut ScriptExecutionReport,
driver: PostParseLifecycleDriver,
completed_task: Option<PostParsePageOwnedTask>,
) -> std::result::Result<PostParseLifecycleAdvance, String> {
if let Some(advance) = self
.finish_completed_post_parse_page_owned_task_or_continue(
page_task_queue,
report,
completed_task,
)
.await?
{
return Ok(advance);
}
self.next_post_parse_lifecycle_advance_from_driver(loader, page_task_queue, report, driver)
.await
}
pub(super) fn has_post_domcontentloaded_runtime_backlog(
&mut self,
page_task_queue: &mut PageTaskQueue,
) -> bool {
let _ = page_task_queue;
self.has_pending_native_module_job()
|| self.has_pending_stable_runtime_script_continuation()
|| (self.document_runtime.dom_content_loaded_dispatched()
&& self.has_pending_runtime_script_work())
}
fn has_post_domcontentloaded_load_delaying_runtime_work(&mut self) -> bool {
if !self.document_runtime.dom_content_loaded_dispatched() {
return false;
}
self.refresh_script_vm_local_document_state();
self.current_main_document_task_owner()
.and_then(|owner| self.current_main_document_has_async_script_load_delay(owner))
.unwrap_or(false)
}
pub(super) fn has_pending_runtime_script_work(&mut self) -> bool {
self.document_runtime
.runtime_script_work_mut()
.has_pending_work()
}
pub(crate) fn current_main_document_has_async_script_load_delay(
&self,
owner: crate::frame_owner_model::FrameDocumentTaskOwner,
) -> Option<bool> {
self._context_host
.borrow()
.current_main_document_has_async_script_load_delay(owner)
}
#[cfg(test)]
pub(crate) fn current_main_document_has_style_load_event_delay(
&self,
owner: crate::frame_owner_model::FrameDocumentTaskOwner,
) -> Option<bool> {
self._context_host
.borrow()
.current_main_document_has_style_load_event_delay(owner)
}
fn has_pending_stable_runtime_script_continuation(&mut self) -> bool {
self.document_runtime
.runtime_script_work_mut()
.is_paused_for_deferred_page_tasks()
&& self.document_runtime.runtime_script_work_mut().pause_kind()
== Some(RuntimeScriptWorkPauseKind::StablePageTurnContinuation)
&& !self.document_runtime.runtime_script_work_mut().is_idle()
}
pub(crate) fn has_runnable_runtime_script_work_now(&mut self) -> bool {
self.refresh_script_vm_local_document_state();
let has_stable_continuation = self.has_pending_stable_runtime_script_continuation();
if self.document_runtime.dom_content_loaded_dispatched() {
return (has_stable_continuation || self.has_pending_runtime_script_work())
&& self.runtime_script_work_has_immediately_runnable_work();
}
has_stable_continuation
&& self
.runtime_script_work_has_immediately_runnable_dynamic_work_before_domcontentloaded()
}
fn prepared_dynamic_script_targets_pre_domcontentloaded_lane(
&self,
script: &PreparedScript,
) -> bool {
let Some(handle) = script.host_script_handle.as_deref() else {
return false;
};
self.document_runtime.script_handle_source(handle) == ScriptHandleSource::DocumentWriteOwned
&& self.document_runtime.script_handle_followup_lane(handle)
== Some(crate::document_runtime::DeferredPageTaskLane::PreDomContentLoaded)
}
fn runtime_script_work_has_pre_domcontentloaded_dynamic_candidate(&mut self) -> bool {
self.document_runtime.accept_ready_runtime_script_events();
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.has_script_matching(|script| {
self.prepared_dynamic_script_targets_pre_domcontentloaded_lane(script)
})
}
fn runtime_script_work_has_immediately_runnable_dynamic_work_before_domcontentloaded(
&mut self,
) -> bool {
self.document_runtime.accept_ready_runtime_script_events();
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.has_immediately_runnable_work_matching(|script| {
dynamic_script_execute_is_runnable_before_dom_content_loaded(
&self.document_runtime,
script,
)
})
}
fn prepare_runtime_script_work_signal(&mut self) -> Option<ImmediateRuntimeScriptWorkSignal> {
(self.has_pending_runtime_script_work()
&& self.arm_runtime_script_work_continuation_if_needed()
&& self.runtime_script_work_should_signal_immediate_progress())
.then_some(ImmediateRuntimeScriptWorkSignal::StablePageTurnContinuation)
}
pub(crate) fn enqueue_immediate_runtime_script_work_if_needed(&mut self) {
self.enqueue_runtime_script_signal_if_needed();
}
pub(super) fn enqueue_runtime_script_signal_if_needed(&mut self) {
if let Some(signal) = self.prepare_runtime_script_work_signal() {
self.enqueue_immediate_runtime_script_work_signal(signal);
}
}
pub(super) fn arm_runtime_script_work_continuation_if_needed(&mut self) -> bool {
if self.document_runtime.runtime_script_work_mut().is_idle() {
return false;
}
self.pause_runtime_script_work_for_stable_continuation();
true
}
#[cfg(test)]
pub(super) fn test_pending_runtime_source_load_script(&self) -> PreparedScript {
PreparedScript {
position: 0,
node_id: NodeId::new(1),
kind: ScriptKind::Classic,
mode: ScriptMode::Async,
source_kind: ScriptSourceKind::External,
fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
source: moli_parser::ScriptSource::External,
url: Url::parse("https://example.com/pending-runtime.js").unwrap(),
base_url: Url::parse("https://example.com/pending-runtime.js").unwrap(),
initiator_url: Url::parse("https://example.com/").unwrap(),
host_script_handle: None,
}
}
#[cfg(test)]
pub(crate) fn enqueue_test_pending_runtime_source_load(&mut self) {
let script = self.test_pending_runtime_source_load_script();
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.enqueue_loading_script_for_test(script);
}
/// Install a ready runtime-script producer without publishing its Page
/// continuation.
///
/// The fixture carries the same exact Document load-delay lease and
/// runtime-owned script identity as production. A later selected callback
/// completion must therefore publish the real
/// `RuntimeScriptContinuation`; the fixture never executes the script
/// through a test-only path.
#[cfg(test)]
pub(crate) fn enqueue_test_ready_runtime_script_followup(&mut self) {
let owner = self
.current_main_document_task_owner()
.expect("ready runtime-script fixture requires a current main Document");
let load_delay_binding = self
.accept_main_document_script_load_delay_binding(
owner,
MainDocumentScriptLoadDelayKind::Classic,
)
.expect("ready runtime-script fixture requires exact lifecycle ownership");
let node_id = self
.document_runtime
.dom_host_mut()
.create_element("script");
let host_script_handle = format!("test-runtime-followup-{}", node_id.index());
self.document_runtime
.bind_runtime_owned_script_handle_for_node(node_id, &host_script_handle);
let script = PreparedScript {
position: node_id.index(),
node_id,
kind: ScriptKind::Classic,
mode: ScriptMode::Async,
source_kind: ScriptSourceKind::Inline,
fetch_metadata: crate::planning::ScriptFetchMetadata::default(),
source: moli_parser::ScriptSource::Inline(String::new()),
url: Url::parse("data:text/javascript,").expect("test runtime-script URL"),
base_url: self.document_runtime.document_url().clone(),
initiator_url: self.document_runtime.document_url().clone(),
host_script_handle: Some(host_script_handle),
};
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.enqueue_ready_script_with_load_delay_for_test(script, load_delay_binding);
// Match the production handoff: the concrete producer is ready, but
// it remains parked behind a stable continuation until the enclosing
// selected callback completes. Without this pause, the callback's
// legacy host-turn flush could execute the script directly and the
// fixture would not prove typed continuation publication.
self.handle_runtime_script_work_at_explicit_boundary(false);
}
fn pause_runtime_script_work_for_stable_continuation(&mut self) {
self.document_runtime
.runtime_script_work_mut()
.pause_for_deferred_page_tasks(RuntimeScriptWorkPauseKind::StablePageTurnContinuation);
let Some(document_owner) = self.current_main_document_task_owner() else {
self.record_runtime_warning(format_args!(
"cannot arm runtime script continuation without a current main Document owner"
));
return;
};
let continuation = self
.page_runtime_wake_tx
.bind_main_document_runtime_continuation(document_owner);
self.document_runtime
.runtime_script_work_mut()
.dynamic_scripts
.enable_continuation_enqueue(continuation);
}
pub(super) fn runtime_script_work_should_signal_immediate_progress(&mut self) -> bool {
self.document_runtime.accept_ready_runtime_script_events();
if self.document_runtime.runtime_script_work_mut().is_idle() {
return false;
}
if self.document_runtime.dom_content_loaded_dispatched() {
return self.runtime_script_work_has_immediately_runnable_work();
}
self.runtime_script_work_has_immediately_runnable_dynamic_work_before_domcontentloaded()
}
pub(crate) fn dispatch_connected_style_load(
&mut self,
ready: crate::document_runtime::ReadyConnectedStyleLoad,
) -> bool {
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
let context_host = self._context_host.clone();
let document_runtime = &mut self.document_runtime;
self.renderer_document_isolate
.with_renderer_document_isolate_mut(|isolate| {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let context = unsafe { v8::Local::new(scope, &*context_ptr) };
let scope = &mut v8::ContextScope::new(scope, context);
let host_ptr: *mut JsContextHost = (*context_host).as_ptr();
if ready.load_event_binding().is_some_and(|binding| {
!unsafe { &*host_ptr }.main_style_load_event_is_current(binding)
}) {
return false;
}
document_runtime.dispatch_pending_style_load(scope, host_ptr, ready)
})
}
pub(crate) fn apply_pending_stylesheet_source_css_projections(&mut self) {
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
let context_host = self._context_host.clone();
let document_runtime = &mut self.document_runtime;
self.renderer_document_isolate
.with_renderer_document_isolate_mut(|isolate| {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let context = unsafe { v8::Local::new(scope, &*context_ptr) };
let scope = &mut v8::ContextScope::new(scope, context);
let host_ptr: *mut JsContextHost = (*context_host).as_ptr();
document_runtime.apply_pending_stylesheet_source_css_projections(scope, host_ptr);
});
}
pub(crate) fn settle_stylesheet_link_clients(
&mut self,
clients: Vec<crate::document_runtime::StylesheetLinkClientTerminal>,
) {
if clients.is_empty() {
return;
}
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
let context_host = self._context_host.clone();
let document_runtime = &mut self.document_runtime;
self.renderer_document_isolate
.with_renderer_document_isolate_mut(|isolate| {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let context = unsafe { v8::Local::new(scope, &*context_ptr) };
let scope = &mut v8::ContextScope::new(scope, context);
let host_ptr: *mut JsContextHost = (*context_host).as_ptr();
document_runtime
.settle_stylesheet_link_clients_in_current_scope(scope, host_ptr, clients);
});
}
pub(crate) fn dispatch_preload_like_link_error_event(&mut self, handle: DomHandle) -> bool {
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
let context_host = self._context_host.clone();
let document_runtime = &mut self.document_runtime;
self.renderer_document_isolate
.with_renderer_document_isolate_mut(|isolate| {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let context = unsafe { v8::Local::new(scope, &*context_ptr) };
let scope = &mut v8::ContextScope::new(scope, context);
let host_ptr: *mut JsContextHost = (*context_host).as_ptr();
document_runtime.dispatch_preload_like_link_error_event(scope, host_ptr, handle);
});
true
}
pub(crate) fn bind_prepared_script_handle_if_needed(
&mut self,
script: &mut PreparedScript,
source: ScriptHandleSource,
) {
let allow_missing_handle = script.kind == ScriptKind::Classic
&& script.source_kind == ScriptSourceKind::Inline
&& script.mode == ScriptMode::Normal;
if script.host_script_handle.is_none() && !allow_missing_handle {
let handle = match source {
ScriptHandleSource::ParserOwned => self
.document_runtime
.bind_parser_owned_script_handle_for_node(script.node_id),
ScriptHandleSource::DocumentWriteOwned => self
.document_runtime
.bind_document_write_owned_script_handle_for_node(script.node_id),
ScriptHandleSource::Unknown | ScriptHandleSource::RuntimeOwned => {
panic!("unsupported prepared script binding source: {source:?}")
}
};
script.host_script_handle = Some(handle);
}
if matches!(source, ScriptHandleSource::DocumentWriteOwned)
&& !matches!(script.mode, ScriptMode::Normal)
{
let _ = self
.document_runtime
.mark_script_already_started_by_node_id(script.node_id);
}
if let Some(handle) = script.host_script_handle.as_deref() {
self.document_runtime.set_script_handle_followup_lane(
handle,
crate::host::HostScriptScheduler::followup_lane_for_script(source, script.mode),
);
if matches!(source, ScriptHandleSource::DocumentWriteOwned)
&& (script.kind == ScriptKind::Module
|| matches!(
script.mode,
ScriptMode::Async
| ScriptMode::InOrder
| ScriptMode::ImportMapInOrder
| ScriptMode::ModuleInOrder
))
{
self.document_runtime
.set_script_handle_waits_until_dom_content_loaded(handle);
}
}
}
pub(crate) fn prime_document_lifecycle_processing_and_record_stylesheet_network_results(
&mut self,
) {
let prime_result = self
.document_runtime
.prime_document_lifecycle_processing_for_owner(self._context_host.as_ref().as_ptr());
self.apply_connected_style_load_prime_result(prime_result);
self.record_ready_stylesheet_network_results();
self.reconcile_document_web_fonts_for_layout();
}
pub(crate) fn apply_connected_style_load_prime_result(
&mut self,
prime_result: crate::document_runtime::ConnectedStyleLoadPrimeResult,
) {
let (modulepreload_starts, runtime_warnings, completed_stylesheet_clients) =
prime_result.into_parts_with_completed_stylesheet_clients();
self.settle_stylesheet_link_clients(completed_stylesheet_clients);
for warning in runtime_warnings {
self.record_runtime_warning(format_args!("{warning}"));
}
for start in modulepreload_starts {
let (request, link_client) = start.into_parts();
if let Err(error) =
self.register_native_modulepreload_link_for_owner(request, link_client)
{
tracing::debug!(
"connected JS modulepreload failed before fetch scheduling: {}",
error
);
}
}
}
#[cfg(test)]
pub(in crate::script_vm) fn queue_linked_stylesheet_import_csp_violations(
&mut self,
import_urls: impl IntoIterator<Item = url::Url>,
) {
let violations = import_urls
.into_iter()
.flat_map(|url| {
let (report_only, enforced) = self
.document_runtime
.style_element_request_csp_check(
&url,
crate::content_security_policy::ContentSecurityPolicyStyleElementRequest {
nonce: None,
},
)
.into_violations();
[report_only, enforced].into_iter().flatten()
})
.collect::<Vec<_>>();
if violations.is_empty() {
return;
}
let context_ptr: *const v8::Global<v8::Context> = &self.page_default_runtime.context;
let context_host = self._context_host.clone();
let document_runtime = &mut self.document_runtime;
self.renderer_document_isolate
.with_renderer_document_isolate_mut(|isolate| {
let scope = pin!(v8::HandleScope::new(isolate));
let scope = &mut scope.init();
let context = unsafe { v8::Local::new(scope, &*context_ptr) };
let scope = &mut v8::ContextScope::new(scope, context);
let host_ptr: *mut JsContextHost = (*context_host).as_ptr();
for violation in violations {
document_runtime.queue_content_security_policy_violation_event_best_effort(
scope, host_ptr, &violation,
);
}
});
}
pub(crate) fn record_ready_stylesheet_network_results(&mut self) {
let results = self
.document_runtime
.take_ready_stylesheet_network_results();
let client_terminals = self
.document_runtime
.take_ready_stylesheet_link_client_terminals();
let blocking_import_graphs = self
.document_runtime
.take_ready_blocking_style_import_graphs();
if results.is_empty() && client_terminals.is_empty() && blocking_import_graphs.is_empty() {
return;
}
let optional_resource_fetch_mask = self
.document_runtime
.current_document_resource_loader()
.map_or(
crate::protocol_types::OptionalResourceFetchMask::NONE,
|loader| loader.request_client().optional_resource_fetch_mask(),
);
let mut performance_entries = Vec::new();
let mut css_subresources = Vec::new();
let mut import_graph_results: Vec<(
crate::document_runtime::ConnectedStyleImportRoot,
Vec<crate::live_stylesheet::LiveStylesheetImportResponse>,
)> = Vec::new();
let mut host = self._context_host.borrow_mut();
for network_result in results {
let crate::document_runtime::ConnectedLoadNetworkResult {
stylesheet_fetch,
blocking_operation: _,
source_operation: _,
import_roots,
document_url,
request_url,
source_owners,
resource_type,
start_unix_millis,
origin_clean,
result,
} = network_result;
let is_import_graph_result = !import_roots.is_empty();
let import_roots = import_roots
.into_iter()
.filter(|root| {
host.live_stylesheet(root.stylesheet_id)
.is_some_and(|stylesheet| root.matches_stylesheet(&stylesheet))
})
.collect::<Vec<_>>();
let has_stylesheet_install_authority = if is_import_graph_result {
!import_roots.is_empty()
} else {
!source_owners.is_empty()
};
performance_entries.push(
crate::context_bootstrap::ResourcePerformanceEntry::from_network_result(
request_url.as_str(),
preload_like_resource_initiator_type(resource_type),
start_unix_millis,
&result,
),
);
if resource_type == SubresourceResourceType::Stylesheet && stylesheet_fetch.is_none() {
let validated_response = result
.as_ref()
.ok()
.filter(|response| (200..=299).contains(&response.status))
.and_then(|response| {
crate::stylesheet_blocking::validate_stylesheet_response(
&request_url,
response.clone(),
)
.ok()
});
let (stylesheet_text, stylesheet_base_url) = validated_response
.as_ref()
.map(|response| (response.body_text().to_owned(), response.final_url.clone()))
.unwrap_or_else(|| {
let final_url = result
.as_ref()
.ok()
.map(|response| response.final_url.clone())
.unwrap_or_else(|| request_url.clone());
(String::new(), final_url)
});
if is_import_graph_result {
let response = crate::live_stylesheet::LiveStylesheetImportResponse {
request_url: request_url.clone(),
response_url: stylesheet_base_url.clone(),
css_text: stylesheet_text.clone(),
successful: validated_response.is_some(),
origin_clean,
};
for root in import_roots {
if let Some((_, responses)) =
import_graph_results.iter_mut().find(|(candidate, _)| {
candidate.owner == root.owner
&& candidate.stylesheet_id == root.stylesheet_id
&& candidate.contents_revision == root.contents_revision
&& candidate.import_generation == root.import_generation
})
{
responses.push(response.clone());
} else {
import_graph_results.push((root, vec![response.clone()]));
}
}
}
if !is_import_graph_result {
for owner in source_owners.iter().copied() {
let Some(prepared) = host.prepare_linked_stylesheet_resource(
owner,
&stylesheet_text,
stylesheet_base_url.clone(),
request_url.clone(),
origin_clean,
) else {
continue;
};
host.install_linked_stylesheet(
crate::document_runtime::InstallLinkedStylesheet::from_prepared(
owner,
request_url.clone(),
prepared,
),
);
}
}
// A stale completion remains observable as Network and
// Performance data, but cannot derive new requests in the
// current document after its exact owner/root authority was
// revoked.
if has_stylesheet_install_authority && validated_response.is_some() {
for resource in
crate::css_resource_urls::stylesheet_load_blocking_font_resources(
&stylesheet_text,
&stylesheet_base_url,
optional_resource_fetch_mask,
)
{
let Some(binding) =
host.accept_current_main_stylesheet_subresource_load_delay()
else {
tracing::debug!(
url = ?resource.request_url(),
kind = ?resource.kind(),
"skipping stylesheet subresource for stale main document owner"
);
continue;
};
css_subresources.push((binding, resource));
}
}
}
host.record_get_subresource_network_result_with_initiator(
None,
document_url,
request_url,
resource_type,
SubresourceRequestInitiatorType::Parser,
&result,
);
}
for (root, responses) in import_graph_results {
if host
.install_live_stylesheet_import_graph(root.clone(), &responses)
.is_some()
{
let _ =
host.refresh_live_stylesheet_after_import_graph(root.owner, root.stylesheet_id);
}
}
for blocking_import_graph in blocking_import_graphs {
let (source, roots, graph) = blocking_import_graph.into_parts();
let mut successful = graph.successful();
let expected_root_count = roots.len();
let roots = roots
.into_iter()
.filter(|root| {
host.live_stylesheet(root.stylesheet_id)
.is_some_and(|stylesheet| root.matches_stylesheet(&stylesheet))
})
.collect::<Vec<_>>();
successful &= !roots.is_empty() && roots.len() == expected_root_count;
let responses =
crate::document_runtime::live_stylesheet_import_responses(graph.as_ref());
if !roots.is_empty() {
for response in &responses {
if !response.successful {
continue;
}
for resource in
crate::css_resource_urls::stylesheet_load_blocking_font_resources(
&response.css_text,
&response.response_url,
optional_resource_fetch_mask,
)
{
let Some(binding) =
host.accept_current_main_stylesheet_subresource_load_delay()
else {
continue;
};
css_subresources.push((binding, resource));
}
}
}
for root in roots {
match host.install_live_stylesheet_import_graph(root.clone(), &responses) {
Some(graph_successful) => {
successful &= graph_successful;
let _ = host.refresh_live_stylesheet_after_import_graph(
root.owner,
root.stylesheet_id,
);
}
None => successful = false,
}
}
self.document_runtime
.complete_ready_blocking_style_import_graph(source, successful, Arc::clone(&graph));
}
drop(host);
self.settle_stylesheet_link_clients(client_terminals);
self.apply_pending_stylesheet_source_css_projections();
self.start_stylesheet_subresource_fetches(css_subresources);
self.record_resource_performance_entries(performance_entries);
}
fn record_resource_performance_entries(
&mut self,
entries: Vec<crate::context_bootstrap::ResourcePerformanceEntry>,
) {
if entries.is_empty() {
return;
}
if let Err(error) = self.with_default_context_scope(|scope, _host_ptr| {
for entry in entries {
crate::context_bootstrap::record_resource_performance_entry(scope, entry);
}
Ok(())
}) {
self.record_runtime_warning(format_args!(
"failed to record resource performance entries: {error}"
));
}
}
pub(super) fn start_stylesheet_subresource_fetches(
&mut self,
resources: Vec<(
crate::frame_owner_model::StylesheetSubresourceLoadDelayBinding,
crate::css_resource_urls::StylesheetLoadBlockingResource,
)>,
) {
if resources.is_empty() {
return;
}
if let Err(error) = self.with_default_context_scope(move |scope, host_ptr| {
crate::document_runtime::DocumentRuntime::start_stylesheet_subresource_fetches_in_current_scope(
scope, host_ptr, resources,
);
Ok(())
}) {
self.record_runtime_warning(format_args!(
"failed to enter stylesheet subresource request scope: {error}"
));
}
}
pub(crate) fn record_script_subresource_network_result(
&mut self,
document_url: Url,
request_url: Url,
result: &std::result::Result<crate::protocol_types::NavigationResponse, String>,
) {
self.record_script_subresource_network_result_with_initiator(
document_url,
request_url,
SubresourceRequestInitiatorType::Parser,
result,
);
}
pub(crate) fn record_script_subresource_network_result_with_initiator(
&mut self,
document_url: Url,
request_url: Url,
request_initiator_type: SubresourceRequestInitiatorType,
result: &std::result::Result<crate::protocol_types::NavigationResponse, String>,
) {
let performance_entry =
crate::context_bootstrap::ResourcePerformanceEntry::from_network_result(
request_url.as_str(),
"script",
None,
result,
);
self._context_host
.borrow_mut()
.record_get_subresource_network_result_with_initiator(
None,
document_url,
request_url,
SubresourceResourceType::Script,
request_initiator_type,
result,
);
self.record_resource_performance_entries(vec![performance_entry]);
}
pub(crate) fn record_historical_script_subresource_network_result(
&mut self,
document_url: Url,
request_url: Url,
result: &std::result::Result<crate::protocol_types::NavigationResponse, String>,
) {
self._context_host
.borrow_mut()
.record_historical_get_subresource_network_result_with_initiator(
None,
document_url,
request_url,
SubresourceResourceType::Script,
SubresourceRequestInitiatorType::Parser,
result,
);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn stylesheet_images_are_not_discovered_from_raw_css_text() {
let stylesheet_base_url =
Url::parse("https://example.test/assets/app.css").expect("stylesheet url");
let stylesheet_text = "#hero { background-image: url(hero.png); }";
assert!(
crate::css_resource_urls::stylesheet_load_blocking_font_resources(
stylesheet_text,
&stylesheet_base_url,
crate::protocol_types::OptionalResourceFetchMask::NONE,
)
.is_empty()
);
let resources = crate::css_resource_urls::stylesheet_load_blocking_font_resources(
stylesheet_text,
&stylesheet_base_url,
crate::protocol_types::OptionalResourceFetchMask::IMAGE,
);
assert!(resources.is_empty());
}
#[test]
fn stylesheet_font_face_resources_require_the_font_bit() {
let stylesheet_base_url =
Url::parse("https://example.test/assets/app.css").expect("stylesheet url");
let stylesheet_text = r#"
@font-face {
font-family: Demo;
src: local("Demo"),
url(fonts/demo.woff2) format("woff2"),
url("/fonts/demo.woff") format("woff");
}
body { background-image: url(hero.png); }
"#;
let resources = crate::css_resource_urls::stylesheet_load_blocking_font_resources(
stylesheet_text,
&stylesheet_base_url,
crate::protocol_types::OptionalResourceFetchMask::FONT,
);
assert_eq!(resources.len(), 1);
assert_eq!(
resources[0]
.request_url()
.expect("URL-backed font fixture")
.as_str(),
"https://example.test/assets/fonts/demo.woff2"
);
assert_eq!(
resources[0].kind(),
crate::css_resource_urls::StylesheetLoadBlockingResourceKind::Font
);
}
}