Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(network): distinguish stylesheet declarations from requests

ldm0a92ae9df3c86
diff --git a/moli-renderer-v8/src/css_resource_urls.rs b/moli-renderer-v8/src/css_resource_urls.rs
index 839a0e958..dd88a149e 100644
--- a/moli-renderer-v8/src/css_resource_urls.rs
+++ b/moli-renderer-v8/src/css_resource_urls.rs
@@ -15,82 +15,110 @@ pub(crate) enum StylesheetLoadBlockingResourceKind {
Font,
}
+/// Discovered resources. A font declaration may resolve entirely via local().
#[derive(Clone, Debug, PartialEq)]
-pub(crate) struct StylesheetLoadBlockingResource {
- request_url: Option<Url>,
- kind: StylesheetLoadBlockingResourceKind,
- web_font: Option<StylesheetWebFont>,
+pub(crate) enum StylesheetLoadBlockingResource {
+ Image(Url),
+ Font {
+ request_url: Option<Url>,
+ font: StylesheetWebFont,
+ },
}
impl StylesheetLoadBlockingResource {
- fn new(request_url: Url, kind: StylesheetLoadBlockingResourceKind) -> Self {
- Self {
- request_url: Some(request_url),
- kind,
- web_font: None,
- }
- }
-
pub(crate) fn image(request_url: Url) -> Self {
- Self::new(request_url, StylesheetLoadBlockingResourceKind::Image)
+ Self::Image(request_url)
}
pub(crate) fn font(request_url: Option<Url>, web_font: StylesheetWebFont) -> Self {
- Self {
+ Self::Font {
request_url,
- kind: StylesheetLoadBlockingResourceKind::Font,
- web_font: Some(web_font),
+ font: web_font,
}
}
pub(crate) fn request_url(&self) -> Option<&Url> {
- self.request_url.as_ref()
+ match self {
+ Self::Image(url) => Some(url),
+ Self::Font { request_url, .. } => request_url.as_ref(),
+ }
}
- pub(crate) fn with_request_url(mut self, url: Url) -> Self {
- self.request_url = Some(url);
- self
+ pub(crate) fn web_font(&self) -> Option<&StylesheetWebFont> {
+ match self {
+ Self::Image(_) => None,
+ Self::Font { font, .. } => Some(font),
+ }
}
- pub(crate) fn into_parts(self) -> (Option<Url>, Option<StylesheetWebFont>) {
- (self.request_url, self.web_font)
+ pub(crate) fn kind(&self) -> StylesheetLoadBlockingResourceKind {
+ match self {
+ Self::Image(_) => StylesheetLoadBlockingResourceKind::Image,
+ Self::Font { .. } => StylesheetLoadBlockingResourceKind::Font,
+ }
}
+}
- pub(crate) fn web_font(&self) -> Option<&StylesheetWebFont> {
- self.web_font.as_ref()
+/// A selected network source, after local source resolution and request binding.
+#[derive(Clone, Debug)]
+pub(crate) struct StylesheetSubresourceRequest {
+ url: Url,
+ target: StylesheetSubresourceTarget,
+}
+
+/// The continuation retained after the request URL has moved into the network
+/// loader. Image tracking is optional; font request identity is mandatory.
+#[derive(Clone, Debug)]
+pub(crate) enum StylesheetSubresourceTarget {
+ Image(Option<crate::native_bridge::CssImageResourceRequestIdentity>),
+ Font(BoundStylesheetWebFont),
+}
+
+impl StylesheetSubresourceRequest {
+ pub(crate) fn image(
+ url: Url,
+ identity: Option<crate::native_bridge::CssImageResourceRequestIdentity>,
+ ) -> Self {
+ Self {
+ url,
+ target: StylesheetSubresourceTarget::Image(identity),
+ }
}
- pub(crate) fn bind_web_font_request(mut self, request_id: u64) -> Self {
- self.web_font = self
- .web_font
- .take()
- .map(|font| font.bind_request(request_id));
- self
+ pub(crate) fn font(url: Url, font: BoundStylesheetWebFont) -> Self {
+ Self {
+ url,
+ target: StylesheetSubresourceTarget::Font(font),
+ }
}
- pub(crate) fn kind(&self) -> StylesheetLoadBlockingResourceKind {
- self.kind
+ pub(crate) fn url(&self) -> &Url {
+ &self.url
+ }
+
+ pub(crate) fn target(&self) -> &StylesheetSubresourceTarget {
+ &self.target
+ }
+
+ pub(crate) fn into_parts(self) -> (Url, StylesheetSubresourceTarget) {
+ (self.url, self.target)
}
}
-/// Parsed `@font-face` metadata that stays attached to the exact resource
-/// request until its owner-validated completion.
+/// Parsed declaration metadata, before any network source is selected.
#[derive(Clone, Debug, PartialEq)]
pub(crate) struct StylesheetWebFont {
slot: String,
face: WebFontFace,
sources: Vec<moli_css_parse::CssFontSource>,
- request_id: Option<u64>,
}
impl StylesheetWebFont {
- pub(crate) fn bind_request(mut self, request_id: u64) -> Self {
- self.request_id = Some(request_id);
- self
- }
-
- pub(crate) fn request_id(&self) -> Option<u64> {
- self.request_id
+ pub(crate) fn bind_request(self, request_id: u64) -> BoundStylesheetWebFont {
+ BoundStylesheetWebFont {
+ font: self,
+ request_id,
+ }
}
pub(crate) fn sources(&self) -> &[moli_css_parse::CssFontSource] {
@@ -106,28 +134,49 @@ impl StylesheetWebFont {
}
}
+/// Declaration metadata tied to one exact pending request in its Document.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct BoundStylesheetWebFont {
+ font: StylesheetWebFont,
+ request_id: u64,
+}
+
+impl BoundStylesheetWebFont {
+ pub(crate) fn request_id(&self) -> u64 {
+ self.request_id
+ }
+
+ pub(crate) fn font(&self) -> &StylesheetWebFont {
+ &self.font
+ }
+
+ pub(crate) fn into_font(self) -> StylesheetWebFont {
+ self.font
+ }
+}
+
#[derive(Clone, Debug)]
pub(crate) struct CompletedStylesheetWebFont {
- request: StylesheetWebFont,
+ request: BoundStylesheetWebFont,
bytes: Option<Vec<u8>>,
}
impl CompletedStylesheetWebFont {
- pub(crate) fn response(request: StylesheetWebFont, bytes: Vec<u8>) -> Self {
+ pub(crate) fn response(request: BoundStylesheetWebFont, bytes: Vec<u8>) -> Self {
Self {
request,
bytes: Some(bytes),
}
}
- pub(crate) fn failure(request: StylesheetWebFont) -> Self {
+ pub(crate) fn failure(request: BoundStylesheetWebFont) -> Self {
Self {
request,
bytes: None,
}
}
- pub(crate) fn into_parts(self) -> (StylesheetWebFont, Option<Vec<u8>>) {
+ pub(crate) fn into_parts(self) -> (BoundStylesheetWebFont, Option<Vec<u8>>) {
(self.request, self.bytes)
}
}
@@ -163,7 +212,7 @@ fn stylesheet_web_font_resources(
}
/// Projects one already-parsed and serialized `@font-face` rule into the
-/// typed request metadata retained by the style world.
+/// declaration metadata retained by the style world.
pub(crate) fn stylesheet_web_font_resource(
css_text: &str,
base_url: &Url,
@@ -241,7 +290,6 @@ fn stylesheet_web_font_resource_with_descriptor(
slot,
face: descriptor.into_face(),
sources,
- request_id: None,
},
)
}
@@ -405,11 +453,9 @@ mod tests {
]
);
let web_font = resources[0]
- .web_font
- .as_ref()
+ .web_font()
.expect("font resource should retain its descriptors");
assert!(web_font.slot().starts_with("stylesheet-font:"));
- assert_eq!(web_font.request_id(), None);
assert_eq!(web_font.face().family_name(), "Demo");
assert_eq!(web_font.face().weight(), Some(625.0));
assert_eq!(web_font.face().stretch(), Some(87.5));
diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout.rs b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
index 83d99ee2a..ff55fb8e7 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/layout.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
@@ -7,7 +7,9 @@ use moli_layout::{
use super::JsContextHost;
use super::layout_state::InferredFrameStyleViewportCacheKey;
use crate::{
- css_resource_urls::{CompletedStylesheetWebFont, StylesheetLoadBlockingResource},
+ css_resource_urls::{
+ CompletedStylesheetWebFont, StylesheetLoadBlockingResource, StylesheetSubresourceRequest,
+ },
document_runtime::DomHandle,
native_bridge::element::iframe_handle_viewport,
script_vm::web_fonts::DocumentWebFontCompletion,
@@ -659,7 +661,7 @@ impl JsContextHost {
&self,
document: DomHandle,
resource: StylesheetLoadBlockingResource,
- ) -> Option<StylesheetLoadBlockingResource> {
+ ) -> Option<StylesheetSubresourceRequest> {
self.document_layout_state
.borrow_mut()
.admit(document, self.document_handle(), resource)
diff --git a/moli-renderer-v8/src/native_bridge/context_host/layout_state.rs b/moli-renderer-v8/src/native_bridge/context_host/layout_state.rs
index e6d8bfd5e..0de9bb1ae 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/layout_state.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/layout_state.rs
@@ -4,7 +4,9 @@ use moli_layout::{DocumentLayoutServices, FrozenLayoutTree, LayoutViewport};
use super::layout_snapshot::LatestLayoutTreeCache;
use crate::{
- css_resource_urls::{CompletedStylesheetWebFont, StylesheetLoadBlockingResource},
+ css_resource_urls::{
+ CompletedStylesheetWebFont, StylesheetLoadBlockingResource, StylesheetSubresourceRequest,
+ },
document_runtime::DomHandle,
script_vm::web_fonts::{DocumentWebFontCompletion, DocumentWebFontState},
style_engine::{StyleViewport, StylesheetResourceGeneration, StyloStyleEnvironment},
@@ -336,7 +338,7 @@ impl DocumentLayoutState {
document: DomHandle,
main_document: DomHandle,
resource: StylesheetLoadBlockingResource,
- ) -> Option<StylesheetLoadBlockingResource> {
+ ) -> Option<StylesheetSubresourceRequest> {
// Ready faces are revisited by read-only font projections.
self.with_web_fonts_for_document(document, main_document, |fonts, services| {
fonts.admit(resource, services)
diff --git a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs
index 65eacdc59..048b11bf5 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs
@@ -1211,8 +1211,7 @@ impl JsContextHost {
request_mode: moli_fetch::RequestMode,
network_partition_key: Option<String>,
policy_context: crate::types::SubresourcePolicyContext,
- web_font: Option<crate::css_resource_urls::StylesheetWebFont>,
- css_image: Option<crate::native_bridge::CssImageResourceRequestIdentity>,
+ target: crate::css_resource_urls::StylesheetSubresourceTarget,
mut info: PendingSubresourceFetchInfo,
) -> Option<u64> {
if !self.stylesheet_subresource_load_delay_is_current(binding) {
@@ -1247,8 +1246,7 @@ impl JsContextHost {
policy_context,
continuation: PendingSubresourceContinuation::StylesheetSubresource {
binding,
- web_font,
- css_image,
+ target,
},
deferred_request_started: false,
},
diff --git a/moli-renderer-v8/src/network_host/stylesheet_subresource.rs b/moli-renderer-v8/src/network_host/stylesheet_subresource.rs
index 4804e3ce7..eee844363 100644
--- a/moli-renderer-v8/src/network_host/stylesheet_subresource.rs
+++ b/moli-renderer-v8/src/network_host/stylesheet_subresource.rs
@@ -2,8 +2,7 @@ use super::subresource::{PreparedSubresourceFetch, SubresourceFetchOptions};
use super::*;
use crate::{
css_resource_urls::{
- CompletedStylesheetWebFont, StylesheetLoadBlockingResource,
- StylesheetLoadBlockingResourceKind,
+ CompletedStylesheetWebFont, StylesheetSubresourceRequest, StylesheetSubresourceTarget,
},
frame_owner_model::StylesheetSubresourceLoadDelayBinding,
native_bridge::{JsContextHost, OwnerDispatchScope},
@@ -26,8 +25,7 @@ pub(crate) fn start_stylesheet_subresource_fetch(
scope: &mut v8::PinScope<'_, '_>,
host: &mut JsContextHost,
binding: StylesheetSubresourceLoadDelayBinding,
- resource: StylesheetLoadBlockingResource,
- css_image: Option<crate::native_bridge::CssImageResourceRequestIdentity>,
+ request: StylesheetSubresourceRequest,
) -> Result<StylesheetSubresourceFetchStart> {
ensure!(
host.stylesheet_subresource_load_delay_is_current(binding),
@@ -42,93 +40,60 @@ pub(crate) fn start_stylesheet_subresource_fetch(
let environment = host
.subresource_request_environment(&resource_loader, owner)
.context("stylesheet Document request environment is unavailable")?;
- let resource_kind = resource.kind();
- ensure!(
- css_image.is_none() || resource_kind == StylesheetLoadBlockingResourceKind::Image,
- "a stylesheet CSS image identity was bound to a non-image resource"
- );
- let is_web_font = resource_kind == StylesheetLoadBlockingResourceKind::Font;
- if is_web_font {
- let web_font = resource
- .web_font()
- .context("Document stylesheet font is missing parsed @font-face metadata")?;
- ensure!(
- web_font.request_id().is_some(),
- "Document stylesheet font is missing its admitted request identity"
- );
- }
- let (request_url, web_font) = resource.into_parts();
- let request_url =
- request_url.context("admitted stylesheet subresource is missing its network URL")?;
- let options = match resource_kind {
- StylesheetLoadBlockingResourceKind::Image => SubresourceFetchOptions::CSS_IMAGE,
- StylesheetLoadBlockingResourceKind::Font => SubresourceFetchOptions::FONT,
+ let (request_url, target) = request.into_parts();
+ let options = match &target {
+ StylesheetSubresourceTarget::Image(_) => SubresourceFetchOptions::CSS_IMAGE,
+ StylesheetSubresourceTarget::Font(_) => SubresourceFetchOptions::FONT,
};
let resource_type = options.resource_type;
if let Some(response) = local_url_response(&request_url) {
let mut response: crate::protocol_types::NavigationResponse = response.into();
- let encoded = (resource_kind == StylesheetLoadBlockingResourceKind::Image).then(|| {
- let manager = host
- .document_resource_loader_for_owner(binding.owner())
- .map_or_else(
- moli_parkable_image::ParkableImageManager::default,
- |loader| {
- let runner = loader.task_runner();
- loader.request_client().parkable_image_manager(&runner)
- },
+ let terminal = match target {
+ StylesheetSubresourceTarget::Image(identity) => {
+ let runner = resource_loader.task_runner();
+ let encoded = resource_loader
+ .request_client()
+ .parkable_image_manager(&runner)
+ .from_frozen_bytes(response.take_body_bytes());
+ if let Some(identity) = identity {
+ let descriptor = crate::network_host::image_response_descriptor_from_parkable(
+ &response, &encoded,
+ );
+ let _ = host.complete_stylesheet_css_image_response(
+ &identity,
+ descriptor,
+ encoded.clone(),
+ );
+ }
+ host.record_get_subresource_network_result_with_body_and_initiator(
+ environment.frame_id,
+ environment.document_url,
+ request_url,
+ resource_type,
+ SubresourceRequestInitiatorType::Css,
+ &Ok(response),
+ crate::types::SubresourceResponseBody::from_parkable_image(encoded),
);
- manager.from_frozen_bytes(response.take_body_bytes())
- });
- if let Some(identity) = css_image.as_ref() {
- let descriptor = crate::network_host::image_response_descriptor_from_parkable(
- &response,
- encoded
- .as_ref()
- .expect("a local CSS image must have parkable bytes"),
- );
- let _ = host.complete_stylesheet_css_image_response(
- identity,
- descriptor,
- encoded
- .as_ref()
- .expect("a local CSS image must have parkable bytes")
- .clone(),
- );
- }
- let terminal = if is_web_font {
- let font = web_font.expect("web-font metadata was validated before consumption");
- StylesheetSubresourceFetchStart::WebFontSettled(
- if (200..=299).contains(&response.status) {
+ StylesheetSubresourceFetchStart::Settled
+ }
+ StylesheetSubresourceTarget::Font(font) => {
+ let terminal = if (200..=299).contains(&response.status) {
CompletedStylesheetWebFont::response(font, response.clone_body_bytes())
} else {
CompletedStylesheetWebFont::failure(font)
- },
- )
- } else {
- StylesheetSubresourceFetchStart::Settled
+ };
+ host.record_get_subresource_network_result_with_initiator(
+ environment.frame_id,
+ environment.document_url,
+ request_url,
+ resource_type,
+ SubresourceRequestInitiatorType::Css,
+ &Ok(response),
+ );
+ StylesheetSubresourceFetchStart::WebFontSettled(terminal)
+ }
};
- let result = Ok(response);
- if let Some(encoded) = encoded {
- host.record_get_subresource_network_result_with_body_and_initiator(
- environment.frame_id,
- environment.document_url,
- request_url,
- resource_type,
- SubresourceRequestInitiatorType::Css,
- &result,
- crate::types::SubresourceResponseBody::from_parkable_image(encoded),
- );
- } else {
- host.record_get_subresource_network_result_with_initiator(
- environment.frame_id,
- environment.document_url,
- request_url,
- resource_type,
- SubresourceRequestInitiatorType::Css,
- &result,
- );
- }
host.settle_stylesheet_subresource_load_delay(binding);
return Ok(terminal);
}
@@ -137,11 +102,9 @@ pub(crate) fn start_stylesheet_subresource_fetch(
.request_client()
.optional_resource_fetch_enabled(resource_type)
{
- if let Some(identity) = css_image.as_ref() {
- let _ = host.fail_stylesheet_css_image(identity);
- }
+ let terminal = synchronous_failure_terminal(host, target);
host.settle_stylesheet_subresource_load_delay(binding);
- return Ok(synchronous_failure_terminal(is_web_font, web_font));
+ return Ok(terminal);
}
let prepared = PreparedSubresourceFetch::prepare(
scope,
@@ -162,8 +125,7 @@ pub(crate) fn start_stylesheet_subresource_fetch(
options.request_mode,
prepared.network_partition_key.clone(),
prepared.network_context.policy_context,
- web_font,
- css_image,
+ target,
prepared.pending_info.clone(),
)
.context("stylesheet subresource owner changed before request binding")?;
@@ -177,14 +139,18 @@ pub(crate) fn start_stylesheet_subresource_fetch(
}
fn synchronous_failure_terminal(
- is_web_font: bool,
- web_font: Option<crate::css_resource_urls::StylesheetWebFont>,
+ host: &mut JsContextHost,
+ target: StylesheetSubresourceTarget,
) -> StylesheetSubresourceFetchStart {
- if is_web_font {
- StylesheetSubresourceFetchStart::WebFontSettled(CompletedStylesheetWebFont::failure(
- web_font.expect("web-font metadata was validated before consumption"),
- ))
- } else {
- StylesheetSubresourceFetchStart::Settled
+ match target {
+ StylesheetSubresourceTarget::Image(identity) => {
+ if let Some(identity) = identity {
+ let _ = host.fail_stylesheet_css_image(&identity);
+ }
+ StylesheetSubresourceFetchStart::Settled
+ }
+ StylesheetSubresourceTarget::Font(font) => StylesheetSubresourceFetchStart::WebFontSettled(
+ CompletedStylesheetWebFont::failure(font),
+ ),
}
}
diff --git a/moli-renderer-v8/src/script_vm/layout.rs b/moli-renderer-v8/src/script_vm/layout.rs
index 8f06f6aba..c06c680f7 100644
--- a/moli-renderer-v8/src/script_vm/layout.rs
+++ b/moli-renderer-v8/src/script_vm/layout.rs
@@ -483,13 +483,22 @@ impl ScriptVm {
web_fonts::DocumentWebFontCompletion::Stale => {
tracing::debug!("discarded superseded document web font response")
}
- web_fonts::DocumentWebFontCompletion::Retry(resource) => {
+ web_fonts::DocumentWebFontCompletion::Retry(request) => {
let binding = self
._context_host
.borrow_mut()
.accept_current_stylesheet_subresource_load_delay_for_document(document);
- if let Some(binding) = binding {
- self.start_stylesheet_subresource_fetches(vec![(binding, *resource)]);
+ if let Some(binding) = binding
+ && let Err(error) = self.with_default_context_scope(move |scope, host_ptr| {
+ crate::document_runtime::DocumentRuntime::start_stylesheet_subresource_requests_in_current_scope(
+ scope, host_ptr, vec![(binding, *request)],
+ );
+ Ok(())
+ })
+ {
+ self.record_runtime_warning(format_args!(
+ "failed to enter stylesheet subresource request scope: {error}"
+ ));
}
}
}
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 3552ef049..498ef9433 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
@@ -1,4 +1,5 @@
use super::*;
+use crate::css_resource_urls::StylesheetSubresourceTarget;
impl ScriptVm {
pub(super) fn resolve_network_only_subresource_fetch(
@@ -773,40 +774,39 @@ impl ScriptVm {
}
PendingSubresourceContinuation::StylesheetSubresource {
binding,
- web_font,
- css_image,
+ target,
} => {
- if let Some(identity) = css_image.as_ref() {
- let descriptor = crate::network_host::image_response_descriptor_from_parkable(
- &observable_response,
- parkable_image
- .as_ref()
- .expect("a CSS image response must be parkable"),
- );
- let _ = context_host
- .borrow_mut()
- .complete_stylesheet_css_image_response(
- identity,
- descriptor,
- parkable_image
+ completed_web_font = match target {
+ StylesheetSubresourceTarget::Image(identity) => {
+ if let Some(identity) = identity {
+ let encoded = parkable_image
.as_ref()
- .expect("a CSS image response must be parkable")
- .clone(),
- );
- }
- completed_web_font = web_font.map(|font| {
- let terminal = if (200..=299).contains(&response_status)
- && !opaque_response_blocked
- {
- crate::css_resource_urls::CompletedStylesheetWebFont::response(
- font,
- observable_response.clone_body_bytes(),
- )
- } else {
- crate::css_resource_urls::CompletedStylesheetWebFont::failure(font)
- };
- (binding, terminal)
- });
+ .expect("a CSS image response must be parkable");
+ let descriptor = crate::network_host::image_response_descriptor_from_parkable(
+ &observable_response, encoded,
+ );
+ let _ = context_host
+ .borrow_mut()
+ .complete_stylesheet_css_image_response(
+ &identity, descriptor, encoded.clone(),
+ );
+ }
+ None
+ }
+ StylesheetSubresourceTarget::Font(font) => {
+ let terminal = if (200..=299).contains(&response_status)
+ && !opaque_response_blocked
+ {
+ crate::css_resource_urls::CompletedStylesheetWebFont::response(
+ font,
+ observable_response.clone_body_bytes(),
+ )
+ } else {
+ crate::css_resource_urls::CompletedStylesheetWebFont::failure(font)
+ };
+ Some((binding, terminal))
+ }
+ };
apply_stylesheet_subresource_terminal(&context_host, binding);
}
PendingSubresourceContinuation::Beacon
@@ -916,17 +916,22 @@ impl ScriptVm {
}
PendingSubresourceContinuation::StylesheetSubresource {
binding,
- web_font,
- css_image,
+ target,
} => {
- if let Some(identity) = css_image.as_ref() {
- let _ = context_host
- .borrow_mut()
- .fail_stylesheet_css_image(identity);
- }
- completed_web_font = web_font.map(|font| {
- (binding, crate::css_resource_urls::CompletedStylesheetWebFont::failure(font))
- });
+ completed_web_font = match target {
+ StylesheetSubresourceTarget::Image(identity) => {
+ if let Some(identity) = identity {
+ let _ = context_host
+ .borrow_mut()
+ .fail_stylesheet_css_image(&identity);
+ }
+ None
+ }
+ StylesheetSubresourceTarget::Font(font) => Some((
+ binding,
+ crate::css_resource_urls::CompletedStylesheetWebFont::failure(font),
+ )),
+ };
apply_stylesheet_subresource_terminal(&context_host, binding);
}
PendingSubresourceContinuation::Beacon
diff --git a/moli-renderer-v8/src/script_vm/tests/child_document_web_fonts.rs b/moli-renderer-v8/src/script_vm/tests/child_document_web_fonts.rs
index a95d3ca84..96a351a10 100644
--- a/moli-renderer-v8/src/script_vm/tests/child_document_web_fonts.rs
+++ b/moli-renderer-v8/src/script_vm/tests/child_document_web_fonts.rs
@@ -1,7 +1,8 @@
use super::*;
use crate::{
css_resource_urls::{
- CompletedStylesheetWebFont, StylesheetLoadBlockingResource,
+ BoundStylesheetWebFont, CompletedStylesheetWebFont, StylesheetLoadBlockingResource,
+ StylesheetSubresourceRequest, StylesheetSubresourceTarget,
stylesheet_load_blocking_font_resources,
},
protocol_types::OptionalResourceFetchMask,
@@ -19,10 +20,16 @@ fn font_resource() -> StylesheetLoadBlockingResource {
.unwrap()
}
-fn font_response(resource: &StylesheetLoadBlockingResource) -> CompletedStylesheetWebFont {
- let (_, request) = resource.clone().into_parts();
+fn font_request(resource: &StylesheetSubresourceRequest) -> &BoundStylesheetWebFont {
+ let StylesheetSubresourceTarget::Font(request) = resource.target() else {
+ panic!("fixture must prepare a font request");
+ };
+ request
+}
+
+fn font_response(resource: &StylesheetSubresourceRequest) -> CompletedStylesheetWebFont {
CompletedStylesheetWebFont::response(
- request.unwrap(),
+ font_request(resource).clone(),
include_bytes!("../../../../moli-layout/tests/fixtures/moli-ahem.woff2").to_vec(),
)
}
@@ -102,8 +109,8 @@ fn child_web_font_document_open_retires_registrations_and_rejects_old_owner() {
(binding, resource)
};
assert_eq!(
- resource.web_font().unwrap().request_id(),
- replacement_resource.web_font().unwrap().request_id()
+ font_request(&resource).request_id(),
+ font_request(&replacement_resource).request_id()
);
let before = vm.layout_pass_observability_for_test().1;
vm.complete_document_web_font(binding, font_response(&resource));
diff --git a/moli-renderer-v8/src/script_vm/web_fonts.rs b/moli-renderer-v8/src/script_vm/web_fonts.rs
index 86eb52afd..d12140057 100644
--- a/moli-renderer-v8/src/script_vm/web_fonts.rs
+++ b/moli-renderer-v8/src/script_vm/web_fonts.rs
@@ -8,7 +8,8 @@ use moli_layout::{DocumentLayoutServices, WebFontRegistrationError, WebFontRegis
use crate::{
css_resource_urls::{
- CompletedStylesheetWebFont, StylesheetLoadBlockingResource, StylesheetWebFont,
+ CompletedStylesheetWebFont, StylesheetLoadBlockingResource, StylesheetSubresourceRequest,
+ StylesheetWebFont,
},
font_loading::{FontFaceLoad, FontFaceResource},
};
@@ -39,7 +40,7 @@ pub(crate) enum DocumentWebFontCompletion {
Registered(WebFontRegistrationOutcome),
Invalid(WebFontRegistrationError),
NetworkFailed,
- Retry(Box<StylesheetLoadBlockingResource>),
+ Retry(Box<StylesheetSubresourceRequest>),
Stale,
}
@@ -108,34 +109,31 @@ impl DocumentWebFontState {
fn bind_request(
&mut self,
- resource: StylesheetLoadBlockingResource,
+ url: url::Url,
+ font: StylesheetWebFont,
load: FontFaceLoad,
- ) -> StylesheetLoadBlockingResource {
+ ) -> StylesheetSubresourceRequest {
self.next_request_id = self
.next_request_id
.checked_add(1)
.expect("document web-font request identity space exhausted");
self.pending.insert(self.next_request_id, load);
- resource.bind_web_font_request(self.next_request_id)
+ StylesheetSubresourceRequest::font(url, font.bind_request(self.next_request_id))
}
+ /// Resolve local sources and bind a request only when a network source is needed.
pub(crate) fn admit(
&mut self,
resource: StylesheetLoadBlockingResource,
services: &mut DocumentLayoutServices,
- ) -> Option<StylesheetLoadBlockingResource> {
- let Some(font) = resource.web_font() else {
- return Some(resource);
+ ) -> Option<StylesheetSubresourceRequest> {
+ let font = match resource {
+ StylesheetLoadBlockingResource::Image(url) => {
+ return Some(StylesheetSubresourceRequest::image(url, None));
+ }
+ StylesheetLoadBlockingResource::Font { font, .. } => font,
};
- if let Some(id) = font.request_id() {
- // A native source fallback already has its next exact request.
- return self
- .pending
- .get(&id)
- .is_some_and(|load| load.borrow().slot() == font.slot())
- .then_some(resource);
- }
- let load = self.observe(font);
+ let load = self.observe(&font);
self.slots
.insert(font.slot().to_owned(), WebFontSlot { load: load.clone() });
if !load.borrow_mut().begin() {
@@ -149,7 +147,7 @@ impl DocumentWebFontState {
let next = load.borrow_mut().next_url(services);
if let Some(url) = next {
let url = url::Url::parse(&url).expect("CSS font sources retain resolved URLs");
- Some(self.bind_request(resource.with_request_url(url), load))
+ Some(self.bind_request(url, font, load))
} else {
if let Err(error) = load.borrow().register(services) {
tracing::warn!(%error, "failed to register local stylesheet font");
@@ -164,13 +162,11 @@ impl DocumentWebFontState {
services: &mut DocumentLayoutServices,
) -> DocumentWebFontCompletion {
let (request, bytes) = terminal.into_parts();
- let Some(id) = request.request_id() else {
- return DocumentWebFontCompletion::Stale;
- };
+ let id = request.request_id();
if self
.pending
.get(&id)
- .is_none_or(|load| load.borrow().slot() != request.slot())
+ .is_none_or(|load| load.borrow().slot() != request.font().slot())
{
return DocumentWebFontCompletion::Stale;
}
@@ -182,12 +178,15 @@ impl DocumentWebFontState {
let next = load.borrow_mut().next_url(services);
if let Some(url) = next {
let url = url::Url::parse(&url).expect("CSS font fallback retains its parser URL");
- let resource = StylesheetLoadBlockingResource::font(Some(url), request);
- return DocumentWebFontCompletion::Retry(Box::new(self.bind_request(resource, load)));
+ return DocumentWebFontCompletion::Retry(Box::new(self.bind_request(
+ url,
+ request.into_font(),
+ load,
+ )));
}
let active = self
.slots
- .get(request.slot())
+ .get(request.font().slot())
.is_some_and(|slot| std::rc::Rc::ptr_eq(&slot.load, &load));
if !active {
return DocumentWebFontCompletion::Stale;
@@ -220,7 +219,9 @@ impl DocumentWebFontState {
#[cfg(test)]
mod tests {
use super::*;
- use crate::css_resource_urls::stylesheet_load_blocking_font_resources;
+ use crate::css_resource_urls::{
+ StylesheetSubresourceTarget, stylesheet_load_blocking_font_resources,
+ };
use crate::protocol_types::OptionalResourceFetchMask;
use url::Url;
@@ -238,11 +239,13 @@ mod tests {
}
fn terminal(
- resource: StylesheetLoadBlockingResource,
+ resource: StylesheetSubresourceRequest,
bytes: Option<Vec<u8>>,
) -> CompletedStylesheetWebFont {
let (_, request) = resource.into_parts();
- let request = request.expect("font resource metadata");
+ let StylesheetSubresourceTarget::Font(request) = request else {
+ panic!("fixture must prepare a font request");
+ };
match bytes {
Some(bytes) => CompletedStylesheetWebFont::response(request, bytes),
None => CompletedStylesheetWebFont::failure(request),
@@ -259,14 +262,10 @@ mod tests {
&mut services,
)
.unwrap();
- let second = state
- .admit(
- resource("@font-face{font-family:Second;src:url(font.woff2)}"),
- &mut services,
- )
- .unwrap();
+ let second_resource = resource("@font-face{font-family:Second;src:url(font.woff2)}");
+ let second = state.admit(second_resource.clone(), &mut services).unwrap();
- state.retain_active_slots([&second], &mut services);
+ state.retain_active_slots([&second_resource], &mut services);
assert!(matches!(
state.complete(terminal(first, Some(TEST_FONT.to_vec())), &mut services),
DocumentWebFontCompletion::Stale
@@ -323,10 +322,7 @@ mod tests {
else {
panic!("invalid first source should advance to its fallback");
};
- assert_eq!(
- second.request_url().expect("URL fallback").as_str(),
- "https://example.test/second.woff2"
- );
+ assert_eq!(second.url().as_str(), "https://example.test/second.woff2");
assert!(matches!(
state.complete(terminal(duplicate, Some(TEST_FONT.to_vec())), &mut services),
DocumentWebFontCompletion::Stale
diff --git a/moli-renderer-v8/src/stylesheet_runtime/settlement.rs b/moli-renderer-v8/src/stylesheet_runtime/settlement.rs
index 8e758da6a..c414e0fbe 100644
--- a/moli-renderer-v8/src/stylesheet_runtime/settlement.rs
+++ b/moli-renderer-v8/src/stylesheet_runtime/settlement.rs
@@ -5,6 +5,10 @@
//! genuinely asynchronous dependent resources cross a Page task boundary.
use super::*;
+use crate::css_resource_urls::{
+ StylesheetLoadBlockingResource, StylesheetLoadBlockingResourceKind,
+ StylesheetSubresourceRequest, StylesheetSubresourceTarget,
+};
impl DocumentRuntime {
pub(crate) fn reconcile_document_web_fonts_in_current_scope(
@@ -299,57 +303,65 @@ impl DocumentRuntime {
let retain_css_images = host.layout_policy().uses_real_layout();
let mut admitted = Vec::with_capacity(resources.len());
for (binding, resource) in resources {
- match resource.kind() {
- crate::css_resource_urls::StylesheetLoadBlockingResourceKind::Font => {
+ match resource {
+ resource @ StylesheetLoadBlockingResource::Font { .. } => {
let Some(document) = host.stylesheet_web_font_document(binding) else {
continue;
};
match host.admit_document_web_font(document, resource) {
- Some(resource) => admitted.push((binding, resource, None)),
+ Some(request) => admitted.push((binding, request)),
None => {
host.settle_stylesheet_subresource_load_delay(binding);
}
}
}
- crate::css_resource_urls::StylesheetLoadBlockingResourceKind::Image
- if retain_css_images =>
- {
- let resolved_url = resource
- .request_url()
- .expect("CSS images have a URL")
- .as_str()
- .to_owned();
- match host.admit_stylesheet_css_image(binding, resolved_url) {
- crate::native_bridge::CssImageResourceAdmission::Fetch(identity) => {
- admitted.push((binding, resource, Some(identity)));
+ StylesheetLoadBlockingResource::Image(url) => {
+ let identity = if retain_css_images {
+ match host.admit_stylesheet_css_image(binding, url.as_str().to_owned()) {
+ crate::native_bridge::CssImageResourceAdmission::Fetch(identity) => {
+ Some(identity)
+ }
+ crate::native_bridge::CssImageResourceAdmission::Reused => {
+ host.settle_stylesheet_subresource_load_delay(binding);
+ continue;
+ }
+ crate::native_bridge::CssImageResourceAdmission::Untracked => None,
}
- crate::native_bridge::CssImageResourceAdmission::Reused => {
- host.settle_stylesheet_subresource_load_delay(binding);
- }
- crate::native_bridge::CssImageResourceAdmission::Untracked => {
- admitted.push((binding, resource, None));
- }
- }
+ } else {
+ None
+ };
+ admitted.push((binding, StylesheetSubresourceRequest::image(url, identity)));
}
- _ => admitted.push((binding, resource, None)),
}
}
- let mut admitted = std::collections::VecDeque::from(admitted);
- while let Some((binding, resource, css_image)) = admitted.pop_front() {
- let request_url = resource.request_url().cloned();
- let kind = resource.kind();
- let failed_css_image = css_image.clone();
- let failed_web_font = (kind
- == crate::css_resource_urls::StylesheetLoadBlockingResourceKind::Font)
- .then(|| {
- resource
- .web_font()
- .cloned()
- .map(crate::css_resource_urls::CompletedStylesheetWebFont::failure)
- })
- .flatten();
+ Self::start_stylesheet_subresource_requests_in_current_scope(scope, host_ptr, admitted);
+ tracing::debug!(
+ resource_count,
+ elapsed_ms = started.elapsed().as_millis(),
+ "started owner-bound stylesheet subresource requests"
+ );
+ }
+
+ pub(crate) fn start_stylesheet_subresource_requests_in_current_scope(
+ scope: &mut v8::PinScope<'_, '_>,
+ host_ptr: *mut JsContextHost,
+ requests: Vec<(
+ crate::frame_owner_model::StylesheetSubresourceLoadDelayBinding,
+ StylesheetSubresourceRequest,
+ )>,
+ ) {
+ debug_assert!(!host_ptr.is_null());
+ let host = unsafe { &mut *host_ptr };
+ let mut admitted = std::collections::VecDeque::from(requests);
+ while let Some((binding, request)) = admitted.pop_front() {
+ let request_url = request.url().clone();
+ let failed_target = request.target().clone();
+ let kind = match &failed_target {
+ StylesheetSubresourceTarget::Image(_) => StylesheetLoadBlockingResourceKind::Image,
+ StylesheetSubresourceTarget::Font(_) => StylesheetLoadBlockingResourceKind::Font,
+ };
match crate::network_host::start_stylesheet_subresource_fetch(
- scope, host, binding, resource, css_image,
+ scope, host, binding, request,
) {
Ok(crate::network_host::StylesheetSubresourceFetchStart::WebFontSettled(
web_font,
@@ -360,7 +372,7 @@ impl DocumentRuntime {
&& let Some(binding) = host
.accept_current_stylesheet_subresource_load_delay_for_document(document)
{
- admitted.push_back((binding, resource, None));
+ admitted.push_back((binding, resource));
}
}
Ok(
@@ -368,18 +380,21 @@ impl DocumentRuntime {
| crate::network_host::StylesheetSubresourceFetchStart::Settled,
) => {}
Err(error) => {
- if let Some(identity) = failed_css_image.as_ref() {
+ if let StylesheetSubresourceTarget::Image(Some(identity)) = &failed_target {
let _ = host.fail_stylesheet_css_image(identity);
}
let settlement = host.settle_stylesheet_subresource_load_delay(binding);
- if let Some(web_font) = failed_web_font
- && let Some(resource) =
- Self::complete_document_web_font(host, binding, web_font)
+ if let StylesheetSubresourceTarget::Font(font) = failed_target
+ && let Some(resource) = Self::complete_document_web_font(
+ host,
+ binding,
+ crate::css_resource_urls::CompletedStylesheetWebFont::failure(font),
+ )
&& let Some(document) = host.stylesheet_web_font_document(binding)
&& let Some(binding) = host
.accept_current_stylesheet_subresource_load_delay_for_document(document)
{
- admitted.push_back((binding, resource, None));
+ admitted.push_back((binding, resource));
}
tracing::warn!(
url = ?request_url,
@@ -393,18 +408,13 @@ impl DocumentRuntime {
}
}
crate::context_bootstrap::publish_font_face_load_changes(scope);
- tracing::debug!(
- resource_count,
- elapsed_ms = started.elapsed().as_millis(),
- "started owner-bound stylesheet subresource requests"
- );
}
fn complete_document_web_font(
host: &JsContextHost,
binding: crate::frame_owner_model::StylesheetSubresourceLoadDelayBinding,
terminal: crate::css_resource_urls::CompletedStylesheetWebFont,
- ) -> Option<crate::css_resource_urls::StylesheetLoadBlockingResource> {
+ ) -> Option<StylesheetSubresourceRequest> {
let document = host.stylesheet_web_font_document(binding)?;
match host.complete_document_web_font(document, terminal) {
crate::script_vm::web_fonts::DocumentWebFontCompletion::Registered(outcome) => {
diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs
index 1c1934976..660c3207a 100644
--- a/moli-renderer-v8/src/types.rs
+++ b/moli-renderer-v8/src/types.rs
@@ -87,8 +87,7 @@ pub(super) enum PendingSubresourceContinuation {
FontFace(v8::Global<v8::Object>),
StylesheetSubresource {
binding: crate::frame_owner_model::StylesheetSubresourceLoadDelayBinding,
- web_font: Option<crate::css_resource_urls::StylesheetWebFont>,
- css_image: Option<crate::native_bridge::CssImageResourceRequestIdentity>,
+ target: crate::css_resource_urls::StylesheetSubresourceTarget,
},
Xhr {
xhr: v8::Global<v8::Object>,
@@ -1796,8 +1795,7 @@ mod tests {
),
load_delay_token: None,
},
- web_font: None,
- css_image: None,
+ target: crate::css_resource_urls::StylesheetSubresourceTarget::Image(None),
};
assert!(image.delays_document_load_event());