From 5c0107a1a8dfa13745ef78044ea10e085b7f4e32 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 7 Nov 2026 12:28:49 +0800 Subject: [PATCH] refactor(fetch): preserve typed resource loading errors --- Cargo.lock | 1 + moli-fetch/Cargo.toml | 1 + moli-fetch/src/fetch_url_list.rs | 17 +++++-- moli-fetch/src/lib.rs | 2 +- moli-fetch/src/request.rs | 4 +- moli-fetch/src/tests/redirect_policy.rs | 13 +++-- .../context_host/text_track_loads.rs | 24 ++++++--- .../native_bridge/element/media/attributes.rs | 3 +- .../element/media/text_tracks.rs | 18 ++++++- moli-renderer-v8/src/network_host.rs | 4 +- .../src/network_host/fetch/bindings.rs | 4 +- .../src/network_host/font_face.rs | 24 ++++----- moli-renderer-v8/src/network_host/media.rs | 20 ++++---- .../src/network_host/resource_fetch_error.rs | 25 +++++++++ .../src/network_host/response/cors.rs | 5 +- .../network_host/stylesheet_subresource.rs | 10 ++-- .../src/network_host/subresource.rs | 35 +++++++------ .../src/network_host/text_track.rs | 51 ++++++++++--------- .../src/script_vm/subresource_fetch.rs | 6 +-- .../subresource_fetch/fetch_dispatch.rs | 4 +- .../subresource_fetch/pending_fetch.rs | 49 ++++++++++-------- .../script_vm/subresource_fetch/streaming.rs | 4 +- .../src/worker/global_scope/fetch.rs | 8 +-- 23 files changed, 204 insertions(+), 128 deletions(-) create mode 100644 moli-renderer-v8/src/network_host/resource_fetch_error.rs diff --git a/Cargo.lock b/Cargo.lock index afcd79c076e..d89b49ad715 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2948,6 +2948,7 @@ dependencies = [ "rcgen", "serde", "strum", + "thiserror", "tokio", "tokio-rustls", "tokio-tungstenite", diff --git a/moli-fetch/Cargo.toml b/moli-fetch/Cargo.toml index d567401900e..3ddef818399 100644 --- a/moli-fetch/Cargo.toml +++ b/moli-fetch/Cargo.toml @@ -32,6 +32,7 @@ parking_lot = "0.12" percent-encoding = "2" serde = { version = "1.0.228", features = ["derive"] } strum = { version = "0.28.0", features = ["derive"] } +thiserror = "2.0.17" tokio = { version = "1.51.0", features = ["rt", "sync"] } tokio-util = { version = "0.7.18", features = ["rt"] } tracing = "0.1.41" diff --git a/moli-fetch/src/fetch_url_list.rs b/moli-fetch/src/fetch_url_list.rs index f046dca01a3..9b45b22b666 100644 --- a/moli-fetch/src/fetch_url_list.rs +++ b/moli-fetch/src/fetch_url_list.rs @@ -4,6 +4,14 @@ use url::Url; use crate::{RedirectInfo, RedirectSource, RequestMode}; +#[derive(Debug, thiserror::Error)] +pub enum RequestModeError { + #[error("same-origin request mode requires an initiating origin")] + MissingOrigin, + #[error("same-origin request mode blocked a cross-origin URL in the fetch of {url}")] + CrossOrigin { url: Url }, +} + /// A borrowed view of the URLs visited by a fetch. Requests and responses use /// the same rules for redirect taint, including synthetic redirects. #[derive(Clone, Copy, Debug)] @@ -39,15 +47,14 @@ impl<'a> FetchUrlList<'a> { self, mode: RequestMode, origin: &WebOrigin, - ) -> Result<(), String> { + ) -> Result<(), RequestModeError> { if mode == RequestMode::SameOrigin && self.current_url.scheme() != "data" && self.has_cross_origin_url(origin) { - return Err(format!( - "same-origin request mode blocked a cross-origin URL in the fetch of {}", - self.current_url - )); + return Err(RequestModeError::CrossOrigin { + url: self.current_url.clone(), + }); } Ok(()) } diff --git a/moli-fetch/src/lib.rs b/moli-fetch/src/lib.rs index b4fb0cc2581..830f33704f2 100644 --- a/moli-fetch/src/lib.rs +++ b/moli-fetch/src/lib.rs @@ -48,7 +48,7 @@ pub use error::{ FetchCacheMiss, FetchCancelled, NET_ERR_ABORTED_ERROR_TEXT, ensure_http_status_success, is_fetch_cancelled, }; -pub use fetch_url_list::FetchUrlList; +pub use fetch_url_list::{FetchUrlList, RequestModeError}; pub use headers::{ DefaultAcceptKind, cors_unsafe_request_header_names, default_accept_header, encode_redirect_location, is_cors_safelisted_method, is_cors_safelisted_request_content_type, diff --git a/moli-fetch/src/request.rs b/moli-fetch/src/request.rs index fc385f88f4b..b2a648e6875 100644 --- a/moli-fetch/src/request.rs +++ b/moli-fetch/src/request.rs @@ -1211,10 +1211,10 @@ impl Request { } let origin = self .request_origin() - .context("same-origin request mode requires an initiating origin")?; + .context(crate::RequestModeError::MissingOrigin)?; self.url_list(request_url) .validate_request_mode(self.request_mode, origin) - .map_err(anyhow::Error::msg) + .map_err(Into::into) } /// Checks one network response against the request's state before that diff --git a/moli-fetch/src/tests/redirect_policy.rs b/moli-fetch/src/tests/redirect_policy.rs index 2377d0caf21..e9d5504247a 100644 --- a/moli-fetch/src/tests/redirect_policy.rs +++ b/moli-fetch/src/tests/redirect_policy.rs @@ -122,11 +122,14 @@ fn request_mode_validation_is_pure_and_admission_rechecks_recorded_policy() -> R anyhow::bail!("recorded redirect denied"); })); request.validate_request_mode_for_url(&target)?; - assert!( - request - .validate_request_mode_for_url(&Url::parse("https://cross.test/")?) - .is_err() - ); + let cross_origin_url = Url::parse("https://cross.test/")?; + let error = request + .validate_request_mode_for_url(&cross_origin_url) + .unwrap_err(); + assert!(matches!( + error.downcast_ref::(), + Some(crate::RequestModeError::CrossOrigin { url }) if url == &cross_origin_url + )); assert_eq!( calls.load(Ordering::SeqCst), 0, diff --git a/moli-renderer-v8/src/native_bridge/context_host/text_track_loads.rs b/moli-renderer-v8/src/native_bridge/context_host/text_track_loads.rs index 8976e76f9d5..b7dee3564ec 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/text_track_loads.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/text_track_loads.rs @@ -249,7 +249,7 @@ impl JsContextHost { &mut self, track_handle: DomHandle, sequence: TextTrackLoadSequenceId, - result: Result, + terminal: PendingTextTrackLoadTerminal, ) -> Option { let pending = self .pending_text_track_load_sequences @@ -259,9 +259,13 @@ impl JsContextHost { { return None; } - pending.network_state = match result { - Ok(body) => PendingTextTrackLoadNetworkState::Ready(body), - Err(_) => PendingTextTrackLoadNetworkState::FetchFailed, + pending.network_state = match terminal { + PendingTextTrackLoadTerminal::Ready(body) => { + PendingTextTrackLoadNetworkState::Ready(body) + } + PendingTextTrackLoadTerminal::FetchFailed => { + PendingTextTrackLoadNetworkState::FetchFailed + } }; pending_text_track_terminal_followup(pending) } @@ -271,7 +275,7 @@ impl JsContextHost { track_handle: DomHandle, sequence: TextTrackLoadSequenceId, internal_id: u64, - result: Result, + terminal: PendingTextTrackLoadTerminal, ) -> Option { let pending = self .pending_text_track_load_sequences @@ -287,9 +291,13 @@ impl JsContextHost { ); return None; } - pending.network_state = match result { - Ok(body) => PendingTextTrackLoadNetworkState::Ready(body), - Err(_) => PendingTextTrackLoadNetworkState::FetchFailed, + pending.network_state = match terminal { + PendingTextTrackLoadTerminal::Ready(body) => { + PendingTextTrackLoadNetworkState::Ready(body) + } + PendingTextTrackLoadTerminal::FetchFailed => { + PendingTextTrackLoadNetworkState::FetchFailed + } }; tracing::debug!( track = track_handle.index(), diff --git a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs index 44b4ffc2a06..f1c68c6b454 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/attributes.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/attributes.rs @@ -14,6 +14,7 @@ use crate::native_bridge::{ PendingMediaLoadTerminalFollowup, }; use crate::util::v8_string; +use anyhow::Context; pub(in crate::native_bridge) fn media_autoplay_getter_function<'s>( scope: &mut v8::PinScope<'s, '_>, @@ -469,7 +470,7 @@ fn start_media_load( return; } let start = selected_source - .ok_or_else(|| "media resource selection found no supported URL".to_owned()) + .context(crate::network_host::ResourceFetchError::NoMediaSource) .and_then(|selected_source| { let request_url = selected_source.request_url; if unsafe { &mut *runtime_ptr } diff --git a/moli-renderer-v8/src/native_bridge/element/media/text_tracks.rs b/moli-renderer-v8/src/native_bridge/element/media/text_tracks.rs index 053f183e4ce..f041f238c77 100644 --- a/moli-renderer-v8/src/native_bridge/element/media/text_tracks.rs +++ b/moli-renderer-v8/src/native_bridge/element/media/text_tracks.rs @@ -1487,7 +1487,11 @@ fn apply_track_load_start( Ok(crate::network_host::TextTrackResourceFetchStart::Pending) => {} Ok(crate::network_host::TextTrackResourceFetchStart::PolicySkipped) => { let followup = unsafe { &mut *runtime_ptr } - .complete_pending_text_track_local_if_matches(handle, sequence, Ok(String::new())); + .complete_pending_text_track_local_if_matches( + handle, + sequence, + PendingTextTrackLoadTerminal::Ready(String::new()), + ); queue_text_track_terminal_followup(scope, runtime_ptr, handle, sequence, followup); } Ok(crate::network_host::TextTrackResourceFetchStart::Local(result)) => { @@ -1496,8 +1500,18 @@ fn apply_track_load_start( queue_text_track_terminal_followup(scope, runtime_ptr, handle, sequence, followup); } Err(error) => { + tracing::debug!( + track = handle.index(), + sequence = sequence.get(), + %error, + "text-track resource selection failed" + ); let followup = unsafe { &mut *runtime_ptr } - .complete_pending_text_track_local_if_matches(handle, sequence, Err(error)); + .complete_pending_text_track_local_if_matches( + handle, + sequence, + PendingTextTrackLoadTerminal::FetchFailed, + ); queue_text_track_terminal_followup(scope, runtime_ptr, handle, sequence, followup); } } diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs index 3e4b9a61373..848467d79de 100644 --- a/moli-renderer-v8/src/network_host.rs +++ b/moli-renderer-v8/src/network_host.rs @@ -18,6 +18,8 @@ mod media; mod preflight_events; mod request; mod request_scope; +mod resource_fetch_error; +pub(crate) use resource_fetch_error::ResourceFetchError; mod response; mod stylesheet_subresource; mod subresource; @@ -179,7 +181,7 @@ pub(crate) use self::stylesheet_subresource::{ StylesheetSubresourceFetchStart, start_stylesheet_subresource_fetch, }; pub(crate) use self::text_track::{ - TextTrackResourceFetchStart, start_text_track_resource_fetch, text_track_response_result, + TextTrackResourceFetchStart, start_text_track_resource_fetch, text_track_response_terminal, }; pub(crate) use self::url_helpers::merge_byte_string_request_headers; pub(in crate::network_host) use self::url_helpers::merge_subresource_request_headers; diff --git a/moli-renderer-v8/src/network_host/fetch/bindings.rs b/moli-renderer-v8/src/network_host/fetch/bindings.rs index 479a17cfe69..7e25187c779 100644 --- a/moli-renderer-v8/src/network_host/fetch/bindings.rs +++ b/moli-renderer-v8/src/network_host/fetch/bindings.rs @@ -251,10 +251,10 @@ fn window_fetch_callback_in_relevant_realm<'s>( return; } - if let Err(message) = moli_fetch::FetchUrlList::new(&prepared.resolved_url, &[]) + if let Err(error) = moli_fetch::FetchUrlList::new(&prepared.resolved_url, &[]) .validate_request_mode(prepared.request_mode, &prepared.request_origin) { - rv.set(make_rejected_promise(scope, &message).into()); + rv.set(make_rejected_promise(scope, &error.to_string()).into()); return; } diff --git a/moli-renderer-v8/src/network_host/font_face.rs b/moli-renderer-v8/src/network_host/font_face.rs index 38f7d709d22..a332ea793d6 100644 --- a/moli-renderer-v8/src/network_host/font_face.rs +++ b/moli-renderer-v8/src/network_host/font_face.rs @@ -4,7 +4,7 @@ use crate::{ native_bridge::{JsContextHost, WindowExecutionContextIdentity}, types::{SubresourceRequestInitiatorType, SubresourceResourceType}, }; -use anyhow::{Context, Result, anyhow, ensure}; +use anyhow::{Context, Result, ensure}; pub(crate) enum FontFaceFetchStart { Local(Vec), @@ -59,24 +59,21 @@ pub(crate) fn start_font_face_fetch( source: &str, ) -> Result { let host_ptr = crate::util::context_host_ptr_from_global_bridge(scope) - .context("FontFace URL loader is unavailable in this realm")?; + .context(ResourceFetchError::NoFontFaceRealm)?; // SAFETY: the current live realm owns the bridge. No author callback runs // while the host is used except its existing CSP notification boundary. let host: &mut JsContextHost = unsafe { &mut *host_ptr }; let identity = request_context .filter(|identity| host.window_execution_context_identity_is_current(*identity)) - .context("FontFace creation Window is no longer available")?; + .context(ResourceFetchError::StaleOwner)?; let owner = identity.dispatch_scope(); let resource_loader = host .document_resource_loader_for_dispatch_scope(owner) - .context("Font request has no live document resource loader")?; + .context(ResourceFetchError::NoResourceLoader)?; let environment = host .subresource_request_environment(&resource_loader, owner) - .context("Font request has no live document request environment")?; - let request_url = environment - .base_url - .join(source) - .context("failed to resolve FontFace source URL")?; + .context(ResourceFetchError::NoRequestEnvironment)?; + let request_url = environment.base_url.join(source)?; ensure!( host.font_request_allowed_by_csp( scope, @@ -85,14 +82,17 @@ pub(crate) fn start_font_face_fetch( &request_url, crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect, ), - "Font request blocked by Content Security Policy" + ResourceFetchError::ContentSecurityPolicyBlocked ); if let Some(response) = local_url_response(&request_url) { let response: crate::types::NavigationResponse = response.into(); let result = if (200..300).contains(&response.status) { Ok(FontFaceFetchStart::Local(response.body_bytes().to_vec())) } else { - Err(anyhow!("Font request failed")) + Err(ResourceFetchError::HttpStatus { + status: response.status, + } + .into()) }; host.record_get_subresource_network_result_with_initiator( environment.frame_id, @@ -112,7 +112,7 @@ pub(crate) fn start_font_face_fetch( environment, request_url, SubresourceFetchOptions::FONT, - )?; + ); let internal_id = host.record_font_face_fetch( v8::Global::new(scope, scope.get_current_context()), v8::Global::new(scope, face), diff --git a/moli-renderer-v8/src/network_host/media.rs b/moli-renderer-v8/src/network_host/media.rs index 08616af98da..83f310ef919 100644 --- a/moli-renderer-v8/src/network_host/media.rs +++ b/moli-renderer-v8/src/network_host/media.rs @@ -4,6 +4,7 @@ use crate::native_bridge::{ JsContextHost, MediaLoadSequenceId, OwnerDispatchScope, PendingMediaLoadOwner, }; use crate::types::SubresourceRequestInitiatorType; +use anyhow::{Context, Result}; use moli_fetch::{RequestCredentialsMode, RequestMode}; #[derive(Clone, Copy, Debug, Eq, PartialEq)] @@ -19,13 +20,13 @@ pub(crate) fn start_media_element_resource_fetch( media_handle: crate::document_runtime::DomHandle, sequence: MediaLoadSequenceId, request_url: url::Url, -) -> Result { +) -> Result { let pending = host .pending_media_load_sequence(media_handle) .filter(|pending| pending.id() == sequence) - .ok_or_else(|| "media lifecycle sequence is no longer pending".to_owned())?; + .context(ResourceFetchError::SequenceNotPending)?; if !host.pending_media_load_sequence_is_current(media_handle, sequence) { - return Err("media lifecycle sequence owner is stale".to_owned()); + return Err(ResourceFetchError::StaleOwner.into()); } let owner = match pending.owner() { PendingMediaLoadOwner::Main { owner, .. } @@ -36,25 +37,25 @@ pub(crate) fn start_media_element_resource_fetch( PendingMediaLoadOwner::Child { child_handle, .. } => { OwnerDispatchScope::Child(child_handle) } - _ => return Err("media request owner is stale".to_owned()), + _ => return Err(ResourceFetchError::StaleOwner.into()), }; let Some(resource_loader) = host.document_resource_loader_for_dispatch_scope(owner) else { return Ok(MediaElementResourceFetchStart::PolicySkipped); }; let environment = host .subresource_request_environment(&resource_loader, owner) - .ok_or_else(|| "media Document request environment is unavailable".to_owned())?; + .context(ResourceFetchError::NoRequestEnvironment)?; let element = host .dom_host() .node(media_handle) .and_then(crate::dom::native::Node::as_element) - .ok_or_else(|| "media element is unavailable".to_owned())?; + .context(ResourceFetchError::NoMediaElement)?; let options = if element.is_html_element("audio") { SubresourceFetchOptions::AUDIO } else if element.is_html_element("video") { SubresourceFetchOptions::VIDEO } else { - return Err("media lifecycle target is not an audio or video element".to_owned()); + return Err(ResourceFetchError::InvalidMediaElement.into()); }; let (request_mode, credentials_mode) = media_cross_origin_request_modes(element); @@ -89,8 +90,7 @@ pub(crate) fn start_media_element_resource_fetch( environment, request_url, options.with_request_modes(request_mode, credentials_mode), - ) - .map_err(|error| error.to_string())?; + ); let Some(internal_id) = host.record_media_subresource_fetch( v8::Global::new(scope, scope.get_current_context()), media_handle, @@ -104,7 +104,7 @@ pub(crate) fn start_media_element_resource_fetch( prepared.network_context.policy_context, prepared.pending_info.clone(), ) else { - return Err("media lifecycle sequence changed before request binding".to_owned()); + return Err(ResourceFetchError::OwnerChangedBeforeBinding.into()); }; prepared.dispatch(host, internal_id); Ok(MediaElementResourceFetchStart::Pending) diff --git a/moli-renderer-v8/src/network_host/resource_fetch_error.rs b/moli-renderer-v8/src/network_host/resource_fetch_error.rs new file mode 100644 index 00000000000..07c563b8e88 --- /dev/null +++ b/moli-renderer-v8/src/network_host/resource_fetch_error.rs @@ -0,0 +1,25 @@ +#[derive(Debug, thiserror::Error)] +pub(crate) enum ResourceFetchError { + #[error("resource load sequence is no longer pending")] + SequenceNotPending, + #[error("resource request owner is stale")] + StaleOwner, + #[error("Document resource loader is unavailable")] + NoResourceLoader, + #[error("Document request environment is unavailable")] + NoRequestEnvironment, + #[error("media element is unavailable")] + NoMediaElement, + #[error("media lifecycle target is not an audio or video element")] + InvalidMediaElement, + #[error("media resource selection found no supported URL")] + NoMediaSource, + #[error("resource owner changed before request binding")] + OwnerChangedBeforeBinding, + #[error("FontFace URL loader is unavailable in this realm")] + NoFontFaceRealm, + #[error("resource request blocked by Content Security Policy")] + ContentSecurityPolicyBlocked, + #[error("resource request returned HTTP {status}")] + HttpStatus { status: u16 }, +} diff --git a/moli-renderer-v8/src/network_host/response/cors.rs b/moli-renderer-v8/src/network_host/response/cors.rs index bc3fa240bbd..337e38e8ab7 100644 --- a/moli-renderer-v8/src/network_host/response/cors.rs +++ b/moli-renderer-v8/src/network_host/response/cors.rs @@ -83,7 +83,8 @@ pub(crate) fn validate_fetch_response_security_policy( ) -> Result<(), String> { let request_origin = request_origin.into(); head.url_list() - .validate_request_mode(request_mode, &request_origin)?; + .validate_request_mode(request_mode, &request_origin) + .map_err(|error| error.to_string())?; if request_mode == RequestMode::SameOrigin { return Ok(()); } @@ -135,7 +136,7 @@ pub(crate) fn validate_fetch_response_security_policy_with_body_classified( let request_origin = request_origin.into(); head.url_list() .validate_request_mode(request_mode, &request_origin) - .map_err(FetchResponseSecurityViolation::Rejected)?; + .map_err(|error| FetchResponseSecurityViolation::Rejected(error.to_string()))?; if request_mode == RequestMode::SameOrigin { return Ok(()); } diff --git a/moli-renderer-v8/src/network_host/stylesheet_subresource.rs b/moli-renderer-v8/src/network_host/stylesheet_subresource.rs index 3c78d4a0732..824f69df75b 100644 --- a/moli-renderer-v8/src/network_host/stylesheet_subresource.rs +++ b/moli-renderer-v8/src/network_host/stylesheet_subresource.rs @@ -29,17 +29,17 @@ pub(crate) fn start_stylesheet_subresource_fetch( ) -> Result { ensure!( host.stylesheet_subresource_load_delay_is_current(binding), - "stylesheet subresource document owner is stale" + ResourceFetchError::StaleOwner ); let owner = binding .child_handle() .map_or(OwnerDispatchScope::Top, OwnerDispatchScope::Child); let resource_loader = host .document_resource_loader_for_owner(binding.owner()) - .context("stylesheet Document resource authority is unavailable")?; + .context(ResourceFetchError::NoResourceLoader)?; let environment = host .subresource_request_environment(&resource_loader, owner) - .context("stylesheet Document request environment is unavailable")?; + .context(ResourceFetchError::NoRequestEnvironment)?; let (request_url, target) = request.into_parts(); let options = match &target { StylesheetSubresourceTarget::Image(_) => SubresourceFetchOptions::CSS_IMAGE, @@ -114,7 +114,7 @@ pub(crate) fn start_stylesheet_subresource_fetch( environment, request_url, options, - )?; + ); let internal_id = host .record_stylesheet_subresource_fetch( v8::Global::new(scope, scope.get_current_context()), @@ -129,7 +129,7 @@ pub(crate) fn start_stylesheet_subresource_fetch( target, prepared.pending_info.clone(), ) - .context("stylesheet subresource owner changed before request binding")?; + .context(ResourceFetchError::OwnerChangedBeforeBinding)?; prepared.dispatch(host, internal_id); Ok(StylesheetSubresourceFetchStart::Pending) diff --git a/moli-renderer-v8/src/network_host/subresource.rs b/moli-renderer-v8/src/network_host/subresource.rs index b32ddd012cf..01a9eedec86 100644 --- a/moli-renderer-v8/src/network_host/subresource.rs +++ b/moli-renderer-v8/src/network_host/subresource.rs @@ -11,7 +11,6 @@ use crate::{ PendingSubresourceFetchInfo, SubresourceFetchRegistration, SubresourceResourceType, }, }; -use anyhow::{Context, Result}; use moli_fetch::{ BrowserRequestMetadata, FetchCancelHandle, RequestCredentialsMode, RequestMode, RequestRedirectMode, RequestResourceType, @@ -103,7 +102,7 @@ impl PreparedSubresourceFetch { environment: SubresourceRequestEnvironment, request_url: url::Url, options: SubresourceFetchOptions, - ) -> Result { + ) -> Self { let SubresourceRequestEnvironment { document_url, request_origin, @@ -120,18 +119,22 @@ impl PreparedSubresourceFetch { "GET", options.credentials_mode, ); - let request = Request::new("GET", request_url.as_str(), None, Vec::new()) - .context("failed to create subresource GET request")? - .with_initiator_url(&document_url) - .with_request_origin(request_origin.clone()) - .with_resource_type(options.request_resource_type) - .with_page_network_policy() - .with_request_mode(options.request_mode) - .with_credentials_mode(options.credentials_mode) - .with_network_partition_key(network_partition_key.clone()) - .with_redirect_mode(RequestRedirectMode::Follow) - .with_browser_request_metadata(options.metadata) - .with_subframe_context(frame_id.is_some()); + let request = Request::new_browser( + "GET", + request_url.clone(), + None, + Vec::new(), + request_origin.clone(), + ) + .with_initiator_url(&document_url) + .with_resource_type(options.request_resource_type) + .with_page_network_policy() + .with_request_mode(options.request_mode) + .with_credentials_mode(options.credentials_mode) + .with_network_partition_key(network_partition_key.clone()) + .with_redirect_mode(RequestRedirectMode::Follow) + .with_browser_request_metadata(options.metadata) + .with_subframe_context(frame_id.is_some()); let pending_info = PendingSubresourceFetchInfo { internal_id: 0, network_request_handle: None, @@ -146,7 +149,7 @@ impl PreparedSubresourceFetch { resource_type: options.resource_type, request_cookie_report, }; - Ok(Self { + Self { registration: if host.should_intercept_subresource(options.resource_type) { SubresourceFetchRegistration::Intercepted } else { @@ -167,7 +170,7 @@ impl PreparedSubresourceFetch { destination: options.destination, }, resource_loader: resource_loader.clone(), - }) + } } pub(super) fn dispatch(self, host: &JsContextHost, internal_id: u64) { diff --git a/moli-renderer-v8/src/network_host/text_track.rs b/moli-renderer-v8/src/network_host/text_track.rs index f88c2c81041..035a9d2db8f 100644 --- a/moli-renderer-v8/src/network_host/text_track.rs +++ b/moli-renderer-v8/src/network_host/text_track.rs @@ -1,13 +1,14 @@ use super::subresource::{PreparedSubresourceFetch, SubresourceFetchOptions}; use super::*; use crate::document_runtime::DocumentSubresourceCspKind; -use crate::native_bridge::{JsContextHost, TextTrackLoadSequenceId}; +use crate::native_bridge::{JsContextHost, PendingTextTrackLoadTerminal, TextTrackLoadSequenceId}; use crate::types::{SubresourceRequestInitiatorType, SubresourceResourceType}; +use anyhow::{Context, Result}; use moli_fetch::{RequestCredentialsMode, RequestMode}; #[derive(Clone, Debug, Eq, PartialEq)] pub(crate) enum TextTrackResourceFetchStart { - Local(Result), + Local(PendingTextTrackLoadTerminal), PolicySkipped, Pending, } @@ -17,13 +18,13 @@ pub(crate) fn start_text_track_resource_fetch( host: &mut JsContextHost, track_handle: crate::document_runtime::DomHandle, sequence: TextTrackLoadSequenceId, -) -> Result { +) -> Result { let pending = host .pending_text_track_load_sequence(track_handle) .filter(|pending| pending.id() == sequence) - .ok_or_else(|| "text-track request sequence is no longer pending".to_owned())?; + .context(ResourceFetchError::SequenceNotPending)?; if !host.pending_text_track_load_sequence_is_current(track_handle, sequence) { - return Err("text-track request owner is stale".to_owned()); + return Err(ResourceFetchError::StaleOwner.into()); } let target = pending.target(); let owner = target.dispatch_scope(); @@ -33,22 +34,21 @@ pub(crate) fn start_text_track_resource_fetch( }; let environment = host .subresource_request_environment(&resource_loader, owner) - .ok_or_else(|| "text-track Document request environment is unavailable".to_owned())?; + .context(ResourceFetchError::NoRequestEnvironment)?; if pending.source().trim().is_empty() { - return Ok(TextTrackResourceFetchStart::Local(Err( - "text-track element has no source".to_owned(), - ))); + return Ok(TextTrackResourceFetchStart::Local( + PendingTextTrackLoadTerminal::FetchFailed, + )); } let request_url = url::Url::options() .base_url(Some(&environment.base_url)) - .parse(pending.source()) - .map_err(|error| error.to_string())?; + .parse(pending.source())?; let media = host .dom_host() .node(pending.media_handle()) .and_then(crate::dom::native::Node::as_element) .filter(|element| element.is_html_element("audio") || element.is_html_element("video")) - .ok_or_else(|| "text-track media parent is unavailable".to_owned())?; + .context(ResourceFetchError::NoMediaElement)?; let (request_mode, credentials_mode) = text_track_cross_origin_request_modes(media); moli_fetch::FetchUrlList::new(&request_url, &[]) .validate_request_mode(request_mode, &environment.request_origin)?; @@ -56,14 +56,14 @@ pub(crate) fn start_text_track_resource_fetch( .check_top_document_subresource_csp(scope, &request_url, DocumentSubresourceCspKind::Media) .blocks_request() { - return Ok(TextTrackResourceFetchStart::Local(Err( - "text-track request blocked by Content Security Policy".to_owned(), - ))); + return Ok(TextTrackResourceFetchStart::Local( + PendingTextTrackLoadTerminal::FetchFailed, + )); } if let Some(response) = local_url_response(&request_url) { let response: crate::protocol_types::NavigationResponse = response.into(); - let result = text_track_response_result(response.status, response.body_text()); + let terminal = text_track_response_terminal(response.status, response.body_text()); host.record_get_subresource_network_result_with_initiator( environment.frame_id, environment.document_url, @@ -72,7 +72,7 @@ pub(crate) fn start_text_track_resource_fetch( SubresourceRequestInitiatorType::Other, &Ok(response), ); - return Ok(TextTrackResourceFetchStart::Local(result)); + return Ok(TextTrackResourceFetchStart::Local(terminal)); } if !resource_loader @@ -89,8 +89,7 @@ pub(crate) fn start_text_track_resource_fetch( environment, request_url, SubresourceFetchOptions::TEXT_TRACK.with_request_modes(request_mode, credentials_mode), - ) - .map_err(|error| error.to_string())?; + ); let Some(internal_id) = host.record_text_track_subresource_fetch( v8::Global::new(scope, scope.get_current_context()), track_handle, @@ -104,17 +103,21 @@ pub(crate) fn start_text_track_resource_fetch( prepared.network_context.policy_context, prepared.pending_info.clone(), ) else { - return Err("text-track sequence changed before request binding".to_owned()); + return Err(ResourceFetchError::OwnerChangedBeforeBinding.into()); }; prepared.dispatch(host, internal_id); Ok(TextTrackResourceFetchStart::Pending) } -pub(crate) fn text_track_response_result(status: u16, body: &str) -> Result { - if !(200..300).contains(&status) { - return Err(format!("text-track fetch returned HTTP {status}")); +pub(crate) fn text_track_response_terminal( + status: u16, + body: &str, +) -> PendingTextTrackLoadTerminal { + if (200..300).contains(&status) { + PendingTextTrackLoadTerminal::Ready(body.to_owned()) + } else { + PendingTextTrackLoadTerminal::FetchFailed } - Ok(body.to_owned()) } fn text_track_cross_origin_request_modes( diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch.rs index fbe919278f2..87d0566c453 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch.rs @@ -18,7 +18,7 @@ use crate::RendererSyntheticResponseBody; use crate::content_security_policy::ContentSecurityPolicyRedirectStatus; use crate::document_runtime::DocumentRuntime; use crate::frame_owner_model::FrameDocumentModuleTerminalQueueFollowup; -use crate::native_bridge::{JsContextHost, OwnerDispatchScope}; +use crate::native_bridge::{JsContextHost, OwnerDispatchScope, PendingTextTrackLoadTerminal}; use crate::network::ResourceRequestClient; use crate::runtime::{ AuthorizedCurrentChildDocumentLoadCompletion, AuthorizedCurrentChildModuleFetchCompletion, @@ -361,7 +361,7 @@ fn apply_text_track_subresource_terminal( track_handle: crate::document_runtime::DomHandle, sequence: crate::native_bridge::TextTrackLoadSequenceId, internal_id: u64, - result: Result, + terminal: PendingTextTrackLoadTerminal, ) { let followup = context_host .borrow_mut() @@ -369,7 +369,7 @@ fn apply_text_track_subresource_terminal( track_handle, sequence, internal_id, - result, + terminal, ); let host_ptr: *mut JsContextHost = context_host.as_ref().as_ptr(); crate::native_bridge::element::queue_text_track_terminal_followup( diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs index 39e1f6a841c..338ca8317c5 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs @@ -776,7 +776,7 @@ impl ScriptVm { track_handle, sequence, pending.info.internal_id, - crate::network_host::text_track_response_result( + crate::network_host::text_track_response_terminal( response_status, observable_response.body_text(), ), @@ -924,7 +924,7 @@ impl ScriptVm { track_handle, sequence, pending.info.internal_id, - Err(error_text.clone()), + PendingTextTrackLoadTerminal::FetchFailed, ), PendingSubresourceContinuation::FontFace(face) => { let face = v8::Local::new(scope, face); diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs index 4e002ba3c77..f71e11d03d5 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/pending_fetch.rs @@ -1,5 +1,15 @@ use super::*; +#[derive(Debug, thiserror::Error)] +enum PendingSubresourceError { + #[error("unknown pending subresource fetch `{0}`")] + FetchNotFound(u64), + #[error("unknown pending subresource auth `{0}`")] + AuthNotFound(u64), + #[error("unknown pending subresource response `{0}`")] + ResponseNotFound(u64), +} + fn with_subresource_request_metadata( request: moli_fetch::Request, resource_type: SubresourceResourceType, @@ -32,7 +42,7 @@ fn request_for_pending_subresource( request_method: &str, request_headers: moli_fetch::RequestHeaders, request_body_bytes: Option, -) -> Result { +) -> moli_fetch::Request { if let Some(dispatch) = &pending.dispatch { let mut request = dispatch.request.clone(); request.url = request_url.clone(); @@ -46,18 +56,18 @@ fn request_for_pending_subresource( .recompute_site_context_for_request(request_url); request.body = request_body_bytes; request.request_headers = request_headers; - return Ok(request.with_redirect_headers(pending.redirect_headers.clone())); + return request.with_redirect_headers(pending.redirect_headers.clone()); } - let request = moli_fetch::Request::new_bytes( + let request = moli_fetch::Request::new_browser( request_method, - request_url.as_str(), + request_url.clone(), request_body_bytes, request_headers, - )? + pending.request_origin.clone(), + ) .with_redirect_headers(pending.redirect_headers.clone()) .with_initiator_url(&pending.info.document_url) - .with_request_origin(pending.request_origin.clone()) .with_request_mode(pending.request_mode) .with_use_cors_preflight(pending.continuation.use_cors_preflight()) .with_credentials_mode(pending.credentials_mode) @@ -96,10 +106,7 @@ fn request_for_pending_subresource( } SubresourceResourceType::WebSocket | SubresourceResourceType::Document => request, }; - Ok(with_subresource_request_metadata( - request, - pending.info.resource_type, - )) + with_subresource_request_metadata(request, pending.info.resource_type) } impl ScriptVm { @@ -117,7 +124,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_fetch(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource fetch `{internal_id}`"))?; + .ok_or(PendingSubresourceError::FetchNotFound(internal_id))?; let headers = headers.map(|override_headers| match override_headers { moli_fetch::RequestHeaderOverride::CurrentRequest { headers, @@ -471,7 +478,7 @@ impl ScriptVm { &request_method, request_headers.clone(), pending.info.request_body_bytes.clone(), - )?; + ); let cancel_handle = moli_fetch::FetchCancelHandle::new(); pending.load.attach_cancel_handle(cancel_handle.clone()); let state = RunningSubresourceFetchState { @@ -639,7 +646,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_auth(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource auth `{internal_id}`"))?; + .ok_or(PendingSubresourceError::AuthNotFound(internal_id))?; if !pending.pending.load.try_restart_with_auth() { // Reuse the terminal auth path to settle Window and Worker consumers. self._context_host @@ -783,7 +790,7 @@ impl ScriptVm { request_body .as_ref() .and_then(|_| pending_fetch.info.request_body_bytes.clone()), - )?; + ); for redirect in &response.redirect_chain { request.apply_redirect_status(redirect.status); } @@ -850,7 +857,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_auth(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource auth `{internal_id}`"))?; + .ok_or(PendingSubresourceError::AuthNotFound(internal_id))?; if let Some(target) = WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) { @@ -940,7 +947,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_auth(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource auth `{internal_id}`"))?; + .ok_or(PendingSubresourceError::AuthNotFound(internal_id))?; let PendingSubresourceAuthState { pending, request_url, @@ -1002,7 +1009,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_fetch(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource fetch `{internal_id}`"))?; + .ok_or(PendingSubresourceError::FetchNotFound(internal_id))?; let PendingSubresourceFetchState { dispatch, redirect_headers: _, @@ -1206,7 +1213,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_fetch(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource fetch `{internal_id}`"))?; + .ok_or(PendingSubresourceError::FetchNotFound(internal_id))?; let PendingSubresourceFetchState { dispatch, redirect_headers: _, @@ -1692,7 +1699,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_response(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource response `{internal_id}`"))?; + .ok_or(PendingSubresourceError::ResponseNotFound(internal_id))?; if let Some(target) = WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) { @@ -1856,7 +1863,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_response(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource response `{internal_id}`"))?; + .ok_or(PendingSubresourceError::ResponseNotFound(internal_id))?; if let Some(target) = WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) { @@ -1977,7 +1984,7 @@ impl ScriptVm { ._context_host .borrow_mut() .take_pending_subresource_response(internal_id) - .ok_or_else(|| anyhow!("unknown pending subresource response `{internal_id}`"))?; + .ok_or(PendingSubresourceError::ResponseNotFound(internal_id))?; if let Some(target) = WorkerOwnedFetchTarget::from_continuation(&pending.pending.continuation) { diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs index 97673364e49..d98789ded66 100644 --- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs +++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs @@ -756,7 +756,7 @@ impl ScriptVm { *track_handle, *sequence, started.internal_id, - Err(error_text.clone()), + PendingTextTrackLoadTerminal::FetchFailed, ), PendingSubresourceContinuation::FontFace(face) => { let face = v8::Local::new(scope, face); @@ -999,7 +999,7 @@ impl ScriptVm { *track_handle, *sequence, started.internal_id, - Err("text-track response unexpectedly used streaming transport".to_owned()), + PendingTextTrackLoadTerminal::FetchFailed, ), PendingSubresourceContinuation::FontFace(face) => { let face = v8::Local::new(scope, face); diff --git a/moli-renderer-v8/src/worker/global_scope/fetch.rs b/moli-renderer-v8/src/worker/global_scope/fetch.rs index e1ea5371d67..8c1a8e257b1 100644 --- a/moli-renderer-v8/src/worker/global_scope/fetch.rs +++ b/moli-renderer-v8/src/worker/global_scope/fetch.rs @@ -165,11 +165,11 @@ pub(in crate::worker) fn spawn_worker_fetch_network( ) { tokio::task::spawn_local(async move { let loader = load.request_client(); - let (result, network_request_headers) = if let Err(message) = + let (result, network_request_headers) = if let Err(error) = moli_fetch::FetchUrlList::new(&resolved_url, &[]) .validate_request_mode(request_mode, &moli_url::WebOrigin::from_url(&document_url)) { - (Err(message), None) + (Err(error.to_string()), None) } else if let Some(result) = local_url_response_result(&resolved_url, &method) { ( result @@ -2127,10 +2127,10 @@ pub(in crate::worker) fn worker_fetch_callback<'s>( return; } - if let Err(message) = moli_fetch::FetchUrlList::new(&resolved_url, &[]) + if let Err(error) = moli_fetch::FetchUrlList::new(&resolved_url, &[]) .validate_request_mode(request_mode, &moli_url::WebOrigin::from_url(&document_url)) { - rv.set(make_rejected_promise(scope, &message).into()); + rv.set(make_rejected_promise(scope, &error.to_string()).into()); return; }