Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(fonts): retain pending loads across promise chains

ldm0ac823a3eabca
diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs
index ce40e83b4..17b532725 100644
--- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs
+++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs
@@ -24,9 +24,9 @@ pub(super) fn load_matching_faces<'s>(
return promise;
}
let state = v8::Object::new(scope);
- // Reactions retain their state from the input promises, but the returned
- // promise must also retain it when a CSS face leaves document.fonts.
- // This heap edge keeps the settlement endpoints alive without a Global.
+ // Keep the direct promise's state in the JS heap as well. Native pending
+ // font loads root each face until completion or Window retirement, so a
+ // downstream .then()/await promise need not retain this original promise.
set_private_value(scope, promise.into(), QUERY_STATE, state.into());
set_private_value(scope, state, QUERY_RESOLVER, resolver.into());
set_private_value(scope, state, QUERY_FACES, faces.into());
@@ -199,10 +199,9 @@ pub(super) fn initialize_resolver<'s>(
request_context: Option<crate::native_bridge::WindowExecutionContextIdentity>,
) {
set_private_value(scope, face, RESOLVER, resolver.into());
- // A retained pending .loaded promise must retain its settlement endpoint,
- // including CSS-started loads with no explicit JS network request root.
- // Keep this edge in the JS heap so an otherwise unreachable cycle remains
- // collectible; no isolate-wide Global may keep a retired document alive.
+ // A retained pending .loaded promise also retains its settlement endpoint.
+ // Loading faces have a Window-owned native root, released on completion
+ // or retirement; unloaded JS-only cycles remain collectible.
set_private_value(
scope,
resolver.get_promise(scope).into(),
@@ -216,6 +215,9 @@ pub(super) fn initialize_resolver<'s>(
/// Only the observer layer creates JS errors, settles promises and dispatches
/// events. Native CSS completions update the same resource without touching V8.
fn publish_state<'s>(scope: &mut v8::PinScope<'s, '_>, face: v8::Local<'s, v8::Object>) {
+ // Synchronize before running any reentrant loading handler, including when
+ // rebinding replaced the resource without changing its published status.
+ super::state::sync_loading_root(scope, face);
let Some((previous, load)) = super::state::take_change(scope, face) else {
return;
};
diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs
index 5db03817f..3fc8d1369 100644
--- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs
+++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/state.rs
@@ -107,6 +107,41 @@ pub(super) fn request_context<'s>(
.request_context
}
+/// Native loading operations retain the wrapper, independently of which
+/// promise in a .then()/await chain page code keeps alive. Retired Windows
+/// cannot acquire new roots, and terminal resources release existing roots.
+pub(super) fn sync_loading_root<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ face: v8::Local<'s, v8::Object>,
+) {
+ let Some(id) = id(scope, face) else {
+ return;
+ };
+ let Some((loading, request_context)) = scope.get_slot::<Store>().and_then(|store| {
+ let store = store.borrow();
+ let observer = store.entries.get(&id)?;
+ Some((
+ observer.load.borrow().status() == FontFaceStatus::Loading,
+ observer.request_context,
+ ))
+ }) else {
+ return;
+ };
+ let Some(context) = face.get_creation_context(scope) else {
+ return;
+ };
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let Some(host_ptr) = crate::util::context_host_ptr_from_global_bridge(scope) else {
+ return;
+ };
+ let host = unsafe { &mut *host_ptr };
+ if let (true, Some(identity)) = (loading, request_context) {
+ host.retain_pending_font_face_load(scope, id, identity, face);
+ } else {
+ host.release_pending_font_face_load(id);
+ }
+}
+
pub(super) fn bind<'s>(
scope: &mut v8::PinScope<'s, '_>,
face: v8::Local<'s, v8::Object>,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs
index c6808ee11..3fc5bc759 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs
@@ -468,6 +468,7 @@ impl JsContextHost {
next_image_decode_id: 1,
pending_image_decode_requests: HashMap::new(),
resource_timing_buffers: SharedResourceTimingBufferRegistry::new(),
+ pending_font_face_loads: HashMap::new(),
next_webcrypto_task_id: crate::page_task_queue::RendererPageWebCryptoTaskId::first(),
pending_webcrypto_tasks: HashMap::new(),
opfs_owner_state: None,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/font_face_loads.rs b/moli-renderer-v8/src/native_bridge/context_host/font_face_loads.rs
new file mode 100644
index 000000000..e174d2494
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/context_host/font_face_loads.rs
@@ -0,0 +1,65 @@
+use super::{
+ JsContextHost, RuntimeObservableContextToken, WindowExecutionContextIdentity,
+ WindowExecutionContextOwner,
+};
+
+/// CSS-started requests do not carry a JS FontFace continuation. Keep their
+/// settlement endpoints alive even when page code retains only a derived
+/// promise. The creating Window owns these roots and retires them on teardown.
+pub(super) struct PendingFontFaceLoad {
+ execution_context: WindowExecutionContextIdentity,
+ _face: v8::Global<v8::Object>,
+}
+
+impl JsContextHost {
+ pub(crate) fn retain_pending_font_face_load(
+ &mut self,
+ scope: &mut v8::PinScope<'_, '_>,
+ id: u64,
+ execution_context: WindowExecutionContextIdentity,
+ face: v8::Local<'_, v8::Object>,
+ ) {
+ if !self.window_execution_context_identity_is_current(execution_context) {
+ self.pending_font_face_loads.remove(&id);
+ return;
+ }
+ self.pending_font_face_loads
+ .entry(id)
+ .or_insert_with(|| PendingFontFaceLoad {
+ execution_context,
+ _face: v8::Global::new(scope, face),
+ });
+ }
+
+ pub(crate) fn release_pending_font_face_load(&mut self, id: u64) {
+ self.pending_font_face_loads.remove(&id);
+ }
+
+ pub(crate) fn retire_font_face_loads_for_context_token(
+ &mut self,
+ token: RuntimeObservableContextToken,
+ ) -> usize {
+ let before = self.pending_font_face_loads.len();
+ self.pending_font_face_loads
+ .retain(|_, pending| pending.execution_context.realm_token() != token);
+ before - self.pending_font_face_loads.len()
+ }
+
+ pub(crate) fn retire_font_face_loads_for_execution_context_owner(
+ &mut self,
+ owner: WindowExecutionContextOwner,
+ ) {
+ self.pending_font_face_loads
+ .retain(|_, pending| pending.execution_context.owner() != owner);
+ }
+
+ #[cfg(test)]
+ pub(crate) fn pending_font_face_execution_contexts_for_test(
+ &self,
+ ) -> Vec<WindowExecutionContextIdentity> {
+ self.pending_font_face_loads
+ .values()
+ .map(|pending| pending.execution_context)
+ .collect()
+ }
+}
diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
index 764b80051..127fe4456 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
@@ -147,6 +147,7 @@ mod security_policy;
mod selection_records;
mod service_workers;
pub(crate) use service_workers::ServiceWorkerWindowOwner;
+mod font_face_loads;
mod shared_workers;
mod signal_bridge;
mod storage_events;
@@ -942,6 +943,7 @@ pub(crate) struct JsContextHost {
next_image_decode_id: u64,
pending_image_decode_requests: HashMap<ImageDecodeRequestId, PendingImageDecodeRequest>,
resource_timing_buffers: SharedResourceTimingBufferRegistry,
+ pending_font_face_loads: HashMap<u64, font_face_loads::PendingFontFaceLoad>,
next_webcrypto_task_id: crate::page_task_queue::RendererPageWebCryptoTaskId,
pending_webcrypto_tasks: HashMap<
crate::page_task_queue::RendererPageWebCryptoTaskId,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs
index 9d8bd9f13..39f9c0717 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs
@@ -112,6 +112,7 @@ impl JsContextHost {
let bindings = self.retire_runtime_binding_context_token(realm_token);
let images = self.retire_image_decode_requests_for_context_token(realm_token);
let crypto = self.retire_webcrypto_context_token(realm_token);
+ let fonts = self.retire_font_face_loads_for_context_token(realm_token);
self.retire_opfs_context_token(realm_token);
let workers = self.retire_workers_for_context_token(realm_token);
let shared_workers = self.disconnect_shared_worker_clients_for_context_token(realm_token);
@@ -128,6 +129,7 @@ impl JsContextHost {
bindings = bindings.retired_execution_context_count(),
images,
crypto,
+ fonts,
workers,
shared_workers,
xhrs,
@@ -208,6 +210,7 @@ impl JsContextHost {
drop(std::mem::take(&mut self.misc_platform_api_tasks));
drop(std::mem::take(&mut self.file_entry_file_callbacks));
drop(std::mem::take(&mut self.user_interaction_tasks));
+ self.pending_font_face_loads.clear();
self.pending_image_load_events.clear();
self.pending_media_load_sequences.clear();
self.pending_text_track_load_sequences.clear();
@@ -512,6 +515,7 @@ impl JsContextHost {
&mut self,
owner: WindowExecutionContextOwner,
) -> bool {
+ self.retire_font_face_loads_for_execution_context_owner(owner);
self.retire_event_callbacks_for_execution_context(owner);
crate::observer_runtime::retire_execution_context_owner(self, owner);
let retired = self.window_execution_contexts.remove(&owner);
@@ -543,6 +547,7 @@ impl JsContextHost {
&mut self,
context_token: RuntimeObservableContextToken,
) -> usize {
+ self.retire_font_face_loads_for_context_token(context_token);
crate::observer_runtime::retire_context_token(self, context_token);
let indexed_db_retirement = self.retire_indexed_db_context(context_token);
let retired_indexed_db_connections = indexed_db_retirement.retired_connections.len();
@@ -592,6 +597,7 @@ impl JsContextHost {
&mut self,
context_token: RuntimeObservableContextToken,
) -> usize {
+ self.retire_font_face_loads_for_context_token(context_token);
crate::observer_runtime::retire_context_token(self, context_token);
let indexed_db_retirement = self.retire_indexed_db_context(context_token);
indexed_db_retirement.finish(self.indexed_db_manager.as_ref());
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs
index 88cda365d..be728e227 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs
@@ -308,8 +308,16 @@ async fn assert_loaded_promise_lifetime(mode: &str) {
// FontFace.load(), which installs a separate strong request root.
vm.refresh_layout_snapshot_for_test(moli_layout::LayoutViewport::new(800, 600, 1.0))
.unwrap();
- let query_promise = if mode.contains("query") {
+ let query_promise = if mode.contains("query-then") {
+ "document.fonts.load('16px Lifetime','A').then(faces => faces)"
+ } else if mode.contains("query-await") {
+ "(async () => await document.fonts.load('16px Lifetime','A'))()"
+ } else if mode.contains("query") {
"document.fonts.load('16px Lifetime','A')"
+ } else if mode.contains("loaded-then") {
+ "face.loaded.then(face => face)"
+ } else if mode.contains("loaded-await") {
+ "(async () => await face.loaded)()"
} else {
"face.loaded"
};
@@ -356,6 +364,38 @@ async fn assert_loaded_promise_lifetime(mode: &str) {
.pending_subresource_request_count(),
1
);
+ let pending_contexts = vm
+ ._context_host
+ .borrow()
+ .pending_font_face_execution_contexts_for_test();
+ assert_eq!(
+ pending_contexts.len(),
+ 1,
+ "{mode}: native load must root its face"
+ );
+ let execution_context = pending_contexts[0];
+ let retired = mode.contains("retire-");
+ if retired {
+ let mut host = vm._context_host.borrow_mut();
+ if mode.ends_with("retire-realm") {
+ host.retire_window_realm_resources(execution_context.realm_token());
+ } else if mode.ends_with("retire-owner") {
+ assert!(host.retire_window_execution_context(execution_context.owner()));
+ } else if mode.ends_with("retire-context") {
+ assert_eq!(
+ host.retire_window_execution_contexts_for_context_token(
+ execution_context.realm_token()
+ ),
+ 1
+ );
+ } else {
+ panic!("unknown retirement mode {mode}");
+ }
+ assert!(
+ host.pending_font_face_execution_contexts_for_test()
+ .is_empty()
+ );
+ }
// Every vm.eval HandleScope above has exited. Clear WeakRef's job-local
// keepalive before forcing full GC so the witness cannot root the face.
if mode != "css-removed-no-gc" {
@@ -370,11 +410,14 @@ async fn assert_loaded_promise_lifetime(mode: &str) {
}
assert_eq!(
vm.eval("faceWitness.deref()===undefined").unwrap(),
- "false",
- "a retained .loaded promise must keep the loading wrapper alive"
+ if retired { "true" } else { "false" },
+ "{mode}: active loads must keep settlement endpoints alive, retired Windows must release them"
);
gates.remove("lifetime.woff2").unwrap().send(()).unwrap();
server.await.unwrap();
+ if retired {
+ return;
+ }
assert!(
tokio::time::timeout(
Duration::from_secs(2),
@@ -395,6 +438,13 @@ async fn assert_loaded_promise_lifetime(mode: &str) {
.pending_subresource_request_count(),
0
);
+ assert!(
+ vm._context_host
+ .borrow()
+ .pending_font_face_execution_contexts_for_test()
+ .is_empty(),
+ "{mode}: terminal loads must release their native roots"
+ );
let results = vm.eval("JSON.stringify(promiseResults)").unwrap();
assert_eq!(
results,
@@ -403,7 +453,7 @@ async fn assert_loaded_promise_lifetime(mode: &str) {
} else {
r#"[["Lifetime","loaded"]]"#
},
- "{mode}: retaining .loaded must preserve its settlement endpoint"
+ "{mode}: retaining the promise chain must preserve its settlement endpoint"
);
// A fulfilled promise necessarily retains its FontFace result. A rejected
// promise must release the wrapper even while that promise remains live.
@@ -442,6 +492,61 @@ async fn css_removed_rejected_query_promise_releases_wrapper_after_gc() {
assert_loaded_promise_lifetime("css-removed-query-error").await;
}
+#[tokio::test]
+async fn css_removed_query_then_promise_survives_gc() {
+ assert_loaded_promise_lifetime("css-removed-query-then-gc").await;
+}
+
+#[tokio::test]
+async fn css_removed_rejected_query_then_promise_releases_wrapper_after_gc() {
+ assert_loaded_promise_lifetime("css-removed-query-then-error").await;
+}
+
+#[tokio::test]
+async fn css_removed_query_await_promise_survives_gc() {
+ assert_loaded_promise_lifetime("css-removed-query-await-gc").await;
+}
+
+#[tokio::test]
+async fn css_removed_rejected_query_await_promise_releases_wrapper_after_gc() {
+ assert_loaded_promise_lifetime("css-removed-query-await-error").await;
+}
+
+#[tokio::test]
+async fn css_removed_loaded_then_promise_survives_gc() {
+ assert_loaded_promise_lifetime("css-removed-loaded-then-gc").await;
+}
+
+#[tokio::test]
+async fn css_removed_rejected_loaded_then_promise_releases_wrapper_after_gc() {
+ assert_loaded_promise_lifetime("css-removed-loaded-then-error").await;
+}
+
+#[tokio::test]
+async fn css_removed_loaded_await_promise_survives_gc() {
+ assert_loaded_promise_lifetime("css-removed-loaded-await-gc").await;
+}
+
+#[tokio::test]
+async fn css_removed_rejected_loaded_await_promise_releases_wrapper_after_gc() {
+ assert_loaded_promise_lifetime("css-removed-loaded-await-error").await;
+}
+
+#[tokio::test]
+async fn css_removed_query_chain_releases_wrapper_on_realm_retirement() {
+ assert_loaded_promise_lifetime("css-removed-query-then-retire-realm").await;
+}
+
+#[tokio::test]
+async fn css_removed_query_chain_releases_wrapper_on_owner_retirement() {
+ assert_loaded_promise_lifetime("css-removed-query-await-retire-owner").await;
+}
+
+#[tokio::test]
+async fn css_removed_query_chain_releases_wrapper_on_context_retirement() {
+ assert_loaded_promise_lifetime("css-removed-query-then-retire-context").await;
+}
+
#[tokio::test]
async fn css_removed_loaded_promise_without_forced_gc() {
assert_loaded_promise_lifetime("css-removed-no-gc").await;