refactor(fetch): preserve typed resource loading errors

This commit is contained in:
ldm0
2026-11-07 12:28:49 +08:00
parent d8e6e66f32
commit 5c0107a1a8
23 changed files with 204 additions and 128 deletions
Generated
+1
View File
@@ -2948,6 +2948,7 @@ dependencies = [
"rcgen",
"serde",
"strum",
"thiserror",
"tokio",
"tokio-rustls",
"tokio-tungstenite",
+1
View File
@@ -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"
+12 -5
View File
@@ -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(())
}
+1 -1
View File
@@ -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,
+2 -2
View File
@@ -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
+8 -5
View File
@@ -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::<crate::RequestModeError>(),
Some(crate::RequestModeError::CrossOrigin { url }) if url == &cross_origin_url
));
assert_eq!(
calls.load(Ordering::SeqCst),
0,
@@ -249,7 +249,7 @@ impl JsContextHost {
&mut self,
track_handle: DomHandle,
sequence: TextTrackLoadSequenceId,
result: Result<String, String>,
terminal: PendingTextTrackLoadTerminal,
) -> Option<PendingTextTrackLoadTerminalFollowup> {
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<String, String>,
terminal: PendingTextTrackLoadTerminal,
) -> Option<PendingTextTrackLoadTerminalFollowup> {
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(),
@@ -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 }
@@ -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);
}
}
+3 -1
View File
@@ -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;
@@ -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;
}
+12 -12
View File
@@ -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<u8>),
@@ -59,24 +59,21 @@ pub(crate) fn start_font_face_fetch(
source: &str,
) -> Result<FontFaceFetchStart> {
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),
+10 -10
View File
@@ -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<MediaElementResourceFetchStart, String> {
) -> Result<MediaElementResourceFetchStart> {
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)
@@ -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 },
}
@@ -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(());
}
@@ -29,17 +29,17 @@ pub(crate) fn start_stylesheet_subresource_fetch(
) -> Result<StylesheetSubresourceFetchStart> {
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)
@@ -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> {
) -> 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) {
+27 -24
View File
@@ -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<String, String>),
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<TextTrackResourceFetchStart, String> {
) -> Result<TextTrackResourceFetchStart> {
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<String, String> {
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(
@@ -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<String, String>,
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(
@@ -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);
@@ -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<bytes::Bytes>,
) -> Result<moli_fetch::Request> {
) -> 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)
{
@@ -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);
@@ -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;
}