Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(fetch): preserve RequestInit conversion exceptions

ldm0bc64742a6efd
diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs
index 54363283a..b0722c462 100644
--- a/moli-renderer-v8/src/network_host.rs
+++ b/moli-renderer-v8/src/network_host.rs
@@ -123,6 +123,7 @@ pub(crate) use self::media::{
start_media_element_resource_fetch,
};
pub(in crate::network_host) use self::preflight_events::CorsPreflightNetworkObserver;
+pub(crate) use self::request::convert_fetch_arguments;
pub(in crate::network_host) use self::request::normalize_request_method;
pub(crate) use self::request::request_constructor_callback;
pub(crate) use self::request::{
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rs
index 0b9bde8bd..fd9460031 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs
@@ -151,26 +151,21 @@ pub(crate) fn window_fetch_callback<'s>(
// caller's realm is still current. Besides choosing the right realm for
// conversion failures, this permits getters to run; the frozen receiver
// is revalidated only after all such author code has completed.
- let mut parsed = match parse_window_fetch_input(scope, &args) {
+ let (mut parsed, signal) = match convert_fetch_arguments(scope, |scope| {
+ let parsed = parse_window_fetch_input(scope, &args)?;
+ let signal = window_fetch_signal_value(scope, &args)?
+ .map(|value| validate_window_fetch_signal(scope, unsafe { &mut *host_ptr }, value))
+ .transpose()?
+ .flatten()
+ .map(|signal| v8::Global::new(scope, signal));
+ Ok((parsed, signal))
+ }) {
Ok(parsed) => parsed,
- Err(message) => {
- rv.set(make_rejected_promise(scope, &message).into());
+ Err(exception) => {
+ rv.set(make_rejected_promise_with_value(scope, exception).into());
return;
}
};
- let signal_value = window_fetch_signal_value(scope, &args);
- let signal = match signal_value {
- Some(value) => {
- match validate_window_fetch_signal(scope, unsafe { &mut *host_ptr }, value) {
- Ok(signal) => signal,
- Err(message) => {
- rv.set(make_rejected_promise(scope, &message).into());
- return;
- }
- }
- }
- None => None,
- };
let Some(binding) = receiver.resolve_live_binding(unsafe { &*host_ptr }) else {
// This also catches the subtle generation race where a RequestInit
@@ -190,7 +185,6 @@ pub(crate) fn window_fetch_callback<'s>(
mark_request_input_body_used_for_fetch(scope, request_body_owner);
}
let fetch_context = crate::native_bridge::WindowFetchContext::from_realm(binding);
- let signal = signal.map(|signal| v8::Global::new(scope, signal));
let relevant_context = {
let context = fetch_context.script_realm().context(scope);
v8::Global::new(scope, context)
@@ -359,18 +353,23 @@ fn window_fetch_callback_in_relevant_realm<'s>(
fn window_fetch_signal_value<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
-) -> Option<v8::Local<'s, v8::Value>> {
+) -> Result<Option<v8::Local<'s, v8::Value>>, String> {
let signal_key = v8str(scope, "signal");
if args.length() > 1 {
let init_arg = args.get(1);
if !init_arg.is_null_or_undefined()
&& let Ok(init) = v8::Local::<v8::Object>::try_from(init_arg)
- && init.has(scope, signal_key.into()).unwrap_or(false)
+ && init
+ .has(scope, signal_key.into())
+ .ok_or("Failed to read RequestInit.signal")?
{
- let value = init
- .get(scope, signal_key.into())
- .unwrap_or_else(|| v8::undefined(scope).into());
- return Some(value);
+ return crate::webidl::property_result(
+ scope,
+ init,
+ "signal",
+ crate::webidl::Context::member("RequestInit", "signal"),
+ )
+ .map_err(|error| error.to_string());
}
}
@@ -378,12 +377,17 @@ fn window_fetch_signal_value<'s>(
if !request_like.is_null_or_undefined()
&& request_like.is_object()
&& let Ok(request_like) = v8::Local::<v8::Object>::try_from(request_like)
- && let Some(value) = request_like.get(scope, signal_key.into())
{
- return Some(value);
+ return crate::webidl::property_result(
+ scope,
+ request_like,
+ "signal",
+ crate::webidl::Context::member("Request", "signal"),
+ )
+ .map_err(|error| error.to_string());
}
- None
+ Ok(None)
}
fn validate_window_fetch_signal<'s>(
diff --git a/moli-renderer-v8/src/network_host/request.rs b/moli-renderer-v8/src/network_host/request.rs
index 5d69b7d75..645e2f00e 100644
--- a/moli-renderer-v8/src/network_host/request.rs
+++ b/moli-renderer-v8/src/network_host/request.rs
@@ -8,6 +8,7 @@ use super::headers::{
use super::*;
pub(crate) use self::bindings::request_constructor_callback;
+pub(crate) use self::init::convert_fetch_arguments;
pub(in crate::network_host) use self::init::request_credentials_mode_label;
pub(crate) use self::init::{parse_fetch_init, request_object_credentials_mode};
pub(crate) use self::init::{parse_request_redirect_mode_label, request_redirect_mode_label};
diff --git a/moli-renderer-v8/src/network_host/request/init.rs b/moli-renderer-v8/src/network_host/request/init.rs
index 0e42573ba..6e24cd534 100644
--- a/moli-renderer-v8/src/network_host/request/init.rs
+++ b/moli-renderer-v8/src/network_host/request/init.rs
@@ -4,6 +4,30 @@ use crate::webidl;
use moli_fetch::{FetchPriorityHint, RequestCredentialsMode, RequestMode, RequestRedirectMode};
use std::str::FromStr;
+/// Fetch rejects with the original conversion exception, including primitive
+/// values. Keep the catch boundary around argument conversion, before a body
+/// is consumed or any request is dispatched.
+pub(crate) fn convert_fetch_arguments<'s, T>(
+ scope: &mut v8::PinScope<'s, '_>,
+ convert: impl FnOnce(&mut v8::PinScope<'s, '_>) -> Result<T, String>,
+) -> Result<T, v8::Local<'s, v8::Value>> {
+ let try_catch = std::pin::pin!(v8::TryCatch::new(scope));
+ let mut conversion_scope = try_catch.init();
+ let result = convert(&mut conversion_scope);
+ if conversion_scope.has_caught() {
+ let exception = conversion_scope
+ .exception()
+ .unwrap_or_else(|| v8::undefined(&conversion_scope).into());
+ conversion_scope.reset();
+ return Err(exception);
+ }
+ result.map_err(|message| {
+ crate::util::v8_string(&conversion_scope, &message)
+ .map(|message| v8::Exception::type_error(&conversion_scope, message))
+ .unwrap_or_else(|| v8::undefined(&conversion_scope).into())
+ })
+}
+
#[derive(Debug, Clone)]
pub(crate) struct ParsedFetchInit {
pub(crate) method: String,
@@ -96,9 +120,15 @@ fn request_init_headers_member<'s>(
object: v8::Local<'s, v8::Object>,
_key: &str,
) -> Result<Option<Vec<(String, String)>>, webidl::WebIdlError> {
- webidl::property_non_nullish(scope, object, "headers")
- .map(|headers| headers_entries_from_init(scope, headers).map(Some))
- .unwrap_or(Ok(None))
+ webidl::property_result(
+ scope,
+ object,
+ "headers",
+ webidl::Context::member("RequestInit", "headers"),
+ )?
+ .filter(|value| !value.is_null_or_undefined())
+ .map(|headers| headers_entries_from_init(scope, headers).map(Some))
+ .unwrap_or(Ok(None))
}
pub(crate) fn parse_fetch_init<'s>(
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs
index a1a15a84f..b5ca6c122 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/fetch_xhr.rs
@@ -7072,3 +7072,70 @@ async fn blob_url_revocation_uses_window_and_worker_creator_storage_keys() {
}
}).await;
}
+
+#[tokio::test]
+async fn request_init_exceptions_preserve_identity_without_fetching_or_consuming_input() {
+ run_page_vm_async_test(async move {
+ for worker in [false, true] {
+ let mut page_vm = test_page_vm();
+ let local_executor = page_vm.local_executor.clone();
+ let probe = r#"(async () => {
+ const check = (value, message) => { if (!value) throw new Error(message); };
+ const url = 'data:text/plain,must-not-fetch';
+ for (const api of ['Request', 'fetch']) {
+ for (const member of ['method', 'headers', 'signal']) {
+ for (const sentinel of [undefined, null, false, 0, 'sentinel', {}, new Error('sentinel')]) {
+ const input = new Request(url, {method:'POST', body:'kept'});
+ const init = {};
+ Object.defineProperty(init, member, {get() { throw sentinel; }});
+ let result, caught, threw = false;
+ try { result = api === 'Request' ? new Request(input, init) : fetch(input, init); }
+ catch (error) { threw = true; caught = error; }
+ if (api === 'Request') {
+ check(threw && Object.is(caught, sentinel), 'Request must rethrow ' + member);
+ } else {
+ check(!threw && result instanceof Promise, 'fetch conversion must return a Promise');
+ let rejected = false;
+ await result.then(() => {}, error => { rejected = true; caught = error; });
+ check(rejected && Object.is(caught, sentinel), 'fetch must reject with original ' + member);
+ }
+ check(!input.bodyUsed, 'failed ' + member + ' conversion consumed input body');
+ }
+ }
+ }
+ if (typeof document !== 'undefined') {
+ const frame = document.createElement('iframe');
+ document.body.appendChild(frame);
+ const other = frame.contentWindow;
+ const sentinel = new other.Error('cross-realm');
+ const promise = other.fetch.call(window, url, {get headers() { throw sentinel; }});
+ check(promise instanceof other.Promise, 'conversion rejection must belong to function realm');
+ let caught;
+ await promise.catch(error => { caught = error; });
+ check(caught === sentinel, 'cross-realm exception identity');
+ frame.remove();
+ }
+ return 'ok';
+ })()"#;
+ let script = if worker {
+ let source = serde_json::to_string(&format!("{probe}.then(postMessage, error => postMessage(String(error)))")).unwrap();
+ format!(r#"globalThis.__initExceptionResult = 'pending';
+ const source = URL.createObjectURL(new Blob([{source}]));
+ const worker = new Worker(source);
+ worker.onmessage = e => {{ globalThis.__initExceptionResult = e.data; worker.terminate(); URL.revokeObjectURL(source); }};
+ worker.onerror = e => {{ globalThis.__initExceptionResult = e.message; }};"#)
+ } else {
+ format!("globalThis.__initExceptionResult = 'pending'; {probe}.then(value => {{ globalThis.__initExceptionResult = value; }}, error => {{ globalThis.__initExceptionResult = String(error); }})")
+ };
+ let (result, network_output) = local_executor.run(async move {
+ page_vm.vm_mut().eval(&script)?;
+ drive_websocket_until_done(&mut page_vm, "String(globalThis.__initExceptionResult !== 'pending')", "RequestInit exception checks should finish").await?;
+ let result = page_vm.vm_mut().eval("globalThis.__initExceptionResult")?;
+ Ok::<_, anyhow::Error>((result, page_vm.vm_mut().take_network_output()))
+ }).await.expect("RequestInit exceptions should run on owner lane");
+ assert_eq!(result, "ok", "worker={worker}");
+ let (records, _, _) = split_network_output_items(network_output);
+ assert!(records.iter().all(|record| record.resource_type() != SubresourceResourceType::Fetch), "failed argument conversion dispatched a fetch; worker={worker}");
+ }
+ }).await;
+}
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index dbc60413b..1d10ac0d7 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -1,4 +1,5 @@
use super::*;
+use crate::network_host::convert_fetch_arguments;
use crate::service_worker_runtime::{
ServiceWorkerClientId, ServiceWorkerDirectFetchResult, ServiceWorkerFetchDispatch,
ServiceWorkerFetchRequest, ServiceWorkerFetchRequestMetadata, ServiceWorkerRequestDestination,
@@ -1799,16 +1800,29 @@ pub(in crate::worker) fn worker_fetch_signal_option<'s>(
let init_arg = args.get(1);
if !init_arg.is_null_or_undefined()
&& let Ok(init) = v8::Local::<v8::Object>::try_from(init_arg)
- && init.has(scope, signal_key.into()).unwrap_or(false)
+ && init
+ .has(scope, signal_key.into())
+ .ok_or("Failed to read RequestInit.signal")?
{
- let signal = init
- .get(scope, signal_key.into())
- .unwrap_or_else(|| v8::undefined(scope).into());
+ let signal = webidl::property_result(
+ scope,
+ init,
+ "signal",
+ webidl::Context::member("RequestInit", "signal"),
+ )
+ .map_err(|error| error.to_string())?
+ .unwrap_or_else(|| v8::undefined(scope).into());
return validate_worker_fetch_signal(scope, signal);
}
}
if let Some(request_like) = request_like
- && let Some(signal) = request_like.get(scope, signal_key.into())
+ && let Some(signal) = webidl::property_result(
+ scope,
+ request_like,
+ "signal",
+ webidl::Context::member("Request", "signal"),
+ )
+ .map_err(|error| error.to_string())?
{
return validate_worker_fetch_signal(scope, signal);
}
@@ -2036,10 +2050,12 @@ pub(in crate::worker) fn worker_fetch_callback<'s>(
priority,
metadata: request_metadata,
signal,
- } = match resolve_worker_fetch_input(scope, &args, &document_url) {
+ } = match convert_fetch_arguments(scope, |scope| {
+ resolve_worker_fetch_input(scope, &args, &document_url)
+ }) {
Ok(resolved) => resolved,
- Err(message) => {
- rv.set(make_rejected_promise(scope, &message).into());
+ Err(exception) => {
+ rv.set(make_rejected_promise_with_value(scope, exception).into());
return;
}
};