mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
refactor(fetch): preserve typed resource loading errors
This commit is contained in:
Generated
+1
@@ -2948,6 +2948,7 @@ dependencies = [
|
||||
"rcgen",
|
||||
"serde",
|
||||
"strum",
|
||||
"thiserror",
|
||||
"tokio",
|
||||
"tokio-rustls",
|
||||
"tokio-tungstenite",
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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(())
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user