Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(fetch): preserve typed request preparation errors

ldm08c2956908b99
diff --git a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs
index 4994605c6..31cfa40ae 100644
--- a/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs
+++ b/moli-renderer-v8/src/context_bootstrap/window_runtime/navigator.rs
@@ -1494,7 +1494,7 @@ fn storage_bucket_cache_storage_match_callback<'s>(
return;
}
Err(error) => {
- reject_type_error(scope, resolver, &error);
+ reject_type_error(scope, resolver, &error.to_string());
return;
}
};
@@ -1673,7 +1673,7 @@ fn storage_bucket_cache_put_callback<'s>(
return;
}
Err(error) => {
- reject_type_error(scope, resolver, &error);
+ reject_type_error(scope, resolver, &error.to_string());
return;
}
};
@@ -2020,7 +2020,7 @@ fn storage_bucket_cache_match_callback<'s>(
return;
}
Err(error) => {
- reject_type_error(scope, resolver, &error);
+ reject_type_error(scope, resolver, &error.to_string());
return;
}
};
@@ -2075,7 +2075,7 @@ fn storage_bucket_cache_match_all_callback<'s>(
let request = match cache_request_info_argument(scope, &args, 0) {
Ok(request) => request,
Err(error) => {
- reject_type_error(scope, resolver, &error);
+ reject_type_error(scope, resolver, &error.to_string());
return;
}
};
@@ -2146,7 +2146,7 @@ fn storage_bucket_cache_keys_callback<'s>(
let request = match cache_request_info_argument(scope, &args, 0) {
Ok(request) => request,
Err(error) => {
- reject_type_error(scope, resolver, &error);
+ reject_type_error(scope, resolver, &error.to_string());
return;
}
};
@@ -2204,7 +2204,7 @@ fn storage_bucket_cache_delete_callback<'s>(
return;
}
Err(error) => {
- reject_type_error(scope, resolver, &error);
+ reject_type_error(scope, resolver, &error.to_string());
return;
}
};
@@ -2830,7 +2830,7 @@ fn cache_request_info_argument<'s>(
scope: &mut v8::PinScope<'s, '_>,
args: &v8::FunctionCallbackArguments<'s>,
index: i32,
-) -> Result<Option<CacheRequestInfo>, String> {
+) -> Result<Option<CacheRequestInfo>, crate::network_host::RequestUrlError> {
if args.length() <= index {
return Ok(None);
}
diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs
index c2d9c58be..511c131e6 100644
--- a/moli-renderer-v8/src/network_host.rs
+++ b/moli-renderer-v8/src/network_host.rs
@@ -64,7 +64,9 @@ pub(crate) use self::body_source::{
pending_network_body_stream,
};
pub(in crate::network_host) use self::browser_response::http_status_text;
-pub(crate) use self::browser_response::{local_url_response, local_url_response_result};
+pub(crate) use self::browser_response::{
+ LocalUrlError, local_url_response, local_url_response_result,
+};
pub(crate) use self::csp_reports::{
WindowCspReportRequestContext, capture_window_csp_report_request_context,
send_content_security_policy_reports_for_lightweight_popup,
@@ -125,7 +127,7 @@ pub(crate) use self::media::{
pub(in crate::network_host) use self::preflight_events::CorsPreflightNetworkObserver;
pub(in crate::network_host) use self::request::normalize_request_method;
pub(crate) use self::request::request_constructor_callback;
-pub(crate) use self::request::{FetchArgumentError, convert_fetch_arguments};
+pub(crate) use self::request::{FetchArgumentError, RequestUrlError, convert_fetch_arguments};
pub(crate) use self::request::{
mark_request_input_body_used_for_fetch, request_input_snapshot,
try_resolve_request_constructor_url, try_resolve_request_constructor_url_for_base,
@@ -172,7 +174,7 @@ pub(crate) use self::text_track::{
};
pub(crate) use self::url_helpers::merge_byte_string_request_headers;
pub(in crate::network_host) use self::url_helpers::merge_subresource_request_headers;
-pub(crate) use self::url_helpers::resolve_context_url;
+pub(crate) use self::url_helpers::{ResolveContextUrlError, resolve_context_url};
#[cfg(test)]
pub(crate) use self::xhr::prepare_xhr_send_body;
pub(crate) use self::xhr::{
diff --git a/moli-renderer-v8/src/network_host/browser_response.rs b/moli-renderer-v8/src/network_host/browser_response.rs
index 2ca1d48fa..e2a9617ad 100644
--- a/moli-renderer-v8/src/network_host/browser_response.rs
+++ b/moli-renderer-v8/src/network_host/browser_response.rs
@@ -1,5 +1,25 @@
use super::*;
use moli_web_mime::data_url_body_and_mime_type;
+use std::fmt;
+
+#[derive(Debug)]
+pub(crate) enum LocalUrlError {
+ BlobMethod { method: String },
+ BlobUnavailable { url: url::Url },
+ InvalidData { url: url::Url },
+}
+
+impl fmt::Display for LocalUrlError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::BlobMethod { method } => write!(f, "blob URL fetch requires GET, got `{method}`"),
+ Self::BlobUnavailable { url } => write!(f, "blob URL `{url}` is unavailable"),
+ Self::InvalidData { url } => write!(f, "data URL `{url}` is invalid"),
+ }
+ }
+}
+
+impl std::error::Error for LocalUrlError {}
pub(in crate::network_host) fn http_status_text(status: u16) -> &'static str {
StatusCode::from_u16(status)
@@ -68,17 +88,18 @@ pub(crate) fn local_url_response(url: &url::Url) -> Option<Response> {
pub(crate) fn local_url_response_result(
url: &url::Url,
method: &str,
-) -> Option<Result<Response, String>> {
+) -> Option<Result<Response, LocalUrlError>> {
match url.scheme() {
- "blob" if method != "GET" => {
- Some(Err(format!("blob URL fetch requires GET, got `{method}`")))
- }
- "blob" => {
- Some(blob_url_response(url).ok_or_else(|| format!("blob URL `{url}` is unavailable")))
- }
- "data" => {
- Some(data_url_response(url).ok_or_else(|| format!("data URL `{url}` is invalid")))
- }
+ "blob" if method != "GET" => Some(Err(LocalUrlError::BlobMethod {
+ method: method.to_owned(),
+ })),
+ "blob" => Some(
+ blob_url_response(url)
+ .ok_or_else(|| LocalUrlError::BlobUnavailable { url: url.clone() }),
+ ),
+ "data" => Some(
+ data_url_response(url).ok_or_else(|| LocalUrlError::InvalidData { url: url.clone() }),
+ ),
_ => None,
}
}
@@ -125,7 +146,7 @@ mod tests {
.expect_err("an unregistered blob URL must fail locally");
assert_eq!(
- error,
+ error.to_string(),
"blob URL `blob:https://example.test/not-registered` is unavailable"
);
}
diff --git a/moli-renderer-v8/src/network_host/fetch.rs b/moli-renderer-v8/src/network_host/fetch.rs
index 796374cc7..943a43e4b 100644
--- a/moli-renderer-v8/src/network_host/fetch.rs
+++ b/moli-renderer-v8/src/network_host/fetch.rs
@@ -7,6 +7,17 @@ use super::*;
pub(crate) use self::bindings::window_fetch_callback;
+#[derive(Debug)]
+pub(crate) struct NoCorsRedirectModeError;
+
+impl std::fmt::Display for NoCorsRedirectModeError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str("cross-origin no-cors HTTP fetch requires redirect mode 'follow'")
+ }
+}
+
+impl std::error::Error for NoCorsRedirectModeError {}
+
/// Select the HTTP no-cors fetch path using the logical request URL, before
/// Service Worker or DevTools interception. A DevTools transport URL rewrite
/// does not restart this selection. Local URLs use their scheme-fetch path.
@@ -15,13 +26,13 @@ pub(crate) fn validate_no_cors_http_redirect_mode(
url: &url::Url,
mode: moli_fetch::RequestMode,
redirect: moli_fetch::RequestRedirectMode,
-) -> Result<(), String> {
+) -> Result<(), NoCorsRedirectModeError> {
if matches!(url.scheme(), "http" | "https")
&& mode == moli_fetch::RequestMode::NoCors
&& redirect != moli_fetch::RequestRedirectMode::Follow
&& !origin.same_origin(&moli_url::WebOrigin::from_url(url))
{
- return Err("cross-origin no-cors HTTP fetch requires redirect mode 'follow'".to_owned());
+ return Err(NoCorsRedirectModeError);
}
Ok(())
}
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rs
index ab9ccdab8..09ef51849 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs
@@ -3,8 +3,9 @@ mod request;
mod service_worker;
use self::paths::{
- record_intercepted_fetch, reject_bad_port_fetch, reject_blocked_fetch, reject_csp_fetch,
- reject_offline_fetch, reject_url_policy_fetch, resolve_local_fetch, spawn_network_fetch,
+ local_fetch_error_text, record_intercepted_fetch, reject_bad_port_fetch, reject_blocked_fetch,
+ reject_csp_fetch, reject_offline_fetch, reject_url_policy_fetch, resolve_local_fetch,
+ spawn_network_fetch,
};
use self::request::prepare_window_fetch_request;
use self::service_worker::dispatch_service_worker_fetch;
@@ -210,8 +211,8 @@ fn window_fetch_callback_in_relevant_realm<'s>(
let signal = signal.as_ref().map(|signal| v8::Local::new(scope, signal));
let prepared = match prepare_window_fetch_request(scope, parsed, fetch_context, host) {
Ok(prepared) => prepared,
- Err(message) => {
- rv.set(make_rejected_promise(scope, &message).into());
+ Err(error) => {
+ rv.set(make_rejected_promise(scope, &error.to_string()).into());
return;
}
};
@@ -263,13 +264,13 @@ fn window_fetch_callback_in_relevant_realm<'s>(
return;
}
- if let Err(message) = validate_no_cors_http_redirect_mode(
+ if let Err(error) = validate_no_cors_http_redirect_mode(
&prepared.request_origin,
&prepared.resolved_url,
prepared.request_mode,
prepared.redirect_mode,
) {
- let message = reject_url_policy_fetch(host, prepared, message);
+ let message = reject_url_policy_fetch(host, prepared, error.to_string());
rv.set(make_rejected_promise(scope, &message).into());
return;
}
@@ -300,7 +301,8 @@ fn window_fetch_callback_in_relevant_realm<'s>(
return;
}
Ok(None) => {}
- Err(message) => {
+ Err(error) => {
+ let message = local_fetch_error_text(&error);
let exception = v8_string(scope, &message)
.map(|message| v8::Exception::type_error(scope, message))
.unwrap_or_else(|| v8::undefined(scope).into());
@@ -322,28 +324,15 @@ fn window_fetch_callback_in_relevant_realm<'s>(
return;
}
- match dispatch_service_worker_fetch(scope, host, resolver, &prepared) {
- Ok(Some(internal_id)) => {
- if let Some(signal) = signal {
- install_window_fetch_abort_listener(scope, signal, internal_id);
- }
- rv.set(promise.into());
- return;
- }
- Ok(None) => {}
- Err(message) => {
- rv.set(make_rejected_promise(scope, &message).into());
- return;
+ if let Some(internal_id) = dispatch_service_worker_fetch(scope, host, resolver, &prepared) {
+ if let Some(signal) = signal {
+ install_window_fetch_abort_listener(scope, signal, internal_id);
}
+ rv.set(promise.into());
+ return;
}
- let internal_id = match spawn_network_fetch(scope, host, resolver, prepared) {
- Ok(internal_id) => internal_id,
- Err(message) => {
- rv.set(make_rejected_promise(scope, &message).into());
- return;
- }
- };
+ let internal_id = spawn_network_fetch(scope, host, resolver, prepared);
if let Some(signal) = signal {
install_window_fetch_abort_listener(scope, signal, internal_id);
}
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs b/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs
index 6d0184a94..05a90ee66 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings/paths.rs
@@ -140,19 +140,21 @@ pub(super) fn reject_bad_port_fetch(
message
}
+pub(super) fn local_fetch_error_text(error: &LocalUrlError) -> String {
+ match error {
+ LocalUrlError::BlobUnavailable { .. } => FILE_NOT_FOUND_ERROR_TEXT.to_owned(),
+ _ => error.to_string(),
+ }
+}
+
pub(super) fn resolve_local_fetch(
host: &mut JsContextHost,
prepared: &PreparedWindowFetchRequest,
-) -> Result<Option<Response>, String> {
+) -> Result<Option<Response>, LocalUrlError> {
let Some(result) = local_url_response_result(&prepared.resolved_url, &prepared.method) else {
return Ok(None);
};
- let response = result.map_err(|message| {
- let message = if prepared.resolved_url.scheme() == "blob" && prepared.method == "GET" {
- FILE_NOT_FOUND_ERROR_TEXT.to_owned()
- } else {
- message
- };
+ let response = result.inspect_err(|error| {
host.record_subresource_network(SubresourceNetworkRecord::failure(
prepared.frame_id.clone(),
prepared.document_url.clone(),
@@ -161,9 +163,8 @@ pub(super) fn resolve_local_fetch(
prepared.request_headers.clone(),
request_body_text(&prepared.body),
SubresourceResourceType::Fetch,
- message.clone(),
+ local_fetch_error_text(error),
));
- message
})?;
host.record_subresource_network(
SubresourceNetworkRecord::success_with_body(
@@ -198,7 +199,7 @@ pub(super) fn spawn_network_fetch(
host: &mut JsContextHost,
resolver: v8::Local<'_, v8::PromiseResolver>,
prepared: PreparedWindowFetchRequest,
-) -> Result<u64, String> {
+) -> u64 {
let loader = prepared.resource_loader.request_client().clone();
let mut request = Request::new_browser(
&prepared.method,
@@ -292,7 +293,7 @@ pub(super) fn spawn_network_fetch(
prepared.request_headers,
request_body_text(&prepared.body),
);
- Ok(internal_id)
+ internal_id
}
fn window_fetch_cache_mode(cache: &str) -> RequestCacheMode {
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/request.rs b/moli-renderer-v8/src/network_host/fetch/bindings/request.rs
index 20e0c2220..b6630a518 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings/request.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings/request.rs
@@ -1,5 +1,55 @@
use super::super::input::ParsedWindowFetchInput;
use super::super::*;
+use crate::network_host::url_helpers::ResolveContextUrlError;
+use std::fmt;
+
+#[derive(Debug)]
+pub(super) enum FetchPrepareError {
+ DocumentExecutionContextUnavailable,
+ ResourceLoaderUnavailable,
+ ExecutionContextRetired,
+ PolicyContextUnavailable,
+ ReportContextUnavailable,
+ Url(ResolveContextUrlError),
+}
+
+impl From<ResolveContextUrlError> for FetchPrepareError {
+ fn from(error: ResolveContextUrlError) -> Self {
+ Self::Url(error)
+ }
+}
+
+impl fmt::Display for FetchPrepareError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::DocumentExecutionContextUnavailable => {
+ f.write_str("fetch: Document execution context is unavailable")
+ }
+ Self::ResourceLoaderUnavailable => {
+ f.write_str("fetch: Document resource loader is unavailable")
+ }
+ Self::ExecutionContextRetired => {
+ f.write_str("fetch: Window execution context owner is retired")
+ }
+ Self::PolicyContextUnavailable => {
+ f.write_str("fetch: document policy context is unavailable")
+ }
+ Self::ReportContextUnavailable => {
+ f.write_str("fetch: document report context is unavailable")
+ }
+ Self::Url(error) => error.fmt(f),
+ }
+ }
+}
+
+impl std::error::Error for FetchPrepareError {
+ fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+ match self {
+ Self::Url(error) => Some(error),
+ _ => None,
+ }
+ }
+}
pub(super) struct PreparedWindowFetchRequest {
pub(super) frame_id: Option<String>,
@@ -39,7 +89,7 @@ pub(super) fn prepare_window_fetch_request<'s>(
parsed: ParsedWindowFetchInput,
fetch_context: crate::native_bridge::WindowFetchContext,
host: &JsContextHost,
-) -> Result<PreparedWindowFetchRequest, String> {
+) -> Result<PreparedWindowFetchRequest, FetchPrepareError> {
let request_headers = parsed.headers;
// Receiver capture and WebIDL conversion are complete before this pure
// preparation stage. Never inspect `args.this()` here: doing so could bind
@@ -48,13 +98,13 @@ pub(super) fn prepare_window_fetch_request<'s>(
let request_scope = fetch_context.request_target().dispatch_scope();
let document_target = host
.current_window_document_task_target_for_dispatch_scope(request_scope)
- .ok_or_else(|| "fetch: Document execution context is unavailable".to_owned())?;
+ .ok_or(FetchPrepareError::DocumentExecutionContextUnavailable)?;
let resource_loader = host
.document_resource_loader_for_window_owner(document_target.owner())
- .ok_or_else(|| "fetch: Document resource loader is unavailable".to_owned())?;
+ .ok_or(FetchPrepareError::ResourceLoaderUnavailable)?;
let environment = host
.subresource_request_environment(&resource_loader, request_scope)
- .ok_or_else(|| "fetch: Window execution context owner is retired".to_owned())?;
+ .ok_or(FetchPrepareError::ExecutionContextRetired)?;
let crate::network::context::SubresourceRequestEnvironment {
document_url,
base_url,
@@ -63,10 +113,10 @@ pub(super) fn prepare_window_fetch_request<'s>(
} = environment;
let connect_policy = host
.document_connect_policy_snapshot_for_owner(request_scope)
- .ok_or_else(|| "fetch: document policy context is unavailable".to_owned())?;
+ .ok_or(FetchPrepareError::PolicyContextUnavailable)?;
let csp_report_context =
crate::network_host::capture_window_csp_report_request_context(scope, host, request_scope)
- .ok_or_else(|| "fetch: document report context is unavailable".to_owned())?;
+ .ok_or(FetchPrepareError::ReportContextUnavailable)?;
let document_referrer_policy =
effective_subresource_referrer_policy(scope, host, request_scope);
let policy_context = effective_subresource_policy_context(scope, host, request_scope);
@@ -74,8 +124,7 @@ pub(super) fn prepare_window_fetch_request<'s>(
let cors_preflight_request_headers = request_headers.clone();
let request_headers =
merge_byte_string_request_headers(host.extra_http_headers(), &request_headers);
- let resolved_url =
- resolve_context_url(&base_url, &parsed.url, None).map_err(|error| error.to_string())?;
+ let resolved_url = resolve_context_url(&base_url, &parsed.url, None)?;
Ok(PreparedWindowFetchRequest {
frame_id,
diff --git a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs
index d74efbb4b..30952ecf0 100644
--- a/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs
+++ b/moli-renderer-v8/src/network_host/fetch/bindings/service_worker.rs
@@ -10,21 +10,16 @@ pub(super) fn dispatch_service_worker_fetch(
host: &mut JsContextHost,
resolver: v8::Local<'_, v8::PromiseResolver>,
prepared: &PreparedWindowFetchRequest,
-) -> Result<Option<u64>, String> {
+) -> Option<u64> {
if !matches!(prepared.resolved_url.scheme(), "http" | "https") {
- return Ok(None);
+ return None;
}
let client_id = host.service_worker_client_id_for_subresource_owner(prepared.request_scope());
- if host
- .service_worker_controller_for_fetch(
- client_id,
- &prepared.document_url,
- &prepared.resolved_url,
- )
- .is_none()
- {
- return Ok(None);
- }
+ host.service_worker_controller_for_fetch(
+ client_id,
+ &prepared.document_url,
+ &prepared.resolved_url,
+ )?;
let request_cookie_report = observe_subresource_request_cookie_report(
prepared.resource_loader.request_client(),
@@ -113,7 +108,7 @@ pub(super) fn dispatch_service_worker_fetch(
direct_completion_tx: None,
};
if host.dispatch_service_worker_fetch(dispatch) {
- return Ok(Some(internal_id));
+ return Some(internal_id);
}
let _ =
@@ -130,7 +125,7 @@ pub(super) fn dispatch_service_worker_fetch(
network_error_text: None,
result: Err("service worker fetch dispatch failed".to_owned()).into(),
});
- Ok(Some(internal_id))
+ Some(internal_id)
}
fn request_body_text(body: &Option<Vec<u8>>) -> Option<String> {
diff --git a/moli-renderer-v8/src/network_host/request.rs b/moli-renderer-v8/src/network_host/request.rs
index 097159846..513661816 100644
--- a/moli-renderer-v8/src/network_host/request.rs
+++ b/moli-renderer-v8/src/network_host/request.rs
@@ -9,7 +9,7 @@ use super::headers::{
use super::*;
pub(crate) use self::bindings::request_constructor_callback;
-pub(crate) use self::error::FetchArgumentError;
+pub(crate) use self::error::{FetchArgumentError, RequestUrlError};
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};
diff --git a/moli-renderer-v8/src/network_host/request/bindings/init.rs b/moli-renderer-v8/src/network_host/request/bindings/init.rs
index dce291547..ff7335dc7 100644
--- a/moli-renderer-v8/src/network_host/request/bindings/init.rs
+++ b/moli-renderer-v8/src/network_host/request/bindings/init.rs
@@ -137,8 +137,7 @@ pub(super) fn apply_request_init_overrides<'s>(
let method_overridden = parsed.method.is_some();
if let Some(method) = parsed.method {
- state.method = normalize_request_method(&method)
- .map_err(|_| webidl::WebIdlError::custom_message("Request method is forbidden"))?;
+ state.method = normalize_request_method(&method)?;
}
let init_body_value = webidl::property_result(
scope,
diff --git a/moli-renderer-v8/src/network_host/request/error.rs b/moli-renderer-v8/src/network_host/request/error.rs
index e337deadb..246fd044a 100644
--- a/moli-renderer-v8/src/network_host/request/error.rs
+++ b/moli-renderer-v8/src/network_host/request/error.rs
@@ -2,6 +2,36 @@ use crate::network_host::url_helpers::ResolveContextUrlError;
use crate::webidl;
use std::fmt;
+#[derive(Debug)]
+pub(crate) enum RequestUrlError {
+ Resolve(ResolveContextUrlError),
+ OpaqueWorkerBase { input: String },
+}
+
+impl From<ResolveContextUrlError> for RequestUrlError {
+ fn from(error: ResolveContextUrlError) -> Self {
+ Self::Resolve(error)
+ }
+}
+
+impl fmt::Display for RequestUrlError {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ Self::Resolve(error) => error.fmt(f),
+ Self::OpaqueWorkerBase { input } => write!(f, "Failed to parse URL from {input}"),
+ }
+ }
+}
+
+impl std::error::Error for RequestUrlError {
+ fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+ match self {
+ Self::Resolve(error) => Some(error),
+ Self::OpaqueWorkerBase { .. } => None,
+ }
+ }
+}
+
/// Argument conversion failures remain structured until the fetch binding
/// turns them into a JavaScript rejection.
#[derive(Debug)]
diff --git a/moli-renderer-v8/src/network_host/request/init.rs b/moli-renderer-v8/src/network_host/request/init.rs
index b8e8eb414..3fec5fdaf 100644
--- a/moli-renderer-v8/src/network_host/request/init.rs
+++ b/moli-renderer-v8/src/network_host/request/init.rs
@@ -156,7 +156,7 @@ pub(crate) fn parse_fetch_init<'s>(
})?;
let method = init
.method
- .map(|s| normalize_request_method(&s).map_err(webidl::WebIdlError::custom_message))
+ .map(|s| normalize_request_method(&s))
.transpose()?
.unwrap_or_else(|| "GET".to_owned());
diff --git a/moli-renderer-v8/src/network_host/request/input.rs b/moli-renderer-v8/src/network_host/request/input.rs
index 5809c9060..52b663038 100644
--- a/moli-renderer-v8/src/network_host/request/input.rs
+++ b/moli-renderer-v8/src/network_host/request/input.rs
@@ -5,13 +5,15 @@ use crate::webidl;
pub(in crate::network_host) fn normalize_request_method(
method: &str,
-) -> Result<String, &'static str> {
+) -> Result<String, webidl::WebIdlError> {
if method.is_empty() {
return Ok("GET".to_owned());
}
let normalized = method.to_ascii_uppercase();
if matches!(normalized.as_str(), "CONNECT" | "TRACE" | "TRACK") {
- return Err("Request method is forbidden");
+ return Err(webidl::WebIdlError::custom_message(
+ "Request method is forbidden",
+ ));
}
if matches!(
normalized.as_str(),
@@ -106,10 +108,7 @@ fn request_input_snapshot_inner<'s>(
return Ok(None);
};
let method = defined_object_string_property(scope, object, "method")
- .map(|value| {
- normalize_request_method(&value)
- .map_err(|_| webidl::WebIdlError::custom_message("Request method is forbidden"))
- })
+ .map(|value| normalize_request_method(&value))
.transpose()?
.unwrap_or_else(|| "GET".to_owned());
let mode =
@@ -170,10 +169,7 @@ fn request_input_snapshot_from_private_slots<'s>(
) -> Result<RequestInputSnapshot, webidl::WebIdlError> {
let url = request_slot_string(scope, object, REQUEST_URL_SLOT).unwrap_or_default();
let method = request_slot_string(scope, object, REQUEST_METHOD_SLOT)
- .map(|value| {
- normalize_request_method(&value)
- .map_err(|_| webidl::WebIdlError::custom_message("Request method is forbidden"))
- })
+ .map(|value| normalize_request_method(&value))
.transpose()?
.unwrap_or_else(|| "GET".to_owned());
let mode =
@@ -320,7 +316,7 @@ pub(super) fn resolve_request_constructor_url(
pub(crate) fn try_resolve_request_constructor_url(
scope: &mut v8::PinScope<'_, '_>,
input: &str,
-) -> Result<String, String> {
+) -> Result<String, RequestUrlError> {
try_resolve_request_constructor_url_for_scope(scope, input, None, None)
}
@@ -328,7 +324,7 @@ pub(crate) fn try_resolve_request_constructor_url_for_child(
scope: &mut v8::PinScope<'_, '_>,
input: &str,
child_handle: Option<crate::document_runtime::DomHandle>,
-) -> Result<String, String> {
+) -> Result<String, RequestUrlError> {
try_resolve_request_constructor_url_for_scope(scope, input, child_handle, None)
}
@@ -336,7 +332,7 @@ pub(crate) fn try_resolve_request_constructor_url_for_base(
scope: &mut v8::PinScope<'_, '_>,
input: &str,
base_url: Option<url::Url>,
-) -> Result<String, String> {
+) -> Result<String, RequestUrlError> {
try_resolve_request_constructor_url_for_scope(scope, input, None, base_url)
}
@@ -345,14 +341,14 @@ pub(crate) fn try_resolve_request_constructor_url_for_scope(
input: &str,
child_handle: Option<crate::document_runtime::DomHandle>,
base_url: Option<url::Url>,
-) -> Result<String, String> {
+) -> Result<String, RequestUrlError> {
if url::Url::parse(input).is_ok() {
return Ok(input.to_owned());
}
if let Some(base_url) = base_url {
return resolve_context_url(&base_url, input, None)
.map(|url| url.to_string())
- .map_err(|error| error.to_string());
+ .map_err(RequestUrlError::from);
}
if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) {
let host = unsafe { &mut *host_ptr };
@@ -367,14 +363,16 @@ pub(crate) fn try_resolve_request_constructor_url_for_scope(
});
resolve_context_url(&document_url, input, None)
.map(|url| url.to_string())
- .map_err(|error| error.to_string())
+ .map_err(RequestUrlError::from)
} else if let Some(worker_url) = crate::context_bootstrap::current_worker_script_url(scope) {
if worker_url.scheme() == "blob" {
- return Err(format!("Failed to parse URL from {input}"));
+ return Err(RequestUrlError::OpaqueWorkerBase {
+ input: input.to_owned(),
+ });
}
resolve_context_url(&worker_url, input, None)
.map(|url| url.to_string())
- .map_err(|error| error.to_string())
+ .map_err(RequestUrlError::from)
} else {
Ok(input.to_owned())
}
diff --git a/moli-renderer-v8/src/network_host/xhr/bindings/open.rs b/moli-renderer-v8/src/network_host/xhr/bindings/open.rs
index 2b05c7a45..00f9f526f 100644
--- a/moli-renderer-v8/src/network_host/xhr/bindings/open.rs
+++ b/moli-renderer-v8/src/network_host/xhr/bindings/open.rs
@@ -27,8 +27,8 @@ pub(super) fn xhr_open_callback<'s>(
};
let method = match normalize_request_method(&parsed.method) {
Ok(method) => method,
- Err(message) => {
- throw_type_error(scope, message);
+ Err(error) => {
+ webidl::throw_error(scope, &error);
return;
}
};
diff --git a/moli-renderer-v8/src/network_host/xhr/send.rs b/moli-renderer-v8/src/network_host/xhr/send.rs
index afbfbf43a..04cc88d45 100644
--- a/moli-renderer-v8/src/network_host/xhr/send.rs
+++ b/moli-renderer-v8/src/network_host/xhr/send.rs
@@ -181,11 +181,11 @@ pub(super) fn xhr_send_callback<'s>(
record_xhr_response_success(host, &prepared, &response);
apply_xhr_response(scope, xhr, response);
}
- Err(message) if async_request => {
- record_url_policy_xhr_failure(scope, host, xhr, prepared, message);
+ Err(error) if async_request => {
+ record_url_policy_xhr_failure(scope, host, xhr, prepared, error.to_string());
}
- Err(message) => {
- record_synchronous_xhr_failure(scope, host, xhr, prepared, message);
+ Err(error) => {
+ record_synchronous_xhr_failure(scope, host, xhr, prepared, error.to_string());
}
}
return;
diff --git a/moli-renderer-v8/src/network_host/xhr/send/request.rs b/moli-renderer-v8/src/network_host/xhr/send/request.rs
index b93cb862f..49f987c74 100644
--- a/moli-renderer-v8/src/network_host/xhr/send/request.rs
+++ b/moli-renderer-v8/src/network_host/xhr/send/request.rs
@@ -1,4 +1,5 @@
use super::super::*;
+use crate::network_host::url_helpers::ResolveContextUrlError;
const CONTENT_TYPE_HEADER: &str = "Content-Type";
const URL_SEARCH_PARAMS_CONTENT_TYPE: &str = "application/x-www-form-urlencoded;charset=UTF-8";
@@ -30,7 +31,7 @@ pub(super) struct PreparedXhrSendRequest {
pub(super) enum XhrSendPrepareError {
ExecutionContext,
- Url(String),
+ Url(ResolveContextUrlError),
}
pub(super) fn xhr_dom_debugger_request_url<'s>(
@@ -78,8 +79,8 @@ pub(super) fn prepare_xhr_send_request<'s>(
} = environment;
let policy_context = effective_subresource_policy_context(scope, host, owner);
let network_partition_key = active_subresource_network_partition_key(host, owner);
- let resolved_url = resolve_context_url(&base_url, &url_str, None)
- .map_err(|error| XhrSendPrepareError::Url(error.to_string()))?;
+ let resolved_url =
+ resolve_context_url(&base_url, &url_str, None).map_err(XhrSendPrepareError::Url)?;
let (request_headers, cors_preflight_request_headers) =
xhr_request_headers(scope, host, xhr, prepared_body.default_content_type);
let credentials_mode =
diff --git a/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs b/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs
index 96b59bab3..89dfacb4c 100644
--- a/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/followed_navigation.rs
@@ -77,7 +77,7 @@ pub(super) async fn load_followed_location_navigation(
.map(Ok)
.or_else(|| crate::network_host::local_url_response_result(&url, &request_method))
{
- let response = response.map_err(anyhow::Error::msg)?;
+ let response = response?;
if matches!(response.status, 204 | 205) {
return Ok(LoadedFollowedLocationNavigation::NoDocument);
}
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 33426c8d4..db53ee70c 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
@@ -7163,6 +7163,10 @@ async fn request_and_fetch_argument_errors_preserve_exceptions_without_side_effe
check(invalidSignal instanceof other.Promise, 'validation rejection must belong to function realm');
await invalidSignal.catch(error => { caught = error; });
check(caught instanceof other.TypeError, 'validation TypeError must belong to function realm');
+ const invalidUrl = other.fetch.call(window, 'http://[');
+ check(invalidUrl instanceof Promise, 'preparation rejection must belong to receiver realm');
+ await invalidUrl.catch(error => { caught = error; });
+ check(caught instanceof TypeError && caught.message.startsWith('failed to resolve url `http://[`:'), 'preparation TypeError must belong to receiver realm');
frame.remove();
}
return 'ok';
diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs
index 12d92f0ac..9f7c8042b 100644
--- a/moli-renderer-v8/src/worker/global_scope/fetch.rs
+++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs
@@ -2161,12 +2161,13 @@ pub(in crate::worker) fn worker_fetch_callback<'s>(
return;
}
- if let Err(message) = crate::network_host::validate_no_cors_http_redirect_mode(
+ if let Err(error) = crate::network_host::validate_no_cors_http_redirect_mode(
&moli_url::WebOrigin::from_url(&document_url),
&resolved_url,
request_mode,
redirect_mode,
) {
+ let message = error.to_string();
record_worker_subresource_failure(
&state.borrow(),
document_url,
diff --git a/moli-renderer-v8/src/worker/global_scope/xhr.rs b/moli-renderer-v8/src/worker/global_scope/xhr.rs
index b6b7a6b76..686226563 100644
--- a/moli-renderer-v8/src/worker/global_scope/xhr.rs
+++ b/moli-renderer-v8/src/worker/global_scope/xhr.rs
@@ -1,4 +1,5 @@
use super::*;
+use crate::network_host::ResolveContextUrlError;
use crossbeam_channel::{after, bounded, never, select};
use moli_webapi_declare::WebApiObject;
use std::thread;
@@ -13,8 +14,30 @@ pub(in crate::worker) struct PreparedWorkerXhrSendRequest {
credentials_mode: RequestCredentialsMode,
}
+#[derive(Debug)]
pub(in crate::worker) enum WorkerXhrSendPrepareError {
- Request(String),
+ ScriptUrlUnavailable,
+ Url(ResolveContextUrlError),
+}
+
+impl std::fmt::Display for WorkerXhrSendPrepareError {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Self::ScriptUrlUnavailable => {
+ f.write_str("worker xhr: worker script url is unavailable")
+ }
+ Self::Url(error) => error.fmt(f),
+ }
+ }
+}
+
+impl std::error::Error for WorkerXhrSendPrepareError {
+ fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+ match self {
+ Self::Url(error) => Some(error),
+ Self::ScriptUrlUnavailable => None,
+ }
+ }
}
pub(in crate::worker) const WORKER_XHR_TIMEOUT_ERROR_TEXT: &str = "XMLHttpRequest timeout";
@@ -276,8 +299,8 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(
let prepared = match prepare_worker_xhr_send_request(scope, &state, xhr, method, prepared_body)
{
Ok(prepared) => prepared,
- Err(WorkerXhrSendPrepareError::Request(message)) => {
- tracing::debug!("Worker XHR request preparation error: {message}");
+ Err(error) => {
+ tracing::debug!("Worker XHR request preparation error: {error}");
if async_request {
apply_xhr_failure(scope, xhr);
} else {
@@ -419,7 +442,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(
if !async_request && let Some(result) = local_response {
match result {
Ok(response) => apply_xhr_response(scope, xhr, response),
- Err(message) => {
+ Err(error) => {
record_worker_subresource_failure(
&state.borrow(),
prepared.document_url,
@@ -428,7 +451,7 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(
prepared.request_headers,
request_body_text(&prepared.send_body),
SubresourceResourceType::Xhr,
- message,
+ error.to_string(),
);
throw_synchronous_xhr_failure(scope, xhr, &request_url, "NetworkError");
}
@@ -505,7 +528,9 @@ pub(crate) fn try_worker_xhr_send_callback<'s>(
let _ = state.borrow().xhr_completion_tx.send(WorkerXhrCompletion {
xhr_id,
network_request_headers: None,
- result: result.map(|response| WorkerXhrResponse::Materialized(Box::new(response))),
+ result: result
+ .map(|response| WorkerXhrResponse::Materialized(Box::new(response)))
+ .map_err(|error| error.to_string()),
});
return true;
}
@@ -1176,13 +1201,13 @@ pub(in crate::worker) fn prepare_worker_xhr_send_request<'s>(
) -> Result<PreparedWorkerXhrSendRequest, WorkerXhrSendPrepareError> {
let url_str = xhr_state_string_property(scope, xhr, XHR_URL_SLOT).unwrap_or_default();
- let document_url = state.borrow().current_script_url.clone().ok_or_else(|| {
- WorkerXhrSendPrepareError::Request(
- "worker xhr: worker script url is unavailable".to_owned(),
- )
- })?;
+ let document_url = state
+ .borrow()
+ .current_script_url
+ .clone()
+ .ok_or(WorkerXhrSendPrepareError::ScriptUrlUnavailable)?;
let resolved_url = resolve_context_url(&document_url, &url_str, None)
- .map_err(|error| WorkerXhrSendPrepareError::Request(error.to_string()))?;
+ .map_err(WorkerXhrSendPrepareError::Url)?;
let request_headers =
xhr_author_request_headers(scope, xhr, prepared_body.default_content_type);
let credentials_mode =