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): trace response body handles on realm teardown

ldm0cd2cbc8541a4
diff --git a/moli-renderer-v8/src/native_bridge/identity.rs b/moli-renderer-v8/src/native_bridge/identity.rs
index 24adaa79a..d87528380 100644
--- a/moli-renderer-v8/src/native_bridge/identity.rs
+++ b/moli-renderer-v8/src/native_bridge/identity.rs
@@ -590,6 +590,10 @@ pub(crate) fn clear_context_wrapper_cache_for_teardown(
}
crate::context_bootstrap::exposed_interfaces::retain_intrinsic_interfaces_in_realm(scope);
crate::context_bootstrap::retain_indexed_db_state_in_retired_realm(scope);
+ crate::network_host::retain_pending_network_body_state_in_retired_realm(
+ scope,
+ include_shared_default_world,
+ );
}
#[derive(Debug, Default)]
diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs
index f2c85c135..70344c9ff 100644
--- a/moli-renderer-v8/src/network_host.rs
+++ b/moli-renderer-v8/src/network_host.rs
@@ -63,7 +63,7 @@ pub(crate) use self::body_source::{
PendingNetworkBodySourceState, close_pending_network_body_stream,
enqueue_pending_network_body_chunk, error_pending_network_body_stream,
error_pending_network_body_stream_with_reason, new_network_body_source_id,
- pending_network_body_stream,
+ pending_network_body_stream, retain_pending_network_body_state_in_retired_realm,
};
pub(in crate::network_host) use self::browser_response::http_status_text;
pub(crate) use self::browser_response::{
diff --git a/moli-renderer-v8/src/network_host/body_source.rs b/moli-renderer-v8/src/network_host/body_source.rs
index dd52105e8..f28aec8b4 100644
--- a/moli-renderer-v8/src/network_host/body_source.rs
+++ b/moli-renderer-v8/src/network_host/body_source.rs
@@ -4,7 +4,7 @@ use crate::context_bootstrap::{
};
use crate::protocol_types::SubresourceResponseBody;
use crate::types::NetworkBodySourceId;
-use crate::util::{get_private_value, set_private_value};
+use crate::util::{RealmObjectHandle, RealmValueHandle, get_private_value, set_private_value};
use crate::web_api_interfaces;
use crate::worker::get_worker_state;
use std::collections::{HashMap, HashSet};
@@ -244,7 +244,7 @@ enum PendingBodyMaterializationKind {
}
pub(crate) struct PendingBodyMaterialization {
- resolver: v8::Global<v8::PromiseResolver>,
+ resolver: RealmObjectHandle,
kind: PendingBodyMaterializationKind,
}
@@ -261,10 +261,52 @@ pub(crate) struct PendingNetworkBodySourceState {
pull_requested: bool,
closed: bool,
error: Option<String>,
- error_reason: Option<v8::Global<v8::Value>>,
+ error_reason: Option<RealmValueHandle>,
materializations: Vec<PendingBodyMaterialization>,
}
+pub(crate) fn retain_pending_network_body_state_in_retired_realm(
+ scope: &mut v8::PinScope<'_, '_>,
+ include_shared_default_world: bool,
+) {
+ let context = scope.get_current_context();
+ let Some(host) = context_host_mut(scope) else {
+ return;
+ };
+ // Retained Responses keep their buffered bytes and error identity. Their
+ // native body state must not in turn root the retired realm through a
+ // pending body-method resolver or stored JavaScript rejection reason.
+ for state in host.pending_network_body_sources.values_mut() {
+ for materialization in &mut state.materializations {
+ if include_shared_default_world
+ || materialization
+ .resolver
+ .to_local(scope)
+ .and_then(|resolver| resolver.get_creation_context(scope))
+ == Some(context)
+ {
+ materialization.resolver.retain_in_realm(scope);
+ }
+ }
+ let stream_context = state
+ .stream
+ .to_local(scope)
+ .and_then(|stream| stream.get_creation_context(scope));
+ if (include_shared_default_world || stream_context == Some(context))
+ && let Some(reason) = &mut state.error_reason
+ {
+ // A shared native host can own body state from several realms.
+ // Anchor the reason in the stream's realm, even during main teardown.
+ if let Some(stream_context) = stream_context {
+ let scope = &mut v8::ContextScope::new(scope, stream_context);
+ reason.retain_in_realm(scope);
+ } else {
+ reason.retain_in_realm(scope);
+ }
+ }
+ }
+}
+
enum PendingBodyRejection {
Reason(v8::Global<v8::Value>),
Message(String),
@@ -907,7 +949,7 @@ fn error_pending_network_body_stream_with_clone_ids<'s>(
}
state.closed = true;
state.error = Some(error_text.to_owned());
- state.error_reason = Some(v8::Global::new(scope, reason));
+ state.error_reason = Some(RealmValueHandle::new(scope, reason));
if let Some(stream) = state.stream.to_local(scope) {
error_stream(scope, stream, reason);
}
@@ -926,7 +968,7 @@ fn error_pending_network_body_stream_with_clone_ids<'s>(
}
clone.closed = true;
clone.error = Some(error_text.to_owned());
- clone.error_reason = Some(v8::Global::new(scope, reason));
+ clone.error_reason = Some(RealmValueHandle::new(scope, reason));
if let Some(stream) = clone.stream.to_local(scope) {
error_stream(scope, stream, reason);
}
@@ -1199,10 +1241,10 @@ fn clone_pending_network_body_source_in_maps(
let snapshot = original.bytes.clone();
outcome.close_now = original.closed;
outcome.error_now = original.error.clone();
- outcome.error_reason_now = original
- .error_reason
- .as_ref()
- .map(|reason| v8::Global::new(scope, v8::Local::new(scope, reason)));
+ outcome.error_reason_now = original.error_reason.as_ref().map(|reason| {
+ let reason = reason.to_local(scope);
+ v8::Global::new(scope, reason)
+ });
if let Some(clone) = sources.get_mut(&clone_id) {
append_pending_body_state_bytes(scope, clone, &snapshot);
}
@@ -1513,10 +1555,8 @@ fn inspect_pending_body_source_for_materialization<'s>(
.error_reason
.as_ref()
.map(|reason| {
- PendingBodyRejection::Reason(v8::Global::new(
- scope,
- v8::Local::new(scope, reason),
- ))
+ let reason = reason.to_local(scope);
+ PendingBodyRejection::Reason(v8::Global::new(scope, reason))
})
.unwrap_or(PendingBodyRejection::Message(error_text)),
);
@@ -1526,7 +1566,7 @@ fn inspect_pending_body_source_for_materialization<'s>(
sources.remove(&id);
} else {
state.materializations.push(PendingBodyMaterialization {
- resolver: v8::Global::new(scope, resolver),
+ resolver: RealmObjectHandle::new(scope, resolver.into()),
kind,
});
}
@@ -1770,7 +1810,11 @@ fn resolve_pending_body_materializations(
let mut bytes: Vec<u8> = take_pending_network_body_source_bytes(scope, id).unwrap_or_default();
let materialization_count = materializations.len();
for (index, materialization) in materializations.into_iter().enumerate() {
- let resolver = v8::Local::new(scope, &materialization.resolver);
+ let Some(resolver) = materialization.resolver.to_local(scope) else {
+ continue;
+ };
+ // The private handle is populated only from a PromiseResolver.
+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(resolver) };
// Most body sources have exactly one pending materialization. Move the
// completed buffer into that consumer and clone only when fan-out is
// actually needed.
@@ -1808,7 +1852,11 @@ fn reject_pending_body_materializations_with_reason<'s>(
reason: v8::Local<'s, v8::Value>,
) {
for materialization in materializations {
- let resolver = v8::Local::new(scope, &materialization.resolver);
+ let Some(resolver) = materialization.resolver.to_local(scope) else {
+ continue;
+ };
+ // The private handle is populated only from a PromiseResolver.
+ let resolver = unsafe { v8::Local::<v8::PromiseResolver>::cast_unchecked(resolver) };
let _ = resolver.reject(scope, reason);
}
}
diff --git a/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs b/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs
index 994db8ad5..c8f410e25 100644
--- a/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs
+++ b/moli-renderer-v8/src/script_vm/tests/extracted/realms_and_teardown.rs
@@ -1,5 +1,223 @@
use super::*;
+fn new_vm_with_pending_response_for_teardown_test()
+-> (StandaloneScriptVmHarness, crate::types::NetworkBodySourceId) {
+ let mut vm = new_storage_test_vm("https://body-teardown.test/");
+ let body_source_id = crate::network_host::new_network_body_source_id();
+ let document_url = vm.document_runtime.document_url().clone();
+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {
+ let response =
+ crate::network_host::build_fetch_response_object_from_stream_for_request_mode(
+ scope,
+ &document_url,
+ moli_fetch::RequestMode::Cors,
+ moli_fetch::ResponseHead {
+ final_url: document_url.join("data.json").unwrap(),
+ status: 200,
+ headers: vec![("content-type".to_owned(), b"application/json".to_vec())],
+ request_cookie_report: None,
+ cookie_set_reports: Vec::new(),
+ redirected: false,
+ redirect_chain: Vec::new(),
+ from_cache: false,
+ negotiated_http_version: None,
+ },
+ body_source_id,
+ );
+ let global = scope.get_current_context().global(scope);
+ let _ = global.set(
+ scope,
+ crate::util::v8str(scope, "response").into(),
+ response.into(),
+ );
+ Ok(())
+ })
+ .expect("pending Response should be installed");
+ (vm, body_source_id)
+}
+
+fn error_response_for_teardown_test(
+ vm: &mut StandaloneScriptVmHarness,
+ body_source_id: crate::types::NetworkBodySourceId,
+) {
+ vm.eval("globalThis.bodyFailure = new Error('body failed')")
+ .unwrap();
+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {
+ let global = scope.get_current_context().global(scope);
+ let reason = global
+ .get(scope, crate::util::v8str(scope, "bodyFailure").into())
+ .unwrap();
+ crate::network_host::error_pending_network_body_stream_with_reason(
+ scope,
+ body_source_id,
+ "body failed".to_owned(),
+ reason,
+ );
+ Ok(())
+ })
+ .expect("pending Response should retain its rejection reason");
+}
+
+#[test]
+fn pending_response_body_releases_native_host_on_context_teardown() {
+ let (mut vm, _) = new_vm_with_pending_response_for_teardown_test();
+ vm.eval("globalThis.bodyPromise = response.json(); 1")
+ .expect("body materialization should wait for network completion");
+ let weak_host = vm.context_host_weak_for_test();
+ let isolate = vm.renderer_document_isolate.clone();
+ drop(vm);
+ for _ in 0..2 {
+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ }
+ assert!(
+ weak_host.upgrade().is_none(),
+ "a pending body resolver must not root its retired native Document"
+ );
+}
+
+#[test]
+fn errored_response_body_releases_native_host_on_context_teardown() {
+ let (mut vm, body_source_id) = new_vm_with_pending_response_for_teardown_test();
+ error_response_for_teardown_test(&mut vm, body_source_id);
+ let weak_host = vm.context_host_weak_for_test();
+ let isolate = vm.renderer_document_isolate.clone();
+ drop(vm);
+ for _ in 0..2 {
+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ }
+ assert!(
+ weak_host.upgrade().is_none(),
+ "a stored body error must not root its retired native Document"
+ );
+}
+
+#[test]
+fn retained_response_body_keeps_bytes_until_the_last_v8_reference() {
+ for pending in [false, true] {
+ let (mut vm, body_source_id) = new_vm_with_pending_response_for_teardown_test();
+ vm.with_default_context_scope_and_checkpoint_for_test(|scope, _| {
+ crate::network_host::enqueue_pending_network_body_chunk(
+ scope,
+ body_source_id,
+ br#"{"ok":true}"#.to_vec(),
+ );
+ if !pending {
+ crate::network_host::close_pending_network_body_stream(scope, body_source_id);
+ }
+ Ok(())
+ })
+ .unwrap();
+ vm.eval(if pending {
+ "globalThis.bodyPromise = response.text(); globalThis.readBody = () => bodyPromise"
+ } else {
+ "globalThis.readBody = () => response.text()"
+ })
+ .unwrap();
+ let isolate = vm.renderer_document_isolate.clone();
+ let callback = isolate.with_renderer_document_isolate_mut(|isolate| {
+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));
+ let scope = &mut scope.init();
+ let context = v8::Local::new(scope, &vm.page_default_context);
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let value = context
+ .global(scope)
+ .get(scope, crate::util::v8str(scope, "readBody").into())
+ .unwrap();
+ let function = v8::Local::<v8::Function>::try_from(value).unwrap();
+ v8::Global::new(scope, function)
+ });
+ let weak_host = vm.context_host_weak_for_test();
+ drop(vm);
+ for _ in 0..2 {
+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ }
+ assert!(weak_host.upgrade().is_some());
+ let value = isolate.with_renderer_document_isolate_mut(|isolate| {
+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));
+ let scope = &mut scope.init();
+ let caller_context = v8::Context::new(scope, Default::default());
+ let scope = &mut v8::ContextScope::new(scope, caller_context);
+ let function = v8::Local::new(scope, &callback);
+ let context = function.get_creation_context(scope).unwrap();
+ let scope = &mut v8::ContextScope::new(scope, context);
+ if pending {
+ crate::network_host::close_pending_network_body_stream(scope, body_source_id);
+ }
+ let receiver = v8::undefined(scope).into();
+ let value = crate::script_execution::call_function(scope, function, receiver, &[])
+ .expect("retained Response body should remain readable");
+ let promise = v8::Local::<v8::Promise>::try_from(value).unwrap();
+ assert_eq!(promise.state(), v8::PromiseState::Fulfilled);
+ promise.result(scope).to_rust_string_lossy(scope)
+ });
+ assert_eq!(value, r#"{"ok":true}"#);
+ isolate.with_renderer_document_isolate_mut(|isolate| {
+ drop(callback);
+ isolate.low_memory_notification();
+ });
+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ assert!(
+ weak_host.upgrade().is_none(),
+ "releasing the body reader must release its retired native Document"
+ );
+ }
+}
+
+#[test]
+fn retained_response_body_keeps_error_reason_until_the_last_v8_reference() {
+ let (mut vm, body_source_id) = new_vm_with_pending_response_for_teardown_test();
+ error_response_for_teardown_test(&mut vm, body_source_id);
+ vm.eval("globalThis.readBody = () => response.text()")
+ .unwrap();
+ let isolate = vm.renderer_document_isolate.clone();
+ let callback = isolate.with_renderer_document_isolate_mut(|isolate| {
+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));
+ let scope = &mut scope.init();
+ let context = v8::Local::new(scope, &vm.page_default_context);
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let value = context
+ .global(scope)
+ .get(scope, crate::util::v8str(scope, "readBody").into())
+ .unwrap();
+ let function = v8::Local::<v8::Function>::try_from(value).unwrap();
+ v8::Global::new(scope, function)
+ });
+ let weak_host = vm.context_host_weak_for_test();
+ drop(vm);
+ for _ in 0..2 {
+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ }
+ assert!(weak_host.upgrade().is_some());
+ isolate.with_renderer_document_isolate_mut(|isolate| {
+ let scope = std::pin::pin!(v8::HandleScope::new(isolate));
+ let scope = &mut scope.init();
+ let caller_context = v8::Context::new(scope, Default::default());
+ let scope = &mut v8::ContextScope::new(scope, caller_context);
+ let function = v8::Local::new(scope, &callback);
+ let context = function.get_creation_context(scope).unwrap();
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let receiver = v8::undefined(scope).into();
+ let value = crate::script_execution::call_function(scope, function, receiver, &[])
+ .expect("retained Response should preserve its body error");
+ let promise = v8::Local::<v8::Promise>::try_from(value).unwrap();
+ assert_eq!(promise.state(), v8::PromiseState::Rejected);
+ let reason = context
+ .global(scope)
+ .get(scope, crate::util::v8str(scope, "bodyFailure").into())
+ .unwrap();
+ assert!(promise.result(scope).strict_equals(reason));
+ });
+ isolate.with_renderer_document_isolate_mut(|isolate| {
+ drop(callback);
+ isolate.low_memory_notification();
+ });
+ isolate.with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ assert!(
+ weak_host.upgrade().is_none(),
+ "releasing the body reader must release its retired native Document"
+ );
+}
+
fn new_vm_with_evaluated_module_for_teardown_test() -> StandaloneScriptVmHarness {
let mut vm = new_storage_test_vm("https://module-teardown.test/");
let url = vm.document_runtime.document_url().clone();