Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(renderer): defer idle callbacks while page work is pending

ldm0c0e189a0fbad
diff --git a/moli-renderer-v8/src/document_runtime/events.rs b/moli-renderer-v8/src/document_runtime/events.rs
index 3e177408b..9ee3afa07 100644
--- a/moli-renderer-v8/src/document_runtime/events.rs
+++ b/moli-renderer-v8/src/document_runtime/events.rs
@@ -271,14 +271,23 @@ impl DocumentRuntime {
pub(crate) fn run_next_timeout_body(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
+ selection: crate::page_task_queue::RendererPageTimerSelection,
) -> HostTimeoutRunResult {
- self.timeouts.run_next_body(scope)
+ self.timeouts.run_next_body(scope, selection)
}
+ #[cfg(test)]
pub(crate) fn has_ready_timeout(&self) -> bool {
self.timeouts.has_ready_timer()
}
+ pub(crate) fn next_ready_timeout_deadline(
+ &self,
+ selection: crate::page_task_queue::RendererPageTimerSelection,
+ ) -> Option<std::time::Instant> {
+ self.timeouts.next_ready_timer_deadline(selection)
+ }
+
pub(crate) fn ms_to_next_timeout(&self) -> Option<u64> {
self.timeouts.ms_to_next()
}
diff --git a/moli-renderer-v8/src/host/timers.rs b/moli-renderer-v8/src/host/timers.rs
index 3fd9d0ecd..4e50b8350 100644
--- a/moli-renderer-v8/src/host/timers.rs
+++ b/moli-renderer-v8/src/host/timers.rs
@@ -15,6 +15,7 @@ use crate::{
active_lightweight_popup_id, current_runtime_observable_context_token,
lightweight_popup_id_from_window,
},
+ page_task_queue::RendererPageTimerSelection,
script_provenance::CompiledStringProvenance,
util::{
context_host_ptr_from_global_bridge, create_script_origin_with_base_url, get_private_value,
@@ -189,6 +190,24 @@ struct ScheduledTimerTask {
extra_args: Vec<v8::Global<v8::Value>>,
}
+impl ScheduledTimerTask {
+ fn is_unexpired_idle_callback_at(&self, now_ms: f64) -> bool {
+ let ScheduledTimerCallback::WindowWebIdl(callback) = &self.callback else {
+ return false;
+ };
+ callback.is_unexpired_idle_callback_at(now_ms)
+ }
+
+ fn matches_selection(&self, selection: RendererPageTimerSelection, now_ms: f64) -> bool {
+ match selection {
+ RendererPageTimerSelection::AnyReady => true,
+ RendererPageTimerSelection::ExcludeUnexpiredIdleCallbacks => {
+ !self.is_unexpired_idle_callback_at(now_ms)
+ }
+ }
+ }
+}
+
const MIN_DELAY_TIMER_READY_EARLY_ALLOWANCE: Duration = Duration::from_millis(1);
#[cfg(not(test))]
const TIMER_CALLBACK_WATCHDOG_TIMEOUT: Duration = Duration::from_secs(8);
@@ -707,21 +726,37 @@ impl HostTimeoutScheduler {
pub(crate) fn run_next_body(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
+ selection: RendererPageTimerSelection,
) -> HostTimeoutRunResult {
- let Some(timer) = self
- .scheduler
- .take_next_ready(Instant::now(), min_delay_ready_allowance())
- else {
+ let now_ms = crate::window_host::current_time_ms();
+ let Some(timer) = self.scheduler.take_next_ready_matching(
+ Instant::now(),
+ min_delay_ready_allowance(),
+ |task| task.matches_selection(selection, now_ms),
+ ) else {
return HostTimeoutRunResult::Idle;
};
self.run_timer(scope, timer)
}
+ #[cfg(test)]
pub(crate) fn has_ready_timer(&self) -> bool {
self.scheduler
.has_ready_timer(Instant::now(), min_delay_ready_allowance())
}
+ pub(crate) fn next_ready_timer_deadline(
+ &self,
+ selection: RendererPageTimerSelection,
+ ) -> Option<Instant> {
+ let now_ms = crate::window_host::current_time_ms();
+ self.scheduler.next_ready_deadline_matching(
+ Instant::now(),
+ min_delay_ready_allowance(),
+ |task| task.matches_selection(selection, now_ms),
+ )
+ }
+
fn run_timer(
&mut self,
scope: &mut v8::PinScope<'_, '_>,
diff --git a/moli-renderer-v8/src/host/window_callbacks.rs b/moli-renderer-v8/src/host/window_callbacks.rs
index 0aa90fd7d..e7c2b8cc6 100644
--- a/moli-renderer-v8/src/host/window_callbacks.rs
+++ b/moli-renderer-v8/src/host/window_callbacks.rs
@@ -71,6 +71,17 @@ impl ScheduledWindowWebIdlCallback {
.map(WindowExecutionContextIdentity::realm_token)
}
+ pub(super) fn is_unexpired_idle_callback_at(&self, now_ms: f64) -> bool {
+ match self.kind {
+ WindowWebIdlCallbackTaskKind::Idle {
+ timeout_deadline_ms,
+ } => timeout_deadline_ms < 0.0 || now_ms < timeout_deadline_ms,
+ WindowWebIdlCallbackTaskKind::Timer
+ | WindowWebIdlCallbackTaskKind::AnimationFrame { .. }
+ | WindowWebIdlCallbackTaskKind::GeolocationError { .. } => false,
+ }
+ }
+
pub(super) fn is_geolocation_watch<'s>(
&self,
scope: &mut v8::PinScope<'s, '_>,
diff --git a/moli-renderer-v8/src/page_task_queue.rs b/moli-renderer-v8/src/page_task_queue.rs
index d32eb81de..3c710f8ac 100644
--- a/moli-renderer-v8/src/page_task_queue.rs
+++ b/moli-renderer-v8/src/page_task_queue.rs
@@ -361,7 +361,7 @@ pub(crate) use self::owner_sources::{
};
pub(crate) use self::owner_sources::{
RendererPageOwnedTaskSources, RendererPageReadyDescriptor, RendererPageSchedulerTask,
- RendererPageTaskProducerRoutes, RendererPageTaskSourceKind,
+ RendererPageTaskProducerRoutes, RendererPageTaskSourceKind, RendererPageTimerSelection,
};
pub(crate) use self::parser_async_module_admission::{
PageParserAsyncModuleAdmissionTargetEffect, PageParserAsyncModuleAdmissionTurnAction,
diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources.rs b/moli-renderer-v8/src/page_task_queue/owner_sources.rs
index 6637ee016..220590255 100644
--- a/moli-renderer-v8/src/page_task_queue/owner_sources.rs
+++ b/moli-renderer-v8/src/page_task_queue/owner_sources.rs
@@ -238,6 +238,12 @@ pub(crate) struct RendererPageTaskProducerRoutes {
/// for arbitration and source-local eligibility. Exact executable identity is
/// part of each task payload and is interpreted only after dequeue by the lane
/// executor.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum RendererPageTimerSelection {
+ AnyReady,
+ ExcludeUnexpiredIdleCallbacks,
+}
+
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) enum RendererPageReadyDescriptor {
ActionWindow {
@@ -358,6 +364,7 @@ pub(crate) enum RendererPageReadyDescriptor {
},
Timer {
deadline: Instant,
+ selection: RendererPageTimerSelection,
},
}
@@ -478,7 +485,7 @@ impl RendererPageReadyDescriptor {
| Self::ModulepreloadStart { ready }
| Self::Networking { ready, .. }
| Self::WebSocket { ready, .. } => ready.ready_at,
- Self::ActionWindow { deadline } | Self::Timer { deadline } => deadline,
+ Self::ActionWindow { deadline } | Self::Timer { deadline, .. } => deadline,
}
}
@@ -599,6 +606,7 @@ pub(crate) enum RendererPageSchedulerTask {
WebSocket(RendererPageWebSocketTask),
Timer {
deadline: Instant,
+ selection: RendererPageTimerSelection,
},
}
@@ -1487,9 +1495,13 @@ impl RendererPageOwnedTaskSources {
);
RendererPageSchedulerTask::WebSocket(task)
}
- RendererPageReadyDescriptor::Timer { deadline } => {
- RendererPageSchedulerTask::Timer { deadline }
- }
+ RendererPageReadyDescriptor::Timer {
+ deadline,
+ selection,
+ } => RendererPageSchedulerTask::Timer {
+ deadline,
+ selection,
+ },
}
}
diff --git a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs
index 53892a70e..453d9c27b 100644
--- a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs
+++ b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs
@@ -712,11 +712,12 @@ pub(super) fn page_ready_descriptor_snapshot(
) -> PageReadyDescriptorSnapshot {
let mut descriptors = task_sources.ready_descriptors();
let stable_source_was_ready = !descriptors.is_empty();
+ descriptors.retain(|descriptor| {
+ entry
+ .page_vm_mut()
+ .page_ready_descriptor_is_eligible(*descriptor)
+ });
let mut due_deadline_was_ready = false;
- if let Some(timer) = entry.page_vm().due_page_timer_ready_descriptor() {
- descriptors.push(timer);
- due_deadline_was_ready = true;
- }
if let Some(action_window) = entry
.page_vm()
.due_page_action_window_ready_descriptor(std::time::Instant::now())
@@ -724,11 +725,18 @@ pub(super) fn page_ready_descriptor_snapshot(
descriptors.push(action_window);
due_deadline_was_ready = true;
}
- descriptors.retain(|descriptor| {
- entry
- .page_vm_mut()
- .page_ready_descriptor_is_eligible(*descriptor)
- });
+ let timer_selection = if descriptors.is_empty() {
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady
+ } else {
+ crate::page_task_queue::RendererPageTimerSelection::ExcludeUnexpiredIdleCallbacks
+ };
+ if let Some(timer) = entry
+ .page_vm()
+ .due_page_timer_ready_descriptor(timer_selection)
+ {
+ descriptors.push(timer);
+ due_deadline_was_ready = true;
+ }
PageReadyDescriptorSnapshot {
eligible: descriptors,
stable_source_was_ready,
diff --git a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs
index c4c37d4e6..731449d61 100644
--- a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs
+++ b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs
@@ -12,6 +12,8 @@
//! identifies or authorizes work for the current document. Typed queued work
//! must carry and validate its exact execution-context/document identity.
+#[cfg(test)]
+use crate::page_task_queue::RendererPageTimerSelection;
use crate::page_task_queue::{
RendererOwnerWakeSource, RendererPageReadyDescriptor, RendererPageTaskSourceKind,
};
@@ -1008,6 +1010,7 @@ mod tests {
},
RendererPageTaskSourceKind::Timer => RendererPageReadyDescriptor::Timer {
deadline: runnable_since,
+ selection: RendererPageTimerSelection::AnyReady,
},
RendererPageTaskSourceKind::DomManipulation => {
broadcast_channel_descriptor(runnable_since, order)
@@ -1436,7 +1439,10 @@ mod tests {
let selected = scheduler
.select_ready_descriptor([
dynamic_import_descriptor(base + std::time::Duration::from_millis(2), 1),
- RendererPageReadyDescriptor::Timer { deadline: base },
+ RendererPageReadyDescriptor::Timer {
+ deadline: base,
+ selection: RendererPageTimerSelection::AnyReady,
+ },
])
.expect("one ready descriptor should be selected");
@@ -1469,6 +1475,7 @@ mod tests {
dynamic_import_descriptor(runnable_at, 1),
RendererPageReadyDescriptor::Timer {
deadline: runnable_at,
+ selection: RendererPageTimerSelection::AnyReady,
},
])
.expect("one tied descriptor should be selected");
@@ -1514,6 +1521,7 @@ mod tests {
resource_descriptor(base + std::time::Duration::from_millis(2), 3),
RendererPageReadyDescriptor::Timer {
deadline: base + std::time::Duration::from_millis(3),
+ selection: RendererPageTimerSelection::AnyReady,
},
broadcast_channel_descriptor(base + std::time::Duration::from_millis(4), 4),
window_message_descriptor(base + std::time::Duration::from_millis(5), 5),
diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs
index fa2bd5c66..6becd7f39 100644
--- a/moli-renderer-v8/src/runtime/page_vm/mod.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs
@@ -2917,13 +2917,20 @@ impl PageVm {
&mut self,
loader: &ResourceRequestClient,
) -> Result<bool> {
- let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer { deadline }) =
- self.due_page_timer_ready_descriptor()
+ let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer {
+ deadline,
+ selection,
+ }) = self.due_page_timer_ready_descriptor(
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ )
else {
return Ok(false);
};
Box::pin(self.apply_selected_page_scheduler_task(
- crate::page_task_queue::RendererPageSchedulerTask::Timer { deadline },
+ crate::page_task_queue::RendererPageSchedulerTask::Timer {
+ deadline,
+ selection,
+ },
loader,
))
.await?;
diff --git a/moli-renderer-v8/src/runtime/page_vm/page_timer.rs b/moli-renderer-v8/src/runtime/page_vm/page_timer.rs
index 800dc0e76..da985ecfe 100644
--- a/moli-renderer-v8/src/runtime/page_vm/page_timer.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/page_timer.rs
@@ -2,6 +2,7 @@ use std::time::Instant;
use anyhow::{Result, ensure};
+use crate::page_task_queue::RendererPageTimerSelection;
use crate::runtime::PageOwnerTurnOutcome;
use super::PageVm;
@@ -33,11 +34,11 @@ impl PageVm {
pub(in crate::runtime) fn apply_selected_page_timer_turn(
&mut self,
expected_deadline: Instant,
+ selection: RendererPageTimerSelection,
) -> Result<PageOwnerTurnOutcome<PageTimerTurnAction>> {
- let actual_deadline = self.vm().next_timeout_deadline();
- let action = if actual_deadline == Some(expected_deadline) && self.vm().has_ready_timeout()
- {
- let body = self.vm_mut().run_next_due_timer_callback_body()?;
+ let actual_deadline = self.vm().next_ready_timeout_deadline(selection);
+ let action = if actual_deadline == Some(expected_deadline) {
+ let body = self.vm_mut().run_next_due_timer_callback_body(selection)?;
ensure!(
body.consumed_heap_head(),
"a validated due timer descriptor must consume its selected heap head"
diff --git a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs
index 259ee9c5f..f45fa2e4f 100644
--- a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs
@@ -1,5 +1,7 @@
use super::PageVm;
-use crate::page_task_queue::{RendererPageReadyDescriptor, RendererPageWindowDocumentTaskOwner};
+use crate::page_task_queue::{
+ RendererPageReadyDescriptor, RendererPageTimerSelection, RendererPageWindowDocumentTaskOwner,
+};
/// Proof that the Page arbiter matched a scheduler task against its exact
/// PageVm namespace and Window/Document ledger slot.
@@ -120,11 +122,13 @@ impl PageVm {
pub(in crate::runtime) fn due_page_timer_ready_descriptor(
&self,
+ selection: RendererPageTimerSelection,
) -> Option<RendererPageReadyDescriptor> {
self.vm()
- .has_ready_timeout()
- .then(|| self.vm().next_timeout_deadline())
- .flatten()
- .map(|deadline| RendererPageReadyDescriptor::Timer { deadline })
+ .next_ready_timeout_deadline(selection)
+ .map(|deadline| RendererPageReadyDescriptor::Timer {
+ deadline,
+ selection,
+ })
}
}
diff --git a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs
index 2236d8ae9..cca600a1c 100644
--- a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs
@@ -360,8 +360,11 @@ impl PageVm {
.await?;
Ok(())
}
- RendererPageSchedulerTask::Timer { deadline } => {
- let outcome = self.apply_selected_page_timer_turn(deadline)?;
+ RendererPageSchedulerTask::Timer {
+ deadline,
+ selection,
+ } => {
+ let outcome = self.apply_selected_page_timer_turn(deadline, selection)?;
if matches!(outcome.action, PageTimerTurnAction::Consumed { .. }) {
self.finish_selected_page_callback_task(loader).await?;
}
diff --git a/moli-renderer-v8/src/runtime/page_vm/test_support.rs b/moli-renderer-v8/src/runtime/page_vm/test_support.rs
index ed1e60125..e8ff61434 100644
--- a/moli-renderer-v8/src/runtime/page_vm/test_support.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/test_support.rs
@@ -62,9 +62,14 @@ impl PageVm {
task
} else if let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer {
deadline,
- }) = self.due_page_timer_ready_descriptor()
- {
- crate::page_task_queue::RendererPageSchedulerTask::Timer { deadline }
+ selection,
+ }) = self.due_page_timer_ready_descriptor(
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ ) {
+ crate::page_task_queue::RendererPageSchedulerTask::Timer {
+ deadline,
+ selection,
+ }
} else {
return Ok(false);
};
@@ -226,15 +231,19 @@ impl PageVmTaskExecutorTestHarness {
.checked_add(std::time::Duration::from_millis(3_200))
.unwrap_or_else(std::time::Instant::now);
for _ in 0..10_000 {
- if let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer { deadline }) =
- self.page_vm.due_page_timer_ready_descriptor()
- {
+ if let Some(crate::page_task_queue::RendererPageReadyDescriptor::Timer {
+ deadline,
+ selection,
+ }) = self.page_vm.due_page_timer_ready_descriptor(
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ ) {
self.selected_task_local_set
.run_until(
self.page_vm
.apply_selected_page_scheduler_task_on_owner_lane_for_test(
crate::page_task_queue::RendererPageSchedulerTask::Timer {
deadline,
+ selection,
},
loader.clone(),
),
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs b/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs
index f5dc2764f..05ba57070 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/timer.rs
@@ -1,14 +1,18 @@
use super::*;
use super::super::page_timer::PageTimerTurnAction;
-use crate::page_task_queue::{RendererPageReadyDescriptor, RendererPageSchedulerTask};
+use crate::page_task_queue::{
+ RendererPageReadyDescriptor, RendererPageSchedulerTask, RendererPageTimerSelection,
+};
+
+const ANY_READY_TIMER: RendererPageTimerSelection = RendererPageTimerSelection::AnyReady;
fn due_timer_deadline(page_vm: &PageVm) -> Instant {
match page_vm
- .due_page_timer_ready_descriptor()
+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)
.expect("a due timer descriptor should be ready")
{
- RendererPageReadyDescriptor::Timer { deadline } => deadline,
+ RendererPageReadyDescriptor::Timer { deadline, .. } => deadline,
other => panic!("expected timer descriptor, got {other:?}"),
}
}
@@ -20,7 +24,10 @@ async fn run_timer_through_selected_dispatcher(
) -> anyhow::Result<()> {
page_vm
.apply_selected_page_scheduler_task_on_owner_lane_for_test(
- RendererPageSchedulerTask::Timer { deadline },
+ RendererPageSchedulerTask::Timer {
+ deadline,
+ selection: ANY_READY_TIMER,
+ },
loader.clone(),
)
.await?;
@@ -67,7 +74,9 @@ setTimeout(() => {
r#"["first","microtask:first","second","microtask:second"]"#
);
assert!(
- page_vm.due_page_timer_ready_descriptor().is_none(),
+ page_vm
+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)
+ .is_none(),
"two timer tasks must consume exactly two selected turns"
);
Ok::<_, anyhow::Error>(())
@@ -94,7 +103,7 @@ setTimeout(() => {
)?;
let deadline = due_timer_deadline(&page_vm);
- let body = page_vm.apply_selected_page_timer_turn(deadline)?;
+ let body = page_vm.apply_selected_page_timer_turn(deadline, ANY_READY_TIMER)?;
assert_eq!(body.action, PageTimerTurnAction::Consumed { deadline });
assert_eq!(
page_vm.vm_mut().eval("__timerBodyBoundary.join('|')")?,
@@ -260,7 +269,7 @@ setTimeout(() => {
.checked_add(Duration::from_nanos(1))
.expect("test deadline should be representable");
- let stale = page_vm.apply_selected_page_timer_turn(stale_deadline)?;
+ let stale = page_vm.apply_selected_page_timer_turn(stale_deadline, ANY_READY_TIMER)?;
assert_eq!(
stale.action,
PageTimerTurnAction::NoLongerRunnable {
@@ -309,7 +318,11 @@ async fn timer_deadline_observation_cannot_consume_a_due_timer() {
"false",
"reading the timer deadline must not steal the scheduler-owned timer"
);
- assert!(page_vm.due_page_timer_ready_descriptor().is_some());
+ assert!(
+ page_vm
+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)
+ .is_some()
+ );
Ok(())
},
)
@@ -331,7 +344,9 @@ async fn timer_is_not_runnable_before_its_deadline() {
assert!(page_vm.vm().next_timeout_deadline().is_some());
assert!(
- page_vm.due_page_timer_ready_descriptor().is_none(),
+ page_vm
+ .due_page_timer_ready_descriptor(ANY_READY_TIMER)
+ .is_none(),
"a future heap entry is a deadline, not a runnable Page task"
);
assert_eq!(page_vm.vm_mut().eval("String(__futureTimerRan)")?, "false");
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs b/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs
index 983a665ce..0871b0a21 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/wait_observer.rs
@@ -65,15 +65,20 @@ setTimeout(() => {
)?;
let deadline = match page_vm
- .due_page_timer_ready_descriptor()
+ .due_page_timer_ready_descriptor(
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ )
.expect("the zero-delay timer should be scheduler-visible")
{
- RendererPageReadyDescriptor::Timer { deadline } => deadline,
+ RendererPageReadyDescriptor::Timer { deadline, .. } => deadline,
other => panic!("expected a timer descriptor, got {other:?}"),
};
page_vm
.apply_selected_page_scheduler_task_on_owner_lane_for_test(
- RendererPageSchedulerTask::Timer { deadline },
+ RendererPageSchedulerTask::Timer {
+ deadline,
+ selection: crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ },
loader,
)
.await?;
diff --git a/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs b/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs
index cfaefdeb2..4c894bcb9 100644
--- a/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs
+++ b/moli-renderer-v8/src/runtime/phase_one/document_write_resource_tests.rs
@@ -449,7 +449,9 @@ async fn resume_standalone_document_write_page(
let mut descriptors = vec![
crate::page_task_queue::RendererPageReadyDescriptor::Networking { ready, owner },
];
- if let Some(timer) = runtime.page_vm.due_page_timer_ready_descriptor() {
+ if let Some(timer) = runtime.page_vm.due_page_timer_ready_descriptor(
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ ) {
descriptors.push(timer);
}
let selected = crate::runtime::page_turn_scheduler::PageTurnScheduler::new(())
@@ -464,11 +466,17 @@ async fn resume_standalone_document_write_page(
)?
.expect("selected standalone resource head must be executable");
}
- crate::page_task_queue::RendererPageReadyDescriptor::Timer { deadline } => {
+ crate::page_task_queue::RendererPageReadyDescriptor::Timer {
+ deadline,
+ selection,
+ } => {
runtime
.page_vm
.apply_selected_page_scheduler_task(
- crate::page_task_queue::RendererPageSchedulerTask::Timer { deadline },
+ crate::page_task_queue::RendererPageSchedulerTask::Timer {
+ deadline,
+ selection,
+ },
&loader,
)
.await?;
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index fcaa29c7a..ac82e1e1b 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -5833,8 +5833,11 @@ impl ScriptVm {
/// This method deliberately does not checkpoint, synchronize child
/// records, or run runtime follow-up. The selected Page-task dispatcher
/// commits that completion exactly once after the body returns.
- pub(crate) fn run_next_due_timer_callback_body(&mut self) -> Result<HostTimeoutRunResult> {
- let result = self.run_next_timeout_body()?;
+ pub(crate) fn run_next_due_timer_callback_body(
+ &mut self,
+ selection: crate::page_task_queue::RendererPageTimerSelection,
+ ) -> Result<HostTimeoutRunResult> {
+ let result = self.run_next_timeout_body(selection)?;
if let HostTimeoutRunResult::CallbackError(error) = &result {
self.record_runtime_warning(format_args!("timer callback dispatch failed: {error}"));
}
@@ -5851,7 +5854,9 @@ impl ScriptVm {
&mut self,
loader: &ResourceRequestClient,
) -> Result<bool> {
- let result = self.run_next_due_timer_callback_body()?;
+ let result = self.run_next_due_timer_callback_body(
+ crate::page_task_queue::RendererPageTimerSelection::AnyReady,
+ )?;
if !result.consumed_heap_head() {
return Ok(false);
}
diff --git a/moli-renderer-v8/src/script_vm/page_task_enqueue.rs b/moli-renderer-v8/src/script_vm/page_task_enqueue.rs
index b2721e5de..5e243ce85 100644
--- a/moli-renderer-v8/src/script_vm/page_task_enqueue.rs
+++ b/moli-renderer-v8/src/script_vm/page_task_enqueue.rs
@@ -782,7 +782,10 @@ impl ScriptVm {
///
/// Production callers must enter through the selected Page timer task,
/// which commits the single task-end callback completion.
- pub(super) fn run_next_timeout_body(&mut self) -> Result<HostTimeoutRunResult> {
+ pub(super) fn run_next_timeout_body(
+ &mut self,
+ selection: crate::page_task_queue::RendererPageTimerSelection,
+ ) -> Result<HostTimeoutRunResult> {
#[cfg(test)]
if let Some(message) = self.test_next_timeout_failure.take() {
return Err(anyhow!("{message}"));
@@ -796,7 +799,7 @@ impl ScriptVm {
// creates the V8 context scope and does not access or move
// `document_runtime`; the render owner lane runs this
// synchronously on one thread.
- Ok(unsafe { &mut *document_runtime }.run_next_timeout_body(scope))
+ Ok(unsafe { &mut *document_runtime }.run_next_timeout_body(scope, selection))
})
}
@@ -809,7 +812,8 @@ impl ScriptVm {
/// bypassed.
#[cfg(test)]
pub(crate) fn run_next_timeout_for_test(&mut self) -> Result<HostTimeoutRunResult> {
- let result = self.run_next_timeout_body()?;
+ let result = self
+ .run_next_timeout_body(crate::page_task_queue::RendererPageTimerSelection::AnyReady)?;
if result.consumed_heap_head() {
self.perform_owner_lane_task_microtask_checkpoints()?;
self.sync_child_browsing_context_records();
@@ -826,10 +830,18 @@ impl ScriptVm {
self.document_runtime.ms_to_next_timeout()
}
+ #[cfg(test)]
pub(crate) fn has_ready_timeout(&self) -> bool {
self.document_runtime.has_ready_timeout()
}
+ pub(crate) fn next_ready_timeout_deadline(
+ &self,
+ selection: crate::page_task_queue::RendererPageTimerSelection,
+ ) -> Option<Instant> {
+ self.document_runtime.next_ready_timeout_deadline(selection)
+ }
+
pub(crate) fn next_timeout_deadline(&self) -> Option<Instant> {
self.document_runtime.next_timeout_deadline()
}
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs
index de405de02..7fddfd44c 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/idle_callbacks.rs
@@ -41,6 +41,40 @@ async fn idle_callback_timeout_is_a_deadline_not_a_dispatch_delay() {
);
}
+#[tokio::test]
+async fn idle_callback_does_not_overtake_queued_javascript_url_navigation() {
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
+ let mut vm = new_storage_page_task_executor_test_vm_with_loader(
+ "https://idle-after-javascript-url.test/",
+ &loader,
+ );
+ vm.eval(
+ r#"
+globalThis.__javascriptUrlIdleOrder = [];
+const frame = document.createElement("iframe");
+(document.body || document.documentElement || document).appendChild(frame);
+const child = frame.contentWindow;
+child.location.href =
+ "javascript:parent.__javascriptUrlIdleOrder.push('javascript-url')";
+child.requestIdleCallback(() => __javascriptUrlIdleOrder.push("idle"));
+"#,
+ )
+ .expect("javascript URL and idle callback should queue");
+ advance_page_task_executor_until_eval_equals(
+ &mut vm,
+ &loader,
+ "String(__javascriptUrlIdleOrder.length)",
+ "2",
+ "javascript URL must run before the page becomes idle",
+ )
+ .await;
+ assert_eq!(
+ vm.eval("__javascriptUrlIdleOrder.join('|')")
+ .expect("javascript URL idle order should evaluate"),
+ "javascript-url|idle"
+ );
+}
+
#[tokio::test]
async fn idle_deadline_declared_shape_keeps_state_private() {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
diff --git a/moli-time/src/timers.rs b/moli-time/src/timers.rs
index 86b7e32fe..087a39279 100644
--- a/moli-time/src/timers.rs
+++ b/moli-time/src/timers.rs
@@ -167,34 +167,12 @@ impl<T> TimerScheduler<T> {
&mut self,
now: Instant,
allowance: TimerReadyAllowance,
- mut predicate: F,
+ predicate: F,
) -> Option<ReadyTimer<T>>
where
F: FnMut(&T) -> bool,
{
- let mut first_non_ready = None;
- let mut selected = None;
- for timer in &self.pending {
- if !self.active.contains(&timer.id) {
- continue;
- }
- if !timer_ready(timer.run_at, timer.delay_ms, now, allowance) {
- if first_non_ready.is_none_or(|current| timer_precedes(timer, current)) {
- first_non_ready = Some(timer);
- }
- continue;
- }
- if predicate(&timer.payload)
- && selected.is_none_or(|current| timer_precedes(timer, current))
- {
- selected = Some(timer);
- }
- }
-
- let selected = selected?;
- if first_non_ready.is_some_and(|barrier| timer_precedes(barrier, selected)) {
- return None;
- }
+ let selected = self.next_ready_matching_timer(now, allowance, predicate)?;
let selected_id = selected.id;
let selected_sequence = selected.sequence;
@@ -266,6 +244,19 @@ impl<T> TimerScheduler<T> {
})
}
+ pub fn next_ready_deadline_matching<F>(
+ &self,
+ now: Instant,
+ allowance: TimerReadyAllowance,
+ predicate: F,
+ ) -> Option<Instant>
+ where
+ F: FnMut(&T) -> bool,
+ {
+ self.next_ready_matching_timer(now, allowance, predicate)
+ .map(|timer| timer.run_at)
+ }
+
pub fn next_deadline(&self) -> Option<Instant> {
self.pending
.iter()
@@ -312,6 +303,41 @@ impl<T> TimerScheduler<T> {
}
}
}
+
+ fn next_ready_matching_timer<F>(
+ &self,
+ now: Instant,
+ allowance: TimerReadyAllowance,
+ mut predicate: F,
+ ) -> Option<&ScheduledTimer<T>>
+ where
+ F: FnMut(&T) -> bool,
+ {
+ let mut first_non_ready = None;
+ let mut selected = None;
+ for timer in &self.pending {
+ if !self.active.contains(&timer.id) {
+ continue;
+ }
+ if !timer_ready(timer.run_at, timer.delay_ms, now, allowance) {
+ if first_non_ready.is_none_or(|current| timer_precedes(timer, current)) {
+ first_non_ready = Some(timer);
+ }
+ continue;
+ }
+ if predicate(&timer.payload)
+ && selected.is_none_or(|current| timer_precedes(timer, current))
+ {
+ selected = Some(timer);
+ }
+ }
+
+ let selected = selected?;
+ if first_non_ready.is_some_and(|barrier| timer_precedes(barrier, selected)) {
+ return None;
+ }
+ Some(selected)
+ }
}
fn timer_precedes<T>(left: &ScheduledTimer<T>, right: &ScheduledTimer<T>) -> bool {
@@ -440,6 +466,53 @@ mod tests {
scheduler.finish_running(ready.id);
}
+ #[test]
+ fn matching_ready_deadline_observes_selection_and_cancelled_timers() {
+ let now = Instant::now();
+ let mut scheduler = TimerScheduler::default();
+ let cancelled = scheduler.schedule_after("cancelled", 0, now);
+ scheduler.schedule_after("skipped", 0, now);
+ scheduler.schedule_after("selected", 1, now);
+ scheduler.cancel(cancelled);
+
+ assert_eq!(
+ scheduler
+ .next_ready_deadline_matching(now, TimerReadyAllowance::NONE, |payload| *payload
+ == "selected",),
+ None
+ );
+ assert_eq!(
+ scheduler.next_ready_deadline_matching(
+ now + Duration::from_millis(1),
+ TimerReadyAllowance::NONE,
+ |payload| *payload == "selected",
+ ),
+ Some(now + Duration::from_millis(1))
+ );
+ }
+
+ #[test]
+ fn matching_ready_deadline_respects_an_earlier_non_ready_barrier() {
+ let now = Instant::now();
+ let mut scheduler = TimerScheduler::default();
+ scheduler.schedule_after("barrier", 2, now);
+ scheduler.schedule_after("selected", 1, now + Duration::from_micros(1_500));
+ let allowance = TimerReadyAllowance {
+ max_delay_ms: 1,
+ allowance: Duration::from_millis(1),
+ };
+
+ assert_eq!(
+ scheduler.next_ready_deadline_matching(
+ now + Duration::from_micros(1_500),
+ allowance,
+ |payload| *payload == "selected",
+ ),
+ None,
+ "a later timer admitted by early allowance must not overtake the heap head"
+ );
+ }
+
#[test]
fn ms_to_next_rounds_future_submillisecond_deadline_up() {
let now = Instant::now();