Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(renderer): fence screencast resource races

ldm0d823999dc005
diff --git a/moli-core/src/page/command_dispatch.rs b/moli-core/src/page/command_dispatch.rs
index cb4888f65..15860cccf 100644
--- a/moli-core/src/page/command_dispatch.rs
+++ b/moli-core/src/page/command_dispatch.rs
@@ -366,6 +366,7 @@ impl Page {
RendererPageReply::CookieFacadeSnapshot(_) => "a cookie facade snapshot reply",
RendererPageReply::LayoutMetrics(_) => "a layout metrics reply",
RendererPageReply::CaptureScreenshot(_) => "a capture screenshot reply",
+ RendererPageReply::CaptureScreencastFrame(_) => "a capture screencast frame reply",
RendererPageReply::Unit => "a unit reply",
}
}
diff --git a/moli-core/src/page/mod.rs b/moli-core/src/page/mod.rs
index 2846d8317..abff4dd80 100644
--- a/moli-core/src/page/mod.rs
+++ b/moli-core/src/page/mod.rs
@@ -84,7 +84,8 @@ pub use moli_renderer_v8::network::{
pub use moli_renderer_v8::{
DevToolsSessionKey, RendererActivityDiagnostics, RendererAgentAttachmentId,
RendererAutofillAddressField, RendererAutofillCreditCard, RendererAutofillTriggerOutcome,
- RendererAutofillTriggerRequest, RendererCaptureScreenshotReply,
+ RendererAutofillTriggerRequest, RendererCaptureScreencastFrameReply,
+ RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,
RendererCaptureScreenshotRequest, RendererCommandTurnCompletion, RendererCommandTurnOutput,
RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
RendererDevToolsAgentToken, RendererDocumentHitTestResult,
diff --git a/moli-core/src/page/renderer_command_support.rs b/moli-core/src/page/renderer_command_support.rs
index 8d0503854..8f6a237d5 100644
--- a/moli-core/src/page/renderer_command_support.rs
+++ b/moli-core/src/page/renderer_command_support.rs
@@ -11,13 +11,14 @@ use super::protocol_support::{
};
use super::{CompletedPageCommand, Page, PendingPageCommand};
use crate::renderer::{
- RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest, RendererCaptureScreenshotReply,
- RendererCaptureScreenshotRequest, RendererDocumentChildNodeSnapshotEvents,
- RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,
- RendererDocumentNodeAttributesResolution, RendererDocumentNodeClientRect,
- RendererDocumentNodeGeometry, RendererDocumentNodePropertyResolution,
- RendererDocumentNodeReference, RendererDocumentNodeTextResolution,
- RendererDocumentQuerySelectorResolution,
+ RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
+ RendererCaptureScreencastFrameReply, RendererCaptureScreencastFrameRequest,
+ RendererCaptureScreenshotReply, RendererCaptureScreenshotRequest,
+ RendererDocumentChildNodeSnapshotEvents, RendererDocumentFrontendNodeIdsResolution,
+ RendererDocumentHitTestResult, RendererDocumentNodeAttributesResolution,
+ RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,
+ RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,
+ RendererDocumentNodeTextResolution, RendererDocumentQuerySelectorResolution,
RendererDocumentQuerySelectorWithChildNodeSnapshotEvents, RendererDomAttributeMutation,
RendererDomAttributeMutationOutcome, RendererDomBidiNodeBindingResolution,
RendererDomBidiNodeSharedIdResolution, RendererDomEdit, RendererDomEditOutcome,
@@ -1515,6 +1516,30 @@ impl Page {
)
}
+ pub fn start_capture_screencast_frame(
+ &self,
+ request: RendererCaptureScreencastFrameRequest,
+ ) -> Result<PendingPageCommand> {
+ self.start_page_command(RendererPageCommand::CaptureScreencastFrame(request))
+ }
+
+ pub fn finish_capture_screencast_frame(
+ &mut self,
+ completion: CompletedPageCommand,
+ ) -> Result<RendererCaptureScreencastFrameReply> {
+ anyhow::ensure!(
+ completion.renderer_agent_attachment_id() == self.renderer_agent_attachment_id(),
+ "capture screencast frame completed for a stale renderer attachment"
+ );
+ let reply = self.finish_page_command(completion);
+ expect_page_reply!(
+ reply,
+ "capture screencast frame page command",
+ "a capture screencast frame reply",
+ RendererPageReply::CaptureScreencastFrame(result) => Ok(result),
+ )
+ }
+
pub fn start_render_page_dump(
&self,
options: RendererPageDumpOptions,
diff --git a/moli-core/src/renderer.rs b/moli-core/src/renderer.rs
index d23e60d62..9e9469840 100644
--- a/moli-core/src/renderer.rs
+++ b/moli-core/src/renderer.rs
@@ -10,7 +10,8 @@ pub(crate) use moli_renderer_v8::{
DocumentCookieFirstOperation, DocumentCookieGetFreshnessStatus, DocumentCookieOwnerSnapshot,
DocumentCookieSetReadinessStatus, DocumentCookieWriteCapabilitySnapshot, JsRuntime,
RendererAccessibilityPayloadsForObjectId, RendererAutofillTriggerOutcome,
- RendererAutofillTriggerRequest, RendererCaptureScreenshotReply,
+ RendererAutofillTriggerRequest, RendererCaptureScreencastFrameReply,
+ RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,
RendererCaptureScreenshotRequest, RendererDocumentChildNodeSnapshotEvents,
RendererDocumentHitTestResult, RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,
RendererDomAttributeMutation, RendererDomAttributeMutationOutcome,
diff --git a/moli-layout/src/builder.rs b/moli-layout/src/builder.rs
index 5419a4641..d5b8bd608 100644
--- a/moli-layout/src/builder.rs
+++ b/moli-layout/src/builder.rs
@@ -41,6 +41,8 @@ where
styles: &'a mut R,
active_sources: HashSet<S::NodeId>,
seen_sources: HashMap<S::NodeId, String>,
+ seen_css_images: HashSet<(S::NodeId, String)>,
+ css_image_references: Vec<crate::LayoutCssImageReference<S::NodeId>>,
}
impl<'a, S, R> BoxBuilder<'a, S, R>
@@ -54,6 +56,8 @@ where
styles,
active_sources: HashSet::new(),
seen_sources: HashMap::new(),
+ seen_css_images: HashSet::new(),
+ css_image_references: Vec::new(),
}
}
@@ -133,6 +137,7 @@ where
world.compact_reachable();
world.validate_invariants()?;
+ world.css_image_references = self.css_image_references;
Ok(world)
}
@@ -264,7 +269,7 @@ where
}
fn principal_box(
- &self,
+ &mut self,
source_node: S::NodeId,
source_label: String,
semantics: LayoutElementSemantics,
@@ -286,7 +291,12 @@ where
metrics,
);
layout_box.replaced_image = self.source.replaced_image(source_node, &style);
- layout_box.css_images = self.css_image_resources(&style);
+ if !matches!(
+ style.display(),
+ LayoutDisplay::None | LayoutDisplay::Contents
+ ) {
+ layout_box.css_images = self.css_image_resources(source_node, &style);
+ }
layout_box.scroll_offset = self.source.scroll_offset(source_node);
layout_box
}
@@ -362,7 +372,7 @@ where
None,
None,
);
- layout_box.css_images = self.css_image_resources(&style);
+ layout_box.css_images = self.css_image_resources(owner, &style);
if style.has_unsupported_generated_content() {
push_diagnostic(
&mut layout_box.capability_diagnostics,
@@ -519,7 +529,7 @@ where
}
fn allocate_inline_continuation(
- &self,
+ &mut self,
world: &mut LayoutWorld<S::NodeId>,
owner: S::NodeId,
style: &ResolvedLayoutStyle,
@@ -538,33 +548,56 @@ where
None,
None,
);
- continuation.css_images = self.css_image_resources(style);
+ continuation.css_images = self.css_image_resources(owner, style);
world.allocate(continuation)
}
fn css_image_resources(
- &self,
+ &mut self,
+ source: S::NodeId,
style: &ResolvedLayoutStyle,
) -> crate::source::LayoutCssImageResources {
let Some(computed) = style.stylo_computed_values() else {
return crate::source::LayoutCssImageResources::default();
};
- let sample = |image: &style::values::computed::Image| match image {
- GenericImage::Url(url) => url
- .url()
- .and_then(|url| self.source.css_image_resource(url.as_str())),
- _ => None,
+ let background = computed
+ .get_background()
+ .background_image
+ .0
+ .iter()
+ .map(|image| self.css_image_resource(source, image))
+ .collect();
+ let mask = computed
+ .get_svg()
+ .mask_image
+ .0
+ .iter()
+ .map(|image| self.css_image_resource(source, image))
+ .collect();
+ crate::source::LayoutCssImageResources { background, mask }
+ }
+
+ fn css_image_resource(
+ &mut self,
+ source: S::NodeId,
+ image: &style::values::computed::Image,
+ ) -> Option<crate::LayoutImageResource> {
+ let GenericImage::Url(computed_url) = image else {
+ return None;
};
- crate::source::LayoutCssImageResources {
- background: computed
- .get_background()
- .background_image
- .0
- .iter()
- .map(sample)
- .collect(),
- mask: computed.get_svg().mask_image.0.iter().map(sample).collect(),
+ let url = computed_url.url()?;
+ if !matches!(url.scheme(), "http" | "https" | "data" | "blob") || url.fragment().is_some() {
+ return None;
+ }
+ let resolved_url = url.as_str().to_owned();
+ if self.seen_css_images.insert((source, resolved_url.clone())) {
+ self.css_image_references
+ .push(crate::LayoutCssImageReference {
+ source,
+ resolved_url,
+ });
}
+ self.source.css_image_resource(url.as_str())
}
fn normalize_flow_children(
diff --git a/moli-layout/src/layout_tree/pass_result.rs b/moli-layout/src/layout_tree/pass_result.rs
index 7c51c3aec..8723ee9a0 100644
--- a/moli-layout/src/layout_tree/pass_result.rs
+++ b/moli-layout/src/layout_tree/pass_result.rs
@@ -9,6 +9,16 @@ use super::{
tree::{FrozenLayoutTree, LayoutTreeRetentionMetrics},
};
+/// One direct computed CSS image URL observed while constructing a box.
+///
+/// The source node keeps the owning `Document` recoverable at the renderer
+/// boundary without teaching this crate about browsing contexts.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LayoutCssImageReference<N> {
+ pub source: N,
+ pub resolved_url: String,
+}
+
/// Why a full, synchronous layout pass was forced.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LayoutFlushReason {
@@ -46,6 +56,7 @@ where
pub diagnostics: Vec<PaintDiagnostic>,
pub metrics: LayoutPassMetrics,
paint_snapshot: Option<PaintSnapshot>,
+ css_image_references: Vec<LayoutCssImageReference<N>>,
}
impl<N> Deref for LayoutPassResult<N>
@@ -67,6 +78,10 @@ where
self.paint_snapshot.as_ref()
}
+ pub fn css_image_references(&self) -> &[LayoutCssImageReference<N>] {
+ &self.css_image_references
+ }
+
pub fn take_paint_snapshot(&mut self) -> Result<PaintSnapshot, LayoutError> {
self.paint_snapshot
.take()
@@ -83,11 +98,16 @@ where
self.tree
}
- /// Consumes one pass into the sole retainable tree plus optional one-shot
- /// paint input. Embedded-frame composition uses this to nest the child tree
- /// into its parent while separately consuming paint into the parent frame.
- pub fn into_tree_and_paint_snapshot(self) -> (FrozenLayoutTree<N>, Option<PaintSnapshot>) {
- (self.tree, self.paint_snapshot)
+ /// Consumes all products needed to compose an embedded frame into its
+ /// parent pass, including resource discovery metadata from that child.
+ pub fn into_embedded_parts(
+ self,
+ ) -> (
+ FrozenLayoutTree<N>,
+ Option<PaintSnapshot>,
+ Vec<LayoutCssImageReference<N>>,
+ ) {
+ (self.tree, self.paint_snapshot, self.css_image_references)
}
pub fn retention_metrics(&self) -> LayoutTreeRetentionMetrics {
@@ -112,12 +132,14 @@ where
diagnostics: Vec<PaintDiagnostic>,
metrics: LayoutPassMetrics,
paint_snapshot: Option<PaintSnapshot>,
+ css_image_references: Vec<LayoutCssImageReference<N>>,
) -> Self {
Self {
tree,
diagnostics,
metrics,
paint_snapshot,
+ css_image_references,
}
}
}
diff --git a/moli-layout/src/lib.rs b/moli-layout/src/lib.rs
index 79b31e392..d96c6da98 100644
--- a/moli-layout/src/lib.rs
+++ b/moli-layout/src/lib.rs
@@ -47,14 +47,14 @@ pub use error::LayoutError;
pub use layout_tree::{
FrozenCoordinateSpace, FrozenEmbeddedFrame, FrozenLayoutBox, FrozenLayoutTree,
GeometryProvider, LayoutAnswers, LayoutBoxGeometry, LayoutBoxModel, LayoutCaretPosition,
- LayoutClipChainId, LayoutClipNode, LayoutCoordinateSpaceId, LayoutDocumentMetrics,
- LayoutElementMetrics, LayoutFlushReason, LayoutFragment, LayoutFragmentBoxModel,
- LayoutFragmentId, LayoutFragmentKind, LayoutHit, LayoutIntersectionGeometry, LayoutNodeOutput,
- LayoutOutputBoxId, LayoutPassMetrics, LayoutPassResult, LayoutPoint, LayoutQuad, LayoutQuery,
- LayoutQueryAnswer, LayoutQueryBatch, LayoutRect, LayoutScrollContainerMetrics,
- LayoutScrollExtent, LayoutScrollIntoViewGeometry, LayoutSize, LayoutTransform2D,
- LayoutTreeRetentionMetrics, LayoutViewport, MAX_RETAINED_LAYOUT_BOXES,
- MAX_RETAINED_LAYOUT_FRAGMENTS, MAX_RETAINED_LAYOUT_TREE_BYTES,
+ LayoutClipChainId, LayoutClipNode, LayoutCoordinateSpaceId, LayoutCssImageReference,
+ LayoutDocumentMetrics, LayoutElementMetrics, LayoutFlushReason, LayoutFragment,
+ LayoutFragmentBoxModel, LayoutFragmentId, LayoutFragmentKind, LayoutHit,
+ LayoutIntersectionGeometry, LayoutNodeOutput, LayoutOutputBoxId, LayoutPassMetrics,
+ LayoutPassResult, LayoutPoint, LayoutQuad, LayoutQuery, LayoutQueryAnswer, LayoutQueryBatch,
+ LayoutRect, LayoutScrollContainerMetrics, LayoutScrollExtent, LayoutScrollIntoViewGeometry,
+ LayoutSize, LayoutTransform2D, LayoutTreeRetentionMetrics, LayoutViewport,
+ MAX_RETAINED_LAYOUT_BOXES, MAX_RETAINED_LAYOUT_FRAGMENTS, MAX_RETAINED_LAYOUT_TREE_BYTES,
};
pub use normalize::{NormalizedBoxNode, NormalizedBoxTree, NormalizedFormattingContext};
pub use normalize_source::{
diff --git a/moli-layout/src/pass.rs b/moli-layout/src/pass.rs
index feb6030e9..21325ae56 100644
--- a/moli-layout/src/pass.rs
+++ b/moli-layout/src/pass.rs
@@ -19,6 +19,7 @@ where
{
pub tree: FrozenLayoutTree<N>,
pub paint: Option<PaintSnapshot>,
+ pub css_image_references: Vec<crate::LayoutCssImageReference<N>>,
}
impl<N> EmbeddedFrameSnapshot<N>
@@ -26,8 +27,16 @@ where
N: Copy + std::fmt::Debug + Eq + std::hash::Hash,
{
#[must_use]
- pub const fn new(tree: FrozenLayoutTree<N>, paint: Option<PaintSnapshot>) -> Self {
- Self { tree, paint }
+ pub const fn new(
+ tree: FrozenLayoutTree<N>,
+ paint: Option<PaintSnapshot>,
+ css_image_references: Vec<crate::LayoutCssImageReference<N>>,
+ ) -> Self {
+ Self {
+ tree,
+ paint,
+ css_image_references,
+ }
}
}
diff --git a/moli-layout/src/projection.rs b/moli-layout/src/projection.rs
index 6acba0d16..d6a71b1d1 100644
--- a/moli-layout/src/projection.rs
+++ b/moli-layout/src/projection.rs
@@ -36,6 +36,10 @@ where
projection.assign_clip_and_paint_order();
let content_size = projection.document_content_size();
+ let mut css_image_references = world.css_image_references.clone();
+ for (_, snapshot) in embedded_frames.values_mut() {
+ css_image_references.append(&mut snapshot.css_image_references);
+ }
let mut embedded_paint = embedded_frames
.iter_mut()
.filter_map(|(id, (_, snapshot))| snapshot.paint.take().map(|paint| (*id, paint)))
@@ -97,6 +101,7 @@ where
diagnostics,
metrics,
paint_snapshot,
+ css_image_references,
))
}
diff --git a/moli-layout/src/world.rs b/moli-layout/src/world.rs
index af4b92138..38c5bd80e 100644
--- a/moli-layout/src/world.rs
+++ b/moli-layout/src/world.rs
@@ -4,8 +4,8 @@ use style::Atom;
use taffy::{Cache, Layout, Point, Style};
use crate::{
- LayoutElementSemantics, LayoutError, LayoutPoint, LayoutPseudo, ReplacedMetrics,
- ResolvedLayoutStyle, inline::InlineFormattingContext,
+ LayoutCssImageReference, LayoutElementSemantics, LayoutError, LayoutPoint, LayoutPseudo,
+ ReplacedMetrics, ResolvedLayoutStyle, inline::InlineFormattingContext,
};
/// Dense identifier scoped to exactly one [`LayoutWorld`].
@@ -347,6 +347,7 @@ where
pub(crate) display_contents_mapping: HashMap<N, Vec<LayoutBoxId>>,
pub(crate) root: LayoutBoxId,
pub(crate) viewport_layout: ViewportLayoutState,
+ pub(crate) css_image_references: Vec<LayoutCssImageReference<N>>,
}
impl<N> LayoutWorld<N>
@@ -360,6 +361,7 @@ where
display_contents_mapping: HashMap::new(),
root: LayoutBoxId::from_index(0),
viewport_layout: ViewportLayoutState::default(),
+ css_image_references: Vec::new(),
}
}
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index ac84a234d..a4566b8e8 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -18,7 +18,8 @@ use chromiumoxide_cdp::cdp::browser_protocol::page::{
use moli_core::page::{
ChildFrameDocumentNetworkActivitySnapshot, ChildFrameDocumentOpenedSnapshot,
ChildFrameNavigationSnapshot, ChildFrameTreeEventSnapshot, ChildFrameTreeSnapshot,
- CompletedPageCommand, Page, PendingPageCommand, RendererCaptureScreenshotReply,
+ CompletedPageCommand, Page, PendingPageCommand, RendererCaptureScreencastFrameReply,
+ RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,
RendererCaptureScreenshotRequest, RendererDocumentLifecycleEvent,
RendererDocumentLifecycleIdentity, RendererDocumentLifecycleMilestone,
RendererDocumentLifecycleWaitOutcome, RendererDocumentLifecycleWaiter,
@@ -1903,21 +1904,19 @@ impl CdpConnection {
return PageScreencastCaptureStart::Stale;
};
let viewport = current_viewport_surface(conn, session_id_ref);
- let request = RendererCaptureScreenshotRequest {
- purpose: RendererScreenshotPurpose::Screencast,
+ let request = RendererCaptureScreencastFrameRequest {
format: match config.format() {
PageScreencastFormat::Png => RendererScreenshotFormat::Png,
PageScreencastFormat::Jpeg => RendererScreenshotFormat::Jpeg,
},
quality: config.quality(),
- region: moli_core::page::RendererScreenshotRegion::Viewport,
optimize_for_speed: true,
max_width: config.max_width(),
max_height: config.max_height(),
known_visual_state,
};
let pending = match conn.loaded_page_mut_for_protocol_access(session_id_ref) {
- Ok(page) => match page.start_capture_screenshot_with_request(request) {
+ Ok(page) => match page.start_capture_screencast_frame(request) {
Ok(pending) => pending,
Err(error) => {
tracing::debug!(?error, "failed to start screencast frame capture");
@@ -1965,7 +1964,7 @@ impl CdpConnection {
return PageScreencastCaptureCompletion::Stale;
}
- let image = match completed {
+ let frame = match completed {
Ok(completion) => {
let page = match conn.loaded_page_mut_for_protocol_access(session_id_ref) {
Ok(page) => page,
@@ -1978,9 +1977,9 @@ impl CdpConnection {
return PageScreencastCaptureCompletion::Retry;
}
};
- match page.finish_capture_screenshot(*completion) {
- Ok(RendererCaptureScreenshotReply::Captured(image)) => image,
- Ok(RendererCaptureScreenshotReply::ScreencastUnchanged) => {
+ match page.finish_capture_screencast_frame(*completion) {
+ Ok(RendererCaptureScreencastFrameReply::Captured(frame)) => frame,
+ Ok(RendererCaptureScreencastFrameReply::Unchanged) => {
if conn.complete_page_screencast_capture_for_session_owner(
session_id_ref,
generation,
@@ -1992,8 +1991,8 @@ impl CdpConnection {
return PageScreencastCaptureCompletion::Unchanged;
}
Ok(
- RendererCaptureScreenshotReply::LayoutDisabled
- | RendererCaptureScreenshotReply::NoDocument,
+ RendererCaptureScreencastFrameReply::LayoutDisabled
+ | RendererCaptureScreencastFrameReply::NoDocument,
)
| Err(_) => {
let _ = conn.complete_page_screencast_capture_for_session_owner(
@@ -2015,19 +2014,7 @@ impl CdpConnection {
}
};
- let Some(visual_state) = image.visual_state else {
- tracing::debug!(
- generation,
- ?session_id,
- "screencast capture returned a frame without visual-state metadata"
- );
- let _ = conn.complete_page_screencast_capture_for_session_owner(
- session_id_ref,
- generation,
- false,
- );
- return PageScreencastCaptureCompletion::Retry;
- };
+ let visual_state = frame.visual_state;
if conn.complete_page_screencast_capture_for_session_owner(session_id_ref, generation, true)
!= Some(true)
{
@@ -2048,7 +2035,7 @@ impl CdpConnection {
PageScreencastCaptureCompletion::Frame {
event: BackgroundProtocolEvent::page_screencast_frame(
session_id_ref,
- BASE64_STANDARD.encode(&image.bytes),
+ BASE64_STANDARD.encode(&frame.image.bytes),
metadata,
generation,
),
@@ -6735,7 +6722,6 @@ fn start_devtools_capture_screenshot_command(
optimize_for_speed: command.optimize_for_speed,
max_width: None,
max_height: None,
- known_visual_state: None,
};
match page.start_capture_screenshot_with_request(request) {
Ok(pending) => PageCommandTaskStep::Pending(PendingPageCommandDispatch {
@@ -6799,7 +6785,6 @@ fn start_devtools_print_to_pdf_command(
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
};
match page.start_capture_screenshot_with_request(request) {
Ok(pending) => PageCommandTaskStep::Pending(PendingPageCommandDispatch {
@@ -7823,12 +7808,6 @@ async fn complete_pending_page_command_inner(
Ok(RendererCaptureScreenshotReply::NoDocument) => {
CommandOutputPlan::error(-32000, "NoDocumentLoaded")
}
- Ok(RendererCaptureScreenshotReply::ScreencastUnchanged) => {
- CommandOutputPlan::error(
- -32000,
- "Screenshot capture returned an invalid screencast-only reply",
- )
- }
Err(error) => CommandOutputPlan::error(
-32000,
format!("Failed to capture page screenshot: {error}"),
@@ -7871,12 +7850,6 @@ async fn complete_pending_page_command_inner(
"NoDocumentLoaded",
));
}
- Ok(RendererCaptureScreenshotReply::ScreencastUnchanged) => {
- return PageCommandTaskStep::Complete(CommandOutputPlan::error(
- -32000,
- "PDF capture returned an invalid screencast-only reply",
- ));
- }
Err(error) => {
return PageCommandTaskStep::Complete(CommandOutputPlan::error(
-32000,
diff --git a/moli-protocol/src/domains/page/tests/lifecycle.rs b/moli-protocol/src/domains/page/tests/lifecycle.rs
index 390f8137d..7cfb51cfd 100644
--- a/moli-protocol/src/domains/page/tests/lifecycle.rs
+++ b/moli-protocol/src/domains/page/tests/lifecycle.rs
@@ -1,4 +1,5 @@
use super::*;
+use crate::CdpConnection;
use crate::domains::page::{
PageScreencastCaptureCompletion, PageScreencastCaptureStart, PageScreencastSubscriptionStatus,
};
@@ -3866,6 +3867,161 @@ async fn screencast_capture_materializes_jpeg_frame_and_ack_budget() {
);
}
+#[tokio::test(flavor = "multi_thread")]
+async fn screencast_visual_state_is_independent_for_two_sessions_on_one_page() {
+ let mut ctx = TestContext::new();
+ load_bc_with_session(
+ &mut ctx,
+ "BID-screencast-two-sessions",
+ "TID-screencast-two-sessions",
+ "SID-screencast-primary",
+ "about:blank",
+ );
+ assert!(
+ ctx.conn
+ .browser_context
+ .as_mut()
+ .expect("browser context")
+ .assign_auxiliary_session_to_target(
+ "TID-screencast-two-sessions",
+ "SID-screencast-aux".to_owned(),
+ )
+ );
+ ensure_initial_document_for_session(&mut ctx, Some("SID-screencast-primary")).await;
+
+ let start = |conn: &mut CdpConnection, session_id: &str, command_id: u64| {
+ let raw = json!({
+ "id": command_id,
+ "method": "Page.startScreencast",
+ "sessionId": session_id,
+ "params": { "format": "png" }
+ })
+ .to_string();
+ let CdpCommandTaskStep::Complete(outcome) = conn.start_command_dispatch(&raw) else {
+ panic!("Page.startScreencast must complete synchronously");
+ };
+ let (_, scheduler_events) = outcome.into_parts();
+ let [CdpSchedulerEvent::PageScreencastStarted { registration }] =
+ <[_; 1]>::try_from(scheduler_events).expect("one screencast registration per session")
+ else {
+ unreachable!("array pattern fixes the scheduler event kind")
+ };
+ registration
+ };
+ let primary = start(&mut ctx.conn, "SID-screencast-primary", 552);
+ let auxiliary = start(&mut ctx.conn, "SID-screencast-aux", 553);
+
+ let PageScreencastCaptureStart::Pending(primary_capture) =
+ ctx.conn.start_page_screencast_frame_capture(&primary, None)
+ else {
+ panic!("primary session must start its first frame");
+ };
+ let PageScreencastCaptureStart::Pending(auxiliary_capture) = ctx
+ .conn
+ .start_page_screencast_frame_capture(&auxiliary, None)
+ else {
+ panic!("auxiliary session must start its first frame independently");
+ };
+ let PageScreencastCaptureCompletion::Frame {
+ event: primary_event,
+ visual_state: primary_state,
+ } = ctx
+ .conn
+ .complete_page_screencast_frame_capture(primary_capture.wait().await)
+ else {
+ panic!("primary first capture must emit a frame");
+ };
+ let PageScreencastCaptureCompletion::Frame {
+ event: auxiliary_event,
+ visual_state: auxiliary_state,
+ } = ctx
+ .conn
+ .complete_page_screencast_frame_capture(auxiliary_capture.wait().await)
+ else {
+ panic!("auxiliary first capture must emit a frame");
+ };
+ assert_eq!(
+ primary_event.into_parts().0["sessionId"],
+ json!("SID-screencast-primary")
+ );
+ assert_eq!(
+ auxiliary_event.into_parts().0["sessionId"],
+ json!("SID-screencast-aux")
+ );
+ assert_eq!(
+ ctx.conn
+ .acknowledge_page_screencast_frame_for_session_owner(
+ Some("SID-screencast-primary"),
+ primary.generation(),
+ ),
+ Some(true)
+ );
+ assert_eq!(
+ ctx.conn
+ .acknowledge_page_screencast_frame_for_session_owner(
+ Some("SID-screencast-aux"),
+ auxiliary.generation(),
+ ),
+ Some(true)
+ );
+
+ ctx.process_async(json!({
+ "id": 554,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-screencast-primary",
+ "params": {
+ "expression": "document.body.style.background = 'rgb(1, 2, 3)'; 'mutated'",
+ "returnByValue": true
+ }
+ }))
+ .await;
+
+ let PageScreencastCaptureStart::Pending(primary_refresh) = ctx
+ .conn
+ .start_page_screencast_frame_capture(&primary, Some(primary_state))
+ else {
+ panic!("primary session must observe the mutation");
+ };
+ assert!(matches!(
+ ctx.conn
+ .complete_page_screencast_frame_capture(primary_refresh.wait().await),
+ PageScreencastCaptureCompletion::Frame { .. }
+ ));
+ assert_eq!(
+ ctx.conn
+ .acknowledge_page_screencast_frame_for_session_owner(
+ Some("SID-screencast-primary"),
+ primary.generation(),
+ ),
+ Some(true)
+ );
+
+ let PageScreencastCaptureStart::Pending(auxiliary_refresh) = ctx
+ .conn
+ .start_page_screencast_frame_capture(&auxiliary, Some(auxiliary_state))
+ else {
+ panic!("auxiliary session must retain its own pre-mutation state");
+ };
+ let PageScreencastCaptureCompletion::Frame { event, .. } = ctx
+ .conn
+ .complete_page_screencast_frame_capture(auxiliary_refresh.wait().await)
+ else {
+ panic!("auxiliary session must receive the mutation after the primary session did");
+ };
+ assert_eq!(
+ event.into_parts().0["sessionId"],
+ json!("SID-screencast-aux")
+ );
+ assert_eq!(
+ ctx.conn
+ .acknowledge_page_screencast_frame_for_session_owner(
+ Some("SID-screencast-aux"),
+ auxiliary.generation(),
+ ),
+ Some(true)
+ );
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn start_screencast_is_session_local_for_active_auxiliary_session() {
let mut ctx = TestContext::new();
diff --git a/moli-renderer-v8/src/layout_renderer/mod.rs b/moli-renderer-v8/src/layout_renderer/mod.rs
index d3d488667..d9911734a 100644
--- a/moli-renderer-v8/src/layout_renderer/mod.rs
+++ b/moli-renderer-v8/src/layout_renderer/mod.rs
@@ -6,9 +6,8 @@ use std::collections::HashMap;
use moli_layout::{
DocumentLayoutServices, EmbeddedFrameRenderer, LayoutPassRequest, LayoutPassResult,
- LayoutSource, LayoutViewport, build_layout_pass_with_embedded_frames,
+ LayoutViewport, build_layout_pass_with_embedded_frames,
};
-use style::values::generics::image::GenericImage;
use crate::{document_runtime::DomHandle, native_bridge::JsContextHost};
@@ -34,77 +33,6 @@ pub(crate) fn current_native_stylesheet_web_font_resources(
resources.into_values().collect()
}
-/// Resolves the direct `url()` layers visible to the next paint pass.
-///
-/// Initial stylesheet discovery starts most requests earlier. This computed
-/// walk closes the gap for inline styles, CSSOM mutations, and pseudo styles
-/// while using the exact absolute URLs produced by Stylo.
-pub(crate) fn current_native_css_image_resources(
- runtime: &JsContextHost,
- root: DomHandle,
-) -> Vec<crate::css_resource_urls::StylesheetLoadBlockingResource> {
- let source = source_view::NativeLayoutSourceView::new(runtime, root);
- let mut reads = crate::native_bridge::element::ComputedStyleReadScope::new(runtime);
- let mut urls = std::collections::BTreeMap::new();
- let mut stack = vec![root];
- let mut seen = std::collections::HashSet::new();
- while let Some(node) = stack.pop() {
- if !seen.insert(node) {
- continue;
- }
- let children = source.flat_children(node).collect::<Vec<_>>();
- stack.extend(children.into_iter().rev());
- if source.node_kind(node) != moli_layout::LayoutSourceKind::Element {
- continue;
- }
-
- let read = reads.read(node);
- if let Some(computed) = read.computed_values() {
- collect_computed_css_image_urls(computed.as_ref(), &mut urls);
- }
- for pseudo in ["marker", "before", "after"] {
- if let Some(computed) = read.pseudo_computed_values(pseudo) {
- collect_computed_css_image_urls(computed.as_ref(), &mut urls);
- }
- }
- }
- urls.into_values()
- .map(crate::css_resource_urls::StylesheetLoadBlockingResource::image)
- .collect()
-}
-
-fn collect_computed_css_image_urls(
- computed: &style::properties::ComputedValues,
- output: &mut std::collections::BTreeMap<String, url::Url>,
-) {
- let images = computed
- .get_background()
- .background_image
- .0
- .iter()
- .chain(computed.get_svg().mask_image.0.iter());
- for image in images {
- let GenericImage::Url(computed_url) = image else {
- continue;
- };
- let Some(url) = computed_url.url() else {
- continue;
- };
- if !matches!(url.scheme(), "http" | "https" | "data" | "blob") {
- continue;
- }
- // Blink removes fragments for the shared fetch but retains them on
- // StyleFetchedImage for SVG view/element selection. We defer those
- // views until that second semantic layer exists.
- if url.fragment().is_some() {
- continue;
- }
- output
- .entry(url.as_str().to_owned())
- .or_insert_with(|| url.as_ref().clone());
- }
-}
-
pub(crate) fn build_native_layout_pass(
runtime: &JsContextHost,
root: DomHandle,
@@ -214,8 +142,12 @@ impl EmbeddedFrameRenderer<DomHandle> for NativeEmbeddedFrameRenderer<'_> {
);
self.embedded_document_services.insert(document, services);
let output = result?;
- let (tree, paint) = output.into_tree_and_paint_snapshot();
- Ok(Some(moli_layout::EmbeddedFrameSnapshot::new(tree, paint)))
+ let (tree, paint, css_image_references) = output.into_embedded_parts();
+ Ok(Some(moli_layout::EmbeddedFrameSnapshot::new(
+ tree,
+ paint,
+ css_image_references,
+ )))
}
}
diff --git a/moli-renderer-v8/src/layout_renderer/source_view.rs b/moli-renderer-v8/src/layout_renderer/source_view.rs
index 447b98ceb..ab10e63c9 100644
--- a/moli-renderer-v8/src/layout_renderer/source_view.rs
+++ b/moli-renderer-v8/src/layout_renderer/source_view.rs
@@ -22,6 +22,7 @@ pub(super) struct NativeLayoutSourceView<'a> {
}
impl<'a> NativeLayoutSourceView<'a> {
+ #[cfg(test)]
pub(super) fn new(runtime: &'a JsContextHost, root: DomHandle) -> Self {
Self::with_paint_resources(runtime, root, false)
}
diff --git a/moli-renderer-v8/src/lib.rs b/moli-renderer-v8/src/lib.rs
index f1c214939..d26b83fd8 100644
--- a/moli-renderer-v8/src/lib.rs
+++ b/moli-renderer-v8/src/lib.rs
@@ -221,11 +221,12 @@ pub use runtime::{
RendererAgentAttachmentId, RendererAutofillAddressField, RendererAutofillCreditCard,
RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest, RendererBrowserContextRuntime,
RendererBrowserContextRuntimeId, RendererBrowserContextRuntimeOwner,
- RendererBrowserContextRuntimeOwnerAccess, RendererCaptureScreenshotReply,
- RendererCaptureScreenshotRequest, RendererCapturedScreenshot, RendererCommandTurnCompletion,
- RendererCommandTurnOutput, RendererCountEntry, RendererDedicatedWorkerTargetEvent,
- RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken,
- RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,
+ RendererBrowserContextRuntimeOwnerAccess, RendererCaptureScreencastFrameReply,
+ RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotReply,
+ RendererCaptureScreenshotRequest, RendererCapturedScreencastFrame, RendererCapturedScreenshot,
+ RendererCommandTurnCompletion, RendererCommandTurnOutput, RendererCountEntry,
+ RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
+ RendererDevToolsAgentToken, RendererDevToolsMainCommandEnvelope, RendererDocumentBoxModel,
RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,
RendererDocumentChildNodeSnapshots, RendererDocumentCommitPermit,
RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs b/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs
index 8688496db..8e3f536b4 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/canvas_resources.rs
@@ -1,17 +1,25 @@
use std::{collections::HashMap, sync::Arc};
use crate::document_runtime::DomHandle;
+use crate::native_bridge::context_host::visual_resource_generation::VisualResourceGeneration;
const MAX_RETAINED_CANVAS_PAINT_BYTES: usize = 256 * 1024 * 1024;
-#[derive(Default)]
pub(super) struct CanvasResourceStore {
pixels_by_element: HashMap<DomHandle, Arc<moli_image::RgbaImage>>,
retained_bytes: usize,
- paint_generation: u64,
+ visual_generation: VisualResourceGeneration,
}
impl CanvasResourceStore {
+ pub(super) fn new(visual_generation: VisualResourceGeneration) -> Self {
+ Self {
+ pixels_by_element: HashMap::new(),
+ retained_bytes: 0,
+ visual_generation,
+ }
+ }
+
fn replace(&mut self, element: DomHandle, width: u32, height: u32, rgba: Vec<u8>) -> bool {
let Ok(pixels) = moli_image::RgbaImage::try_new(width, height, rgba) else {
return false;
@@ -32,7 +40,7 @@ impl CanvasResourceStore {
}
self.pixels_by_element.insert(element, Arc::new(pixels));
self.retained_bytes = next_retained_bytes;
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
true
}
@@ -41,7 +49,7 @@ impl CanvasResourceStore {
return false;
};
self.retained_bytes = self.retained_bytes.saturating_sub(pixels.byte_len());
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
true
}
@@ -52,9 +60,11 @@ impl CanvasResourceStore {
fn elements(&self) -> impl Iterator<Item = DomHandle> + '_ {
self.pixels_by_element.keys().copied()
}
+}
- const fn paint_generation(&self) -> u64 {
- self.paint_generation
+impl Default for CanvasResourceStore {
+ fn default() -> Self {
+ Self::new(VisualResourceGeneration::default())
}
}
@@ -86,10 +96,6 @@ impl super::JsContextHost {
self.canvas_resources.get(element)
}
- pub(in crate::native_bridge::context_host) fn canvas_paint_generation(&self) -> u64 {
- self.canvas_resources.paint_generation()
- }
-
pub(in crate::native_bridge::context_host) fn retire_canvas_resources_for_document(
&mut self,
document: DomHandle,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/core.rs b/moli-renderer-v8/src/native_bridge/context_host/core.rs
index 4397969a5..c9130b30b 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/core.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs
@@ -192,6 +192,8 @@ impl JsContextHost {
.set_current_main_service_worker_client_id(Some(service_worker_client_id,)),
"main service worker client projection requires a current owner"
);
+ let visual_resource_generation =
+ super::visual_resource_generation::VisualResourceGeneration::default();
let mut host = Self {
runtime: runtime as *mut DocumentRuntime,
layout_policy: moli_page_types::LayoutPolicy::default(),
@@ -309,8 +311,12 @@ impl JsContextHost {
pending_pointer_capture_targets: HashMap::new(),
pointer_capture_targets: HashMap::new(),
lazy_media_load_candidates: HashSet::new(),
- canvas_resources: super::canvas_resources::CanvasResourceStore::default(),
- image_resources: super::image_resources::ImageResourceStore::default(),
+ canvas_resources: super::canvas_resources::CanvasResourceStore::new(
+ visual_resource_generation.clone(),
+ ),
+ image_resources: super::image_resources::ImageResourceStore::new(
+ visual_resource_generation,
+ ),
next_image_decode_id: 1,
pending_image_decode_requests: HashMap::new(),
resource_timing_buffers: SharedResourceTimingBufferRegistry::new(),
diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs
index 7a86ad42c..b8167afa1 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/css.rs
@@ -1,10 +1,4 @@
-use std::{
- collections::HashMap,
- sync::{
- Arc,
- atomic::{AtomicU64, Ordering},
- },
-};
+use std::{collections::HashMap, sync::Arc};
use parking_lot::Mutex;
@@ -18,6 +12,7 @@ use super::{
use crate::{
document_runtime::DomHandle,
frame_owner_model::FrameDocumentTaskOwner,
+ native_bridge::context_host::visual_resource_generation::VisualResourceGeneration,
types::{ImageRequestCorsMode, ImageRequestKey},
};
@@ -53,7 +48,7 @@ struct CssImageResourceKey {
pub(super) struct CssImageResourceStore {
inner: Arc<Mutex<CssImageResourceStoreInner>>,
ready_by_request: ReadyImageResourceIndex,
- paint_generation: Arc<AtomicU64>,
+ visual_generation: VisualResourceGeneration,
#[cfg(test)]
completion_notify: Arc<tokio::sync::Notify>,
}
@@ -77,11 +72,14 @@ enum CssImageResourceState {
}
impl CssImageResourceStore {
- pub(super) fn new(ready_by_request: ReadyImageResourceIndex) -> Self {
+ pub(super) fn new(
+ ready_by_request: ReadyImageResourceIndex,
+ visual_generation: VisualResourceGeneration,
+ ) -> Self {
Self {
inner: Arc::new(Mutex::new(CssImageResourceStoreInner::default())),
ready_by_request,
- paint_generation: Arc::new(AtomicU64::new(0)),
+ visual_generation,
#[cfg(test)]
completion_notify: Arc::new(tokio::sync::Notify::new()),
}
@@ -135,12 +133,34 @@ impl CssImageResourceStore {
},
);
if reused {
+ self.visual_generation.bump();
CssImageResourceAdmission::Reused
} else {
CssImageResourceAdmission::Fetch(identity)
}
}
+ pub(super) fn contains_current(
+ &self,
+ document_handle: DomHandle,
+ document_owner: FrameDocumentTaskOwner,
+ resolved_url: &str,
+ ) -> bool {
+ let request_key = ImageRequestKey::with_density(
+ resolved_url.to_owned(),
+ ImageRequestCorsMode::NoCors,
+ 1.0,
+ );
+ self.inner
+ .lock()
+ .slots
+ .get(&CssImageResourceKey {
+ document_handle,
+ request_key,
+ })
+ .is_some_and(|slot| slot.identity.document_owner == document_owner)
+ }
+
pub(super) fn mark_decode_queued(
&self,
identity: &CssImageResourceRequestIdentity,
@@ -184,7 +204,7 @@ impl CssImageResourceStore {
self.ready_by_request
.insert(identity.request_key.clone(), &resource);
slot.state = CssImageResourceState::Ready(resource);
- self.paint_generation.fetch_add(1, Ordering::AcqRel);
+ self.visual_generation.bump();
#[cfg(test)]
self.completion_notify.notify_waiters();
true
@@ -202,7 +222,7 @@ impl CssImageResourceStore {
return false;
}
slot.state = CssImageResourceState::Failed;
- self.paint_generation.fetch_add(1, Ordering::AcqRel);
+ self.visual_generation.bump();
#[cfg(test)]
self.completion_notify.notify_waiters();
true
@@ -243,17 +263,13 @@ impl CssImageResourceStore {
.retain(|key, _| key.document_handle != document_handle);
let removed = before - inner.slots.len();
if removed != 0 {
- self.paint_generation.fetch_add(1, Ordering::AcqRel);
+ self.visual_generation.bump();
}
drop(inner);
self.ready_by_request.prune_dead();
removed
}
- pub(super) fn paint_generation(&self) -> u64 {
- self.paint_generation.load(Ordering::Acquire)
- }
-
#[cfg(test)]
pub(super) fn observability_for_test(&self) -> (usize, usize, usize, usize, Vec<String>) {
let inner = self.inner.lock();
@@ -318,10 +334,39 @@ mod tests {
}
}
+ #[test]
+ fn worker_completion_publishes_through_the_shared_visual_generation() {
+ let generation = VisualResourceGeneration::default();
+ let store =
+ CssImageResourceStore::new(ReadyImageResourceIndex::default(), generation.clone());
+ let descriptor = ImageResponseDescriptor::raster(moli_image::RasterImageMetadata {
+ format: moli_image::RasterImageFormat::Png,
+ width: 1,
+ height: 1,
+ });
+ let CssImageResourceAdmission::Fetch(identity) = store.admit(
+ DomHandle::new(10),
+ owner(1),
+ "https://example.test/async.png".to_owned(),
+ ) else {
+ panic!("a new CSS image must create a fetch identity");
+ };
+ assert!(store.mark_decode_queued(&identity, descriptor));
+ let before = generation.current();
+ let worker_store = store.clone();
+ let completed =
+ std::thread::spawn(move || worker_store.complete_decode(&identity, ready_red_pixel()))
+ .join()
+ .expect("CSS decoder worker must finish");
+ assert!(completed);
+ assert_eq!(generation.current(), before + 1);
+ }
+
#[test]
fn exact_document_request_identity_rejects_stale_decode_and_shares_ready_content() {
let ready_index = ReadyImageResourceIndex::default();
- let store = CssImageResourceStore::new(ready_index.clone());
+ let store =
+ CssImageResourceStore::new(ready_index.clone(), VisualResourceGeneration::default());
let first_document = DomHandle::new(10);
let second_document = DomHandle::new(20);
let url = "https://example.test/shared.png";
diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs
index e5e76b282..629b23318 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/mod.rs
@@ -97,11 +97,15 @@ impl super::PendingImageLoadEvent {
}
impl super::JsContextHost {
- pub(in crate::native_bridge::context_host) fn image_paint_generations(&self) -> (u64, u64) {
- (
- self.image_resources.paint_generation(),
- self.image_resources.css.paint_generation(),
- )
+ pub(in crate::native_bridge::context_host) fn visual_resource_generation(&self) -> u64 {
+ self.image_resources.visual_generation()
+ }
+
+ #[cfg(test)]
+ pub(crate) fn visual_resource_generation_handle_for_test(
+ &self,
+ ) -> super::visual_resource_generation::VisualResourceGeneration {
+ self.image_resources.visual_generation_handle_for_test()
}
pub(super) fn begin_pending_image_resource(
@@ -216,6 +220,32 @@ impl super::JsContextHost {
.admit(document_handle, binding.owner(), resolved_url)
}
+ pub(crate) fn stylesheet_css_image_is_current(
+ &self,
+ document_handle: DomHandle,
+ resolved_url: &str,
+ ) -> bool {
+ let owner = if document_handle == self.document_handle() {
+ self.current_main_document_task_owner()
+ } else {
+ self.child_browsing_context_host_for_document_handle(document_handle)
+ .and_then(|child_handle| self.frame_owner_current_child_snapshot(child_handle))
+ .filter(|snapshot| snapshot.document_handle == document_handle)
+ .map(|snapshot| {
+ FrameDocumentTaskOwner::new(
+ snapshot.scheduler_lane_id,
+ snapshot.local_window_id,
+ snapshot.document_id,
+ )
+ })
+ };
+ owner.is_some_and(|owner| {
+ self.image_resources
+ .css
+ .contains_current(document_handle, owner, resolved_url)
+ })
+ }
+
pub(crate) fn complete_stylesheet_css_image_response(
&mut self,
identity: &CssImageResourceRequestIdentity,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs
index ea884ec1f..2a11aa32d 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/state.rs
@@ -13,6 +13,7 @@ use super::{
preload::{ScannedImagePreloadStore, SharedScannedImagePreloadLoad},
};
use crate::document_runtime::DomHandle;
+use crate::native_bridge::context_host::visual_resource_generation::VisualResourceGeneration;
use crate::types::ImageRequestKey;
#[derive(Clone)]
@@ -29,7 +30,7 @@ pub(in crate::native_bridge::context_host) struct ImageResourceStore {
pub(super) css: CssImageResourceStore,
pub(super) scanned: ScannedImagePreloadStore,
pub(super) decode: ImageDecodeCoordinator,
- paint_generation: u64,
+ visual_generation: VisualResourceGeneration,
}
struct ImageResourceSlot {
@@ -97,20 +98,26 @@ impl ReadyImageResourceIndex {
impl Default for ImageResourceStore {
fn default() -> Self {
+ Self::new(VisualResourceGeneration::default())
+ }
+}
+
+impl ImageResourceStore {
+ pub(in crate::native_bridge::context_host) fn new(
+ visual_generation: VisualResourceGeneration,
+ ) -> Self {
let ready_by_request = ReadyImageResourceIndex::default();
let decode = ImageDecodeCoordinator::default();
Self {
slots: HashMap::new(),
- css: CssImageResourceStore::new(ready_by_request.clone()),
+ css: CssImageResourceStore::new(ready_by_request.clone(), visual_generation.clone()),
scanned: ScannedImagePreloadStore::new(ready_by_request.clone(), decode.clone()),
ready_by_request,
decode,
- paint_generation: 0,
+ visual_generation,
}
}
-}
-impl ImageResourceStore {
pub(super) fn begin(&mut self, identity: ImageResourceRequestIdentity) {
let ready = self.ready_by_request.get(&identity.request_key);
self.slots.insert(
@@ -121,7 +128,7 @@ impl ImageResourceStore {
scanned_preload: None,
},
);
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
}
pub(super) fn identity(&self, element: DomHandle) -> Option<&ImageResourceRequestIdentity> {
@@ -213,7 +220,7 @@ impl ImageResourceStore {
ImageResourceState::Pending => {
slot.state = ImageResourceState::Ready(resource);
slot.scanned_preload = None;
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
true
}
ImageResourceState::DecodeQueued(_) | ImageResourceState::Failed => false,
@@ -245,7 +252,7 @@ impl ImageResourceStore {
.insert(identity.request_key.clone(), &resource);
slot.state = ImageResourceState::Ready(resource);
slot.scanned_preload = None;
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
true
}
@@ -258,7 +265,7 @@ impl ImageResourceStore {
}
slot.state = ImageResourceState::Failed;
slot.scanned_preload = None;
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
true
}
@@ -297,7 +304,7 @@ impl ImageResourceStore {
pub(super) fn retire_element(&mut self, element: DomHandle) -> bool {
let removed = self.slots.remove(&element).is_some();
if removed {
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
}
self.prune_dead_ready_requests();
removed
@@ -310,7 +317,7 @@ impl ImageResourceStore {
self.prune_dead_ready_requests();
let removed = before - self.slots.len();
if removed != 0 {
- self.paint_generation = self.paint_generation.saturating_add(1);
+ self.visual_generation.bump();
}
removed
}
@@ -319,8 +326,13 @@ impl ImageResourceStore {
self.ready_by_request.prune_dead();
}
- pub(super) const fn paint_generation(&self) -> u64 {
- self.paint_generation
+ pub(super) fn visual_generation(&self) -> u64 {
+ self.visual_generation.current()
+ }
+
+ #[cfg(test)]
+ pub(super) fn visual_generation_handle_for_test(&self) -> VisualResourceGeneration {
+ self.visual_generation.clone()
}
}
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 5e8929991..e6c7602c1 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/layout.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/layout.rs
@@ -56,15 +56,6 @@ impl JsContextHost {
self.layout_policy
}
- fn css_image_discovery_stamp(&self) -> super::layout_state::CssImageDiscoveryStamp {
- super::layout_state::CssImageDiscoveryStamp::new(
- self.dom_host().dom_version(),
- self.style_engine
- .computed_style_observation_generations(self.active_layout_document_handles()),
- self.style_viewport(),
- )
- }
-
pub(crate) fn active_layout_document_handles(&self) -> Vec<DomHandle> {
let mut documents = vec![self.document_handle()];
documents.extend(
@@ -78,32 +69,6 @@ impl JsContextHost {
documents
}
- pub(crate) fn css_image_discovery_needed_for_paint(&self) -> bool {
- let stamp = self.css_image_discovery_stamp();
- !self
- .document_layout_state
- .borrow()
- .css_image_discovery_is_current(stamp)
- }
-
- pub(crate) fn publish_css_image_discovery_for_paint(&mut self) {
- let stamp = self.css_image_discovery_stamp();
- self.document_layout_state
- .get_mut()
- .publish_css_image_discovery(stamp);
- }
-
- pub(crate) fn paint_resource_generations(
- &self,
- ) -> super::layout_state::PaintResourceGenerations {
- let (html_images, css_images) = self.image_paint_generations();
- super::layout_state::PaintResourceGenerations {
- html_images,
- css_images,
- canvas: self.canvas_paint_generation(),
- }
- }
-
pub(crate) fn visual_state_generation(&self) -> u64 {
self.document_layout_state
.borrow()
@@ -115,29 +80,17 @@ impl JsContextHost {
document: crate::runtime::RendererDocumentLifecycleIdentity,
viewport: moli_layout::PaintViewport,
) -> crate::runtime::RendererVisualStateToken {
- let resources = self.paint_resource_generations();
crate::runtime::RendererVisualStateToken::new(
document,
self.dom_host().dom_version(),
self.style_engine
.computed_style_observation_generations(self.active_layout_document_handles()),
self.visual_state_generation(),
- (
- resources.html_images,
- resources.css_images,
- resources.canvas,
- ),
+ self.visual_resource_generation(),
viewport,
)
}
- #[cfg(test)]
- pub(crate) fn css_image_discovery_count_for_test(&self) -> u64 {
- self.document_layout_state
- .borrow()
- .css_image_discovery_count()
- }
-
pub(crate) fn layout_document_for_source(&self, source: DomHandle) -> Option<DomHandle> {
self.dom_host().owner_document_handle(source)
}
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 8a58e53b4..8679ca849 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
@@ -7,37 +7,8 @@ use crate::{
css_resource_urls::{CompletedStylesheetWebFont, StylesheetLoadBlockingResource},
document_runtime::DomHandle,
script_vm::web_fonts::{DocumentWebFontCompletion, DocumentWebFontState},
- style_engine::StyleViewport,
};
-#[derive(Clone, Debug, PartialEq)]
-pub(super) struct CssImageDiscoveryStamp {
- dom_version: u64,
- style_generations: Vec<(DomHandle, u64, u64, u64)>,
- viewport: StyleViewport,
-}
-
-impl CssImageDiscoveryStamp {
- pub(super) fn new(
- dom_version: u64,
- style_generations: Vec<(DomHandle, u64, u64, u64)>,
- viewport: StyleViewport,
- ) -> Self {
- Self {
- dom_version,
- style_generations,
- viewport,
- }
- }
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub(crate) struct PaintResourceGenerations {
- pub(super) html_images: u64,
- pub(super) css_images: u64,
- pub(super) canvas: u64,
-}
-
/// Layout-facing state whose lifetime is bounded by exactly one main Document.
///
/// `ScriptVm` outlives `document.open()`, so the main-document owner
@@ -54,9 +25,6 @@ pub(super) struct DocumentLayoutState {
embedded_document_services: HashMap<DomHandle, DocumentLayoutServices>,
web_fonts: DocumentWebFontState,
web_font_sources_dirty: bool,
- css_image_discovery_stamp: Option<CssImageDiscoveryStamp>,
- #[cfg(test)]
- css_image_discovery_count: u64,
visual_state_generation: u64,
latest_layout: LatestLayoutTreeCache,
/// Last used content viewport published by each live iframe owner's
@@ -73,9 +41,6 @@ impl Default for DocumentLayoutState {
embedded_document_services: HashMap::new(),
web_fonts: DocumentWebFontState::default(),
web_font_sources_dirty: true,
- css_image_discovery_stamp: None,
- #[cfg(test)]
- css_image_discovery_count: 0,
visual_state_generation: 0,
latest_layout: LatestLayoutTreeCache::default(),
frame_viewports: HashMap::new(),
@@ -92,23 +57,6 @@ impl DocumentLayoutState {
std::mem::take(&mut self.web_font_sources_dirty)
}
- pub(super) fn css_image_discovery_is_current(&self, stamp: CssImageDiscoveryStamp) -> bool {
- self.css_image_discovery_stamp == Some(stamp)
- }
-
- pub(super) fn publish_css_image_discovery(&mut self, stamp: CssImageDiscoveryStamp) {
- self.css_image_discovery_stamp = Some(stamp);
- #[cfg(test)]
- {
- self.css_image_discovery_count = self.css_image_discovery_count.saturating_add(1);
- }
- }
-
- #[cfg(test)]
- pub(super) const fn css_image_discovery_count(&self) -> u64 {
- self.css_image_discovery_count
- }
-
pub(super) const fn visual_state_generation(&self) -> u64 {
self.visual_state_generation
}
diff --git a/moli-renderer-v8/src/native_bridge/context_host/mod.rs b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
index c5c535d89..7d64a38f9 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs
@@ -152,6 +152,7 @@ mod text_track_default_modes;
mod traversal_state;
mod user_interaction_tasks;
mod view_transition_updates;
+pub(crate) mod visual_resource_generation;
mod webcrypto_tasks;
mod websockets;
mod window_document_tasks;
diff --git a/moli-renderer-v8/src/native_bridge/context_host/stylesheet_subresource_loads.rs b/moli-renderer-v8/src/native_bridge/context_host/stylesheet_subresource_loads.rs
index 67c35d0e6..7f1847364 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/stylesheet_subresource_loads.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/stylesheet_subresource_loads.rs
@@ -16,6 +16,26 @@ impl StylesheetSubresourceLoadDelaySettlement {
}
impl JsContextHost {
+ pub(crate) fn accept_current_stylesheet_subresource_load_delay_for_document(
+ &mut self,
+ document: DomHandle,
+ ) -> Option<StylesheetSubresourceLoadDelayBinding> {
+ if document == self.document_handle() {
+ return self.accept_current_main_stylesheet_subresource_load_delay();
+ }
+ let child_handle = self.child_browsing_context_host_for_document_handle(document)?;
+ let snapshot = self.frame_owner_current_child_snapshot(child_handle)?;
+ if snapshot.document_handle != document {
+ return None;
+ }
+ let owner = FrameDocumentTaskOwner::new(
+ snapshot.scheduler_lane_id,
+ snapshot.local_window_id,
+ snapshot.document_id,
+ );
+ self.accept_current_child_stylesheet_subresource_load_delay(child_handle, owner)
+ }
+
pub(crate) fn accept_current_main_stylesheet_subresource_load_delay(
&mut self,
) -> Option<StylesheetSubresourceLoadDelayBinding> {
diff --git a/moli-renderer-v8/src/native_bridge/context_host/visual_resource_generation.rs b/moli-renderer-v8/src/native_bridge/context_host/visual_resource_generation.rs
new file mode 100644
index 000000000..6a535fb17
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/context_host/visual_resource_generation.rs
@@ -0,0 +1,22 @@
+use std::sync::{
+ Arc,
+ atomic::{AtomicU64, Ordering},
+};
+
+/// Shared generation for immutable resources sampled by one paint pass.
+///
+/// HTML images, CSS images, and canvases all contribute pixels to the same
+/// visual output. Keeping one cloneable atomic lets asynchronous decoders and
+/// owner-thread mutations publish through the same screencast race fence.
+#[derive(Clone, Default)]
+pub(crate) struct VisualResourceGeneration(Arc<AtomicU64>);
+
+impl VisualResourceGeneration {
+ pub(crate) fn current(&self) -> u64 {
+ self.0.load(Ordering::Acquire)
+ }
+
+ pub(crate) fn bump(&self) {
+ self.0.fetch_add(1, Ordering::AcqRel);
+ }
+}
diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs
index ed6bae7e1..aa52e458e 100644
--- a/moli-renderer-v8/src/runtime/mod.rs
+++ b/moli-renderer-v8/src/runtime/mod.rs
@@ -293,8 +293,9 @@ pub(crate) use self::page_context_cancel::{
RendererPageContextCancelSender, renderer_page_context_cancel_channel,
};
pub use self::page_screenshot::{
- RendererCaptureScreenshotRequest, RendererScreenshotClip, RendererScreenshotFormat,
- RendererScreenshotPurpose, RendererScreenshotRegion, RendererVisualStateToken,
+ RendererCaptureScreencastFrameRequest, RendererCaptureScreenshotRequest,
+ RendererScreenshotClip, RendererScreenshotFormat, RendererScreenshotPurpose,
+ RendererScreenshotRegion, RendererVisualStateToken,
};
pub(super) use self::page_state::RendererPageEntry;
pub use self::page_state::RendererPageRecord;
@@ -305,17 +306,18 @@ pub use self::page_surface::RendererRuntimeInspectorMessageResponseOrder;
pub use self::page_surface::{
DevToolsSessionKey, RendererAccessibilityPayloadsForObjectId, RendererActivityDiagnostics,
RendererAgentAttachmentId, RendererAutofillAddressField, RendererAutofillCreditCard,
- RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest, RendererCaptureScreenshotReply,
- RendererCapturedScreenshot, RendererCommandTurnCompletion, RendererCommandTurnOutput,
- RendererCountEntry, RendererDedicatedWorkerTargetEvent, RendererDedicatedWorkerTargetInfo,
- RendererDevToolsAgentToken, RendererDocumentBoxModel, RendererDocumentChildNodeSnapshotEvent,
- RendererDocumentChildNodeSnapshotEvents, RendererDocumentChildNodeSnapshots,
- RendererDocumentFrontendNodeIdsResolution, RendererDocumentHitTestResult,
- RendererDocumentIsolateAccountingDiagnostics, RendererDocumentNodeAttributesResolution,
- RendererDocumentNodeClientRect, RendererDocumentNodeGeometry,
- RendererDocumentNodePropertyResolution, RendererDocumentNodeReference,
- RendererDocumentNodeTextResolution, RendererDocumentQuerySelectorNode,
- RendererDocumentQuerySelectorResolution,
+ RendererAutofillTriggerOutcome, RendererAutofillTriggerRequest,
+ RendererCaptureScreencastFrameReply, RendererCaptureScreenshotReply,
+ RendererCapturedScreencastFrame, RendererCapturedScreenshot, RendererCommandTurnCompletion,
+ RendererCommandTurnOutput, RendererCountEntry, RendererDedicatedWorkerTargetEvent,
+ RendererDedicatedWorkerTargetInfo, RendererDevToolsAgentToken, RendererDocumentBoxModel,
+ RendererDocumentChildNodeSnapshotEvent, RendererDocumentChildNodeSnapshotEvents,
+ RendererDocumentChildNodeSnapshots, RendererDocumentFrontendNodeIdsResolution,
+ RendererDocumentHitTestResult, RendererDocumentIsolateAccountingDiagnostics,
+ RendererDocumentNodeAttributesResolution, RendererDocumentNodeClientRect,
+ RendererDocumentNodeGeometry, RendererDocumentNodePropertyResolution,
+ RendererDocumentNodeReference, RendererDocumentNodeTextResolution,
+ RendererDocumentQuerySelectorNode, RendererDocumentQuerySelectorResolution,
RendererDocumentQuerySelectorWithChildNodeSnapshotEvents,
RendererDocumentSourcedSameDocumentNavigation,
RendererDocumentSourcedTopLevelLocationNavigation, RendererDomAttributeMutation,
diff --git a/moli-renderer-v8/src/runtime/page_commands.rs b/moli-renderer-v8/src/runtime/page_commands.rs
index 2f5a15aa1..41efb2302 100644
--- a/moli-renderer-v8/src/runtime/page_commands.rs
+++ b/moli-renderer-v8/src/runtime/page_commands.rs
@@ -861,6 +861,9 @@ impl PageVm {
RendererPageCommand::CaptureScreenshot(request) => self
.capture_screenshot(request)
.map(RendererPageReply::CaptureScreenshot),
+ RendererPageCommand::CaptureScreencastFrame(request) => self
+ .capture_screencast_frame(request)
+ .map(RendererPageReply::CaptureScreencastFrame),
RendererPageCommand::BlobBytesForUuid { uuid } => Ok(
RendererPageReply::OptionalBlobBytes(self.vm().blob_bytes_for_uuid(&uuid)),
),
@@ -1406,9 +1409,11 @@ fn renderer_page_command_action_barrier(
}
RendererPageCommand::CaptureScreenshot(request) => Some(match request.purpose {
RendererScreenshotPurpose::Screenshot => moli_action_window::ActionBarrier::Screenshot,
- RendererScreenshotPurpose::Screencast => moli_action_window::ActionBarrier::Screencast,
RendererScreenshotPurpose::Print { .. } => moli_action_window::ActionBarrier::Explicit,
}),
+ RendererPageCommand::CaptureScreencastFrame(_) => {
+ Some(moli_action_window::ActionBarrier::Screencast)
+ }
_ => Some(moli_action_window::ActionBarrier::Explicit),
}
}
diff --git a/moli-renderer-v8/src/runtime/page_screenshot.rs b/moli-renderer-v8/src/runtime/page_screenshot.rs
index 4a4c1a799..804d03cb2 100644
--- a/moli-renderer-v8/src/runtime/page_screenshot.rs
+++ b/moli-renderer-v8/src/runtime/page_screenshot.rs
@@ -4,8 +4,8 @@ use moli_page_types::LayoutPolicy;
use std::sync::Arc;
use super::{
- PageVm, RendererCaptureScreenshotReply, RendererCapturedScreenshot,
- RendererDocumentLifecycleIdentity,
+ PageVm, RendererCaptureScreencastFrameReply, RendererCaptureScreenshotReply,
+ RendererCapturedScreencastFrame, RendererCapturedScreenshot, RendererDocumentLifecycleIdentity,
};
/// Opaque identity for the renderer state that can affect one viewport frame.
@@ -21,9 +21,7 @@ struct RendererVisualState {
dom_generation: u64,
style_generations: Vec<(u32, u64, u64, u64)>,
interaction_generation: u64,
- html_image_generation: u64,
- css_image_generation: u64,
- canvas_generation: u64,
+ resource_generation: u64,
viewport_width: u32,
viewport_height: u32,
device_pixel_ratio_bits: u32,
@@ -35,7 +33,7 @@ impl RendererVisualStateToken {
dom_generation: u64,
style_generations: Vec<(crate::document_runtime::DomHandle, u64, u64, u64)>,
interaction_generation: u64,
- resource_generations: (u64, u64, u64),
+ resource_generation: u64,
viewport: PaintViewport,
) -> Self {
Self(Arc::new(RendererVisualState {
@@ -48,23 +46,19 @@ impl RendererVisualStateToken {
})
.collect(),
interaction_generation,
- html_image_generation: resource_generations.0,
- css_image_generation: resource_generations.1,
- canvas_generation: resource_generations.2,
+ resource_generation,
viewport_width: viewport.css_width,
viewport_height: viewport.css_height,
device_pixel_ratio_bits: viewport.device_pixel_ratio.to_bits(),
}))
}
- fn has_same_paint_resources(&self, other: &Self) -> bool {
- self.0.html_image_generation == other.0.html_image_generation
- && self.0.css_image_generation == other.0.css_image_generation
- && self.0.canvas_generation == other.0.canvas_generation
+ fn has_same_resource_generation(&self, other: &Self) -> bool {
+ self.0.resource_generation == other.0.resource_generation
}
}
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RendererScreenshotFormat {
Png,
Jpeg,
@@ -73,7 +67,6 @@ pub enum RendererScreenshotFormat {
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum RendererScreenshotPurpose {
Screenshot,
- Screencast,
Print { print_background: bool },
}
@@ -108,8 +101,18 @@ pub struct RendererCaptureScreenshotRequest {
pub optimize_for_speed: bool,
pub max_width: Option<u32>,
pub max_height: Option<u32>,
- /// Last frame state observed by this screencast subscription. Ordinary
- /// screenshots leave this empty and always execute a fresh paint pass.
+}
+
+/// One viewport screencast poll. Unlike an explicit screenshot, the caller
+/// may supply the last emitted visual state and receive `Unchanged` without a
+/// layout or paint pass.
+#[derive(Clone, Debug, PartialEq)]
+pub struct RendererCaptureScreencastFrameRequest {
+ pub format: RendererScreenshotFormat,
+ pub quality: u8,
+ pub optimize_for_speed: bool,
+ pub max_width: Option<u32>,
+ pub max_height: Option<u32>,
pub known_visual_state: Option<RendererVisualStateToken>,
}
@@ -123,27 +126,23 @@ impl RendererCaptureScreenshotRequest {
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
}
}
}
impl PageVm {
- /// Captures the current committed document at one renderer-owner command
- /// turn. The pass-local world, Stylo values, and Taffy cache do not escape;
- /// the owned geometry projection is published as the Document's latest
- /// observable layout snapshot. Screencast polling can be suppressed by an
- /// unchanged generation token, but every emitted frame is painted fresh.
+ /// Captures an explicit screenshot or print raster. These demands always
+ /// execute a fresh paint pass and never carry screencast state.
pub(super) fn capture_screenshot(
&mut self,
request: RendererCaptureScreenshotRequest,
) -> anyhow::Result<RendererCaptureScreenshotReply> {
let barrier = match request.purpose {
RendererScreenshotPurpose::Screenshot => moli_action_window::ActionBarrier::Screenshot,
- RendererScreenshotPurpose::Screencast => moli_action_window::ActionBarrier::Screencast,
RendererScreenshotPurpose::Print { .. } => moli_action_window::ActionBarrier::Explicit,
};
self.flush_page_action_window(barrier)?;
+ let paint_capture = request.paint_capture_request()?;
let restore_media = if matches!(request.purpose, RendererScreenshotPurpose::Print { .. })
&& self.emulated_media.media.is_none()
{
@@ -155,21 +154,46 @@ impl PageVm {
} else {
None
};
- let result = self.capture_screenshot_inner(request);
+ let result = self.capture_image(
+ request.format,
+ request.quality,
+ request.optimize_for_speed,
+ paint_capture,
+ moli_layout::LayoutFlushReason::Screenshot,
+ );
if let Some(previous) = restore_media {
self.set_emulated_media(&previous);
}
- result
+ result.map(RendererImageCaptureOutcome::into_screenshot_reply)
}
- fn capture_screenshot_inner(
+ /// Polls one screencast subscription. Only this request accepts a known
+ /// visual state and only this reply can report `Unchanged`.
+ pub(super) fn capture_screencast_frame(
&mut self,
- request: RendererCaptureScreenshotRequest,
- ) -> anyhow::Result<RendererCaptureScreenshotReply> {
+ request: RendererCaptureScreencastFrameRequest,
+ ) -> anyhow::Result<RendererCaptureScreencastFrameReply> {
+ self.capture_screencast_frame_with_before_layout(request, || {})
+ }
+
+ #[cfg(test)]
+ pub(super) fn capture_screencast_frame_with_before_layout_hook(
+ &mut self,
+ request: RendererCaptureScreencastFrameRequest,
+ before_layout: impl FnOnce(),
+ ) -> anyhow::Result<RendererCaptureScreencastFrameReply> {
+ self.capture_screencast_frame_with_before_layout(request, before_layout)
+ }
+
+ fn capture_screencast_frame_with_before_layout(
+ &mut self,
+ request: RendererCaptureScreencastFrameRequest,
+ before_layout: impl FnOnce(),
+ ) -> anyhow::Result<RendererCaptureScreencastFrameReply> {
+ self.flush_page_action_window(moli_action_window::ActionBarrier::Screencast)?;
if self.layout_policy == LayoutPolicy::Mock {
- return Ok(RendererCaptureScreenshotReply::LayoutDisabled);
+ return Ok(RendererCaptureScreencastFrameReply::LayoutDisabled);
}
-
let surface = self
.viewport_surface
.unwrap_or_else(default_viewport_surface);
@@ -178,76 +202,131 @@ impl PageVm {
surface.inner_height,
surface.device_pixel_ratio as f32,
);
- let paint_capture = request.paint_capture_request()?;
- let visual_state_before = matches!(request.purpose, RendererScreenshotPurpose::Screencast)
- .then(|| {
- self.vm()
- .visual_state_token(self.document_lifecycle.identity(), viewport)
- });
- if visual_state_before.is_some()
- && visual_state_before.as_ref() == request.known_visual_state.as_ref()
- {
- return Ok(RendererCaptureScreenshotReply::ScreencastUnchanged);
+ let visual_state_before = self
+ .vm()
+ .visual_state_token(self.document_lifecycle.identity(), viewport);
+ if request.known_visual_state.as_ref() == Some(&visual_state_before) {
+ return Ok(RendererCaptureScreencastFrameReply::Unchanged);
}
- let layout_reason = match request.purpose {
- RendererScreenshotPurpose::Screenshot | RendererScreenshotPurpose::Print { .. } => {
- moli_layout::LayoutFlushReason::Screenshot
- }
- RendererScreenshotPurpose::Screencast => moli_layout::LayoutFlushReason::Screencast,
+ before_layout();
+ let paint_capture = PaintCaptureRequest {
+ region: moli_layout::PaintCaptureRegion::Viewport,
+ include_backgrounds: true,
+ include_viewport_controls: true,
+ max_width: request.max_width,
+ max_height: request.max_height,
};
- let Some(snapshot) = self.vm_mut().paint_layout_snapshot_with_capture(
- viewport,
- layout_reason,
+ let image = match self.capture_image(
+ request.format,
+ request.quality,
+ request.optimize_for_speed,
paint_capture,
- )?
+ moli_layout::LayoutFlushReason::Screencast,
+ )? {
+ RendererImageCaptureOutcome::Captured(image) => image,
+ RendererImageCaptureOutcome::LayoutDisabled => {
+ return Ok(RendererCaptureScreencastFrameReply::LayoutDisabled);
+ }
+ RendererImageCaptureOutcome::NoDocument => {
+ return Ok(RendererCaptureScreencastFrameReply::NoDocument);
+ }
+ };
+ let visual_state_after = self
+ .vm()
+ .visual_state_token(self.document_lifecycle.identity(), viewport);
+ let visual_state =
+ visual_state_for_captured_screencast_frame(visual_state_before, visual_state_after);
+ Ok(RendererCaptureScreencastFrameReply::Captured(
+ RendererCapturedScreencastFrame {
+ image,
+ visual_state,
+ },
+ ))
+ }
+
+ fn capture_image(
+ &mut self,
+ format: RendererScreenshotFormat,
+ quality: u8,
+ optimize_for_speed: bool,
+ paint_capture: PaintCaptureRequest,
+ reason: moli_layout::LayoutFlushReason,
+ ) -> anyhow::Result<RendererImageCaptureOutcome> {
+ if self.layout_policy == LayoutPolicy::Mock {
+ return Ok(RendererImageCaptureOutcome::LayoutDisabled);
+ }
+ let surface = self
+ .viewport_surface
+ .unwrap_or_else(default_viewport_surface);
+ let viewport = PaintViewport::new(
+ surface.inner_width,
+ surface.inner_height,
+ surface.device_pixel_ratio as f32,
+ );
+ let Some(snapshot) =
+ self.vm_mut()
+ .paint_layout_snapshot_with_capture(viewport, reason, paint_capture)?
else {
- return Ok(RendererCaptureScreenshotReply::NoDocument);
+ return Ok(RendererImageCaptureOutcome::NoDocument);
};
- let visual_state = visual_state_before.map(|before| {
- let after = self
- .vm()
- .visual_state_token(self.document_lifecycle.identity(), viewport);
- // Resource decoders can publish from another task while layout is
- // sampling immutable resources. Keep the older token in that
- // race so the next poll cannot mistake a potentially stale frame
- // for the newly completed resource state. Other generation
- // changes here are renderer-internal world preparation and are
- // represented by the completed fresh frame.
- if before.has_same_paint_resources(&after) {
- after
- } else {
- before
- }
- });
let raster = moli_paint::raster_snapshot(&snapshot)?;
- let (mime_type, width, height, bytes) = match request.format {
+ let (mime_type, width, height, bytes) = match format {
RendererScreenshotFormat::Png => {
let encoded = moli_image::encode_png_with_options(
&raster,
- moli_image::PngEncodeOptions {
- optimize_for_speed: request.optimize_for_speed,
- },
+ moli_image::PngEncodeOptions { optimize_for_speed },
)?;
("image/png", encoded.width, encoded.height, encoded.bytes)
}
RendererScreenshotFormat::Jpeg => {
- let encoded = moli_image::encode_jpeg(&raster, request.quality)?;
+ let encoded = moli_image::encode_jpeg(&raster, quality)?;
("image/jpeg", encoded.width, encoded.height, encoded.bytes)
}
};
- Ok(RendererCaptureScreenshotReply::Captured(
+ Ok(RendererImageCaptureOutcome::Captured(
RendererCapturedScreenshot {
mime_type: mime_type.to_owned(),
width,
height,
bytes: bytes.into(),
- visual_state,
},
))
}
}
+enum RendererImageCaptureOutcome {
+ Captured(RendererCapturedScreenshot),
+ LayoutDisabled,
+ NoDocument,
+}
+
+impl RendererImageCaptureOutcome {
+ fn into_screenshot_reply(self) -> RendererCaptureScreenshotReply {
+ match self {
+ Self::Captured(image) => RendererCaptureScreenshotReply::Captured(image),
+ Self::LayoutDisabled => RendererCaptureScreenshotReply::LayoutDisabled,
+ Self::NoDocument => RendererCaptureScreenshotReply::NoDocument,
+ }
+ }
+}
+
+fn visual_state_for_captured_screencast_frame(
+ before: RendererVisualStateToken,
+ after: RendererVisualStateToken,
+) -> RendererVisualStateToken {
+ // Resource decoders can publish from another task while layout samples
+ // immutable resources. Keep the older token in that race so the next poll
+ // cannot mistake a potentially stale frame for the new resource state.
+ // Other changes are renderer-internal world preparation represented by
+ // the completed fresh frame.
+ if before.has_same_resource_generation(&after) {
+ after
+ } else {
+ before
+ }
+}
+
impl RendererCaptureScreenshotRequest {
fn paint_capture_request(&self) -> anyhow::Result<PaintCaptureRequest> {
let include_viewport_controls = matches!(
@@ -274,9 +353,7 @@ impl RendererCaptureScreenshotRequest {
region,
include_backgrounds: match self.purpose {
RendererScreenshotPurpose::Print { print_background } => print_background,
- RendererScreenshotPurpose::Screenshot | RendererScreenshotPurpose::Screencast => {
- true
- }
+ RendererScreenshotPurpose::Screenshot => true,
},
include_viewport_controls,
max_width: self.max_width,
diff --git a/moli-renderer-v8/src/runtime/page_surface.rs b/moli-renderer-v8/src/runtime/page_surface.rs
index 015d663dc..072b91f31 100644
--- a/moli-renderer-v8/src/runtime/page_surface.rs
+++ b/moli-renderer-v8/src/runtime/page_surface.rs
@@ -4241,6 +4241,7 @@ pub enum RendererPageCommand {
SerializeHtml,
LayoutMetrics,
CaptureScreenshot(RendererCaptureScreenshotRequest),
+ CaptureScreencastFrame(RendererCaptureScreencastFrameRequest),
BlobBytesForUuid {
uuid: String,
},
@@ -4834,6 +4835,7 @@ impl RendererPageCommand {
Self::SerializeHtml => Some("SerializeHtml"),
Self::LayoutMetrics => Some("LayoutMetrics"),
Self::CaptureScreenshot(_) => Some("CaptureScreenshot"),
+ Self::CaptureScreencastFrame(_) => Some("CaptureScreencastFrame"),
Self::ScrollBackendNodeIntoViewIfNeeded { .. } => {
Some("ScrollBackendNodeIntoViewIfNeeded")
}
@@ -5133,13 +5135,25 @@ pub struct RendererCapturedScreenshot {
pub width: u32,
pub height: u32,
pub bytes: Arc<[u8]>,
- pub visual_state: Option<RendererVisualStateToken>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum RendererCaptureScreenshotReply {
Captured(RendererCapturedScreenshot),
- ScreencastUnchanged,
+ LayoutDisabled,
+ NoDocument,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct RendererCapturedScreencastFrame {
+ pub image: RendererCapturedScreenshot,
+ pub visual_state: RendererVisualStateToken,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum RendererCaptureScreencastFrameReply {
+ Captured(RendererCapturedScreencastFrame),
+ Unchanged,
LayoutDisabled,
NoDocument,
}
@@ -5217,6 +5231,7 @@ pub enum RendererPageReply {
CookieFacadeSnapshot(Box<RendererPageCookieFacadeSnapshotReply>),
LayoutMetrics(RendererLayoutMetrics),
CaptureScreenshot(RendererCaptureScreenshotReply),
+ CaptureScreencastFrame(RendererCaptureScreencastFrameReply),
Unit,
}
diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
index 71301684d..4437a4beb 100644
--- a/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
+++ b/moli-renderer-v8/src/runtime/page_vm/tests/rendering_update.rs
@@ -11,12 +11,10 @@ use crate::script_vm::MainDocumentLifecycleBody;
fn viewport_screencast_request(
known_visual_state: Option<crate::runtime::RendererVisualStateToken>,
-) -> crate::runtime::RendererCaptureScreenshotRequest {
- crate::runtime::RendererCaptureScreenshotRequest {
- purpose: crate::runtime::RendererScreenshotPurpose::Screencast,
+) -> crate::runtime::RendererCaptureScreencastFrameRequest {
+ crate::runtime::RendererCaptureScreencastFrameRequest {
format: crate::runtime::RendererScreenshotFormat::Png,
quality: 100,
- region: crate::runtime::RendererScreenshotRegion::Viewport,
optimize_for_speed: true,
max_width: None,
max_height: None,
@@ -464,24 +462,22 @@ child.adoptedStyleSheets = [globalThis.__childScreencastSheet];
)?;
let passes_before = page_vm.vm().layout_pass_observability_for_test().1;
- let crate::runtime::RendererCaptureScreenshotReply::Captured(first) =
- page_vm.capture_screenshot(viewport_screencast_request(None))?
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(first) =
+ page_vm.capture_screencast_frame(viewport_screencast_request(None))?
else {
panic!("first child-style screencast demand must capture a frame");
};
- let first_raster = moli_image::decode_png(&first.bytes)?;
+ let first_raster = moli_image::decode_png(&first.image.bytes)?;
assert_eq!(&first_raster.rgba[0..4], [255, 0, 0, 255]);
- let first_visual_state = first
- .visual_state
- .expect("a screencast frame must publish visual-state metadata");
+ let first_visual_state = first.visual_state;
let passes_after_first = page_vm.vm().layout_pass_observability_for_test().1;
assert_eq!(passes_after_first, passes_before + 1);
assert_eq!(
- page_vm.capture_screenshot(viewport_screencast_request(Some(
+ page_vm.capture_screencast_frame(viewport_screencast_request(Some(
first_visual_state.clone(),
)))?,
- crate::runtime::RendererCaptureScreenshotReply::ScreencastUnchanged,
+ crate::runtime::RendererCaptureScreencastFrameReply::Unchanged,
);
assert_eq!(
page_vm.vm().layout_pass_observability_for_test().1,
@@ -492,8 +488,8 @@ child.adoptedStyleSheets = [globalThis.__childScreencastSheet];
page_vm
.vm_mut()
.eval("globalThis.__childScreencastSheet.replaceSync('body { background: blue; }')")?;
- let crate::runtime::RendererCaptureScreenshotReply::Captured(refreshed) = page_vm
- .capture_screenshot(viewport_screencast_request(Some(
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(refreshed) = page_vm
+ .capture_screencast_frame(viewport_screencast_request(Some(
first_visual_state.clone(),
)))?
else {
@@ -504,8 +500,8 @@ child.adoptedStyleSheets = [globalThis.__childScreencastSheet];
passes_after_first + 1,
"a child-only stylesheet generation must invalidate the session token",
);
- assert_ne!(refreshed.visual_state.as_ref(), Some(&first_visual_state));
- let refreshed_raster = moli_image::decode_png(&refreshed.bytes)?;
+ assert_ne!(refreshed.visual_state, first_visual_state);
+ let refreshed_raster = moli_image::decode_png(&refreshed.image.bytes)?;
assert_eq!(&refreshed_raster.rgba[0..4], [0, 0, 255, 255]);
Ok::<_, anyhow::Error>(())
})
@@ -551,17 +547,21 @@ context.fillRect(0, 0, 40, 100);
"#,
)?;
- let crate::runtime::RendererCaptureScreenshotReply::Captured(first) =
- page_vm.capture_screenshot(viewport_screencast_request(None))?
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(first) =
+ page_vm.capture_screencast_frame(viewport_screencast_request(None))?
else {
panic!("initial canvas screencast demand must capture a frame");
};
- let first_state = first.visual_state.expect("initial visual-state token");
- assert_eq!(&moli_image::decode_png(&first.bytes)?.rgba[0..4], [255, 0, 0, 255]);
+ let first_state = first.visual_state;
+ assert_eq!(
+ &moli_image::decode_png(&first.image.bytes)?.rgba[0..4],
+ [255, 0, 0, 255]
+ );
assert_eq!(
- page_vm.capture_screenshot(viewport_screencast_request(Some(first_state.clone())))?,
- crate::runtime::RendererCaptureScreenshotReply::ScreencastUnchanged,
+ page_vm
+ .capture_screencast_frame(viewport_screencast_request(Some(first_state.clone())))?,
+ crate::runtime::RendererCaptureScreencastFrameReply::Unchanged,
);
// Canvas pixel writes do not mutate the DOM or stylesheet worlds. The
@@ -569,40 +569,34 @@ context.fillRect(0, 0, 40, 100);
page_vm.vm_mut().eval(
"const c=document.getElementById('surface').getContext('2d');c.fillStyle='#0000ff';c.fillRect(0,0,40,100);'painted'",
)?;
- let crate::runtime::RendererCaptureScreenshotReply::Captured(canvas_frame) = page_vm
- .capture_screenshot(viewport_screencast_request(Some(first_state.clone())))?
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(canvas_frame) = page_vm
+ .capture_screencast_frame(viewport_screencast_request(Some(first_state.clone())))?
else {
panic!("canvas mutation must capture a fresh screencast frame");
};
- let canvas_state = canvas_frame
- .visual_state
- .expect("canvas frame visual-state token");
+ let canvas_state = canvas_frame.visual_state;
assert_ne!(canvas_state, first_state);
assert_eq!(
- &moli_image::decode_png(&canvas_frame.bytes)?.rgba[0..4],
+ &moli_image::decode_png(&canvas_frame.image.bytes)?.rgba[0..4],
[0, 0, 255, 255]
);
page_vm.vm_mut().eval("scrollTo(0, 30); scrollY")?;
- let crate::runtime::RendererCaptureScreenshotReply::Captured(scrolled) = page_vm
- .capture_screenshot(viewport_screencast_request(Some(canvas_state.clone())))?
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(scrolled) = page_vm
+ .capture_screencast_frame(viewport_screencast_request(Some(canvas_state.clone())))?
else {
panic!("scroll mutation must capture a fresh screencast frame");
};
- let scrolled_state = scrolled
- .visual_state
- .expect("scrolled frame visual-state token");
+ let scrolled_state = scrolled.visual_state;
assert_ne!(scrolled_state, canvas_state);
let passes_before_screenshot = page_vm.vm().layout_pass_observability_for_test().1;
- let mut screenshot = crate::runtime::RendererCaptureScreenshotRequest::viewport_png();
- screenshot.known_visual_state = Some(scrolled_state);
let crate::runtime::RendererCaptureScreenshotReply::Captured(screenshot) =
- page_vm.capture_screenshot(screenshot)?
+ page_vm.capture_screenshot(crate::runtime::RendererCaptureScreenshotRequest::viewport_png())?
else {
panic!("ordinary screenshots must ignore screencast token suppression");
};
- assert!(screenshot.visual_state.is_none());
+ assert_eq!(screenshot.mime_type, "image/png");
assert_eq!(
page_vm.vm().layout_pass_observability_for_test().1,
passes_before_screenshot + 1,
@@ -613,6 +607,62 @@ context.fillRect(0, 0, 40, 100);
.expect("screencast visual generations fixture should run");
}
+#[tokio::test(flavor = "current_thread")]
+async fn async_resource_publication_during_screencast_capture_forces_a_followup_frame() {
+ run_page_vm_async_test(async move {
+ let loader =
+ crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
+ let mut page_vm = test_page_vm_with_loader_and_document_url(
+ &loader,
+ Vec::new(),
+ Url::parse("https://example.com/screencast-resource-race.html")?,
+ );
+ page_vm
+ .vm_mut()
+ .eval("document.documentElement.style.cssText='margin:0;background:red';'ready'")?;
+
+ let generation = page_vm.vm().visual_resource_generation_handle_for_test();
+ let rendezvous = std::sync::Arc::new(std::sync::Barrier::new(2));
+ let worker_rendezvous = rendezvous.clone();
+ let completion = std::thread::spawn(move || {
+ worker_rendezvous.wait();
+ generation.bump();
+ worker_rendezvous.wait();
+ });
+
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(raced) = page_vm
+ .capture_screencast_frame_with_before_layout_hook(
+ viewport_screencast_request(None),
+ || {
+ rendezvous.wait();
+ rendezvous.wait();
+ },
+ )?
+ else {
+ panic!("the initial screencast poll must capture a frame");
+ };
+ completion
+ .join()
+ .expect("the asynchronous resource publisher must finish");
+
+ let crate::runtime::RendererCaptureScreencastFrameReply::Captured(followup) = page_vm
+ .capture_screencast_frame(viewport_screencast_request(Some(raced.visual_state)))?
+ else {
+ panic!("a resource publication racing the prior paint must force one followup frame");
+ };
+ assert_eq!(
+ page_vm.capture_screencast_frame(viewport_screencast_request(Some(
+ followup.visual_state,
+ )))?,
+ crate::runtime::RendererCaptureScreencastFrameReply::Unchanged,
+ "the followup frame must close the resource-generation race",
+ );
+ Ok::<_, anyhow::Error>(())
+ })
+ .await
+ .expect("screencast resource-race fixture should run");
+}
+
#[tokio::test(flavor = "current_thread")]
async fn screenshot_composes_iframe_documents_into_exact_used_content_viewports() {
run_page_vm_async_test(async move {
@@ -2153,10 +2203,12 @@ document.body.innerHTML = '<div id=negative class=case></div><div id=overflow cl
}
#[tokio::test]
-async fn child_document_cssom_invalidates_generation_gated_image_discovery() {
+async fn child_document_layout_discovers_cssom_image_with_child_resource_owner() {
run_page_vm_async_test(async move {
let image_url =
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M/wHwAF/gL+3MxZ5wAAAABJRU5ErkJggg==";
+ let hidden_image_url =
+ "data:image/webp;base64,UklGRhwAAABXRUJQVlA4TA8AAAAvAUAAAAcQ/Y/+ByKi/wEA";
let loader =
crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader");
loader.set_optional_resource_fetch_mask(
@@ -2175,7 +2227,7 @@ async fn child_document_cssom_invalidates_generation_gated_image_discovery() {
const frame = document.createElement('iframe');
document.body.appendChild(frame);
const child = frame.contentDocument;
-child.body.innerHTML = '<div id=target style="width:20px;height:20px"></div>';
+child.body.innerHTML = '<div id=target style="width:20px;height:20px"></div><div id=hidden></div>';
globalThis.__childImageSheet = new frame.contentWindow.CSSStyleSheet();
globalThis.__childImageSheet.replaceSync('#target { background: red; }');
child.adoptedStyleSheets = [globalThis.__childImageSheet];
@@ -2188,30 +2240,20 @@ child.adoptedStyleSheets = [globalThis.__childImageSheet];
.vm_mut()
.screenshot_layout_snapshot(viewport)?
.expect("initial child document paint");
- let after_first = page_vm.vm().css_image_discovery_count_for_test();
page_vm
.vm_mut()
.screenshot_layout_snapshot(viewport)?
.expect("clean child document paint");
- assert_eq!(
- page_vm.vm().css_image_discovery_count_for_test(),
- after_first,
- "a clean child style world must reuse its discovery result",
- );
page_vm.vm_mut().eval(&format!(
- "globalThis.__childImageSheet.replaceSync('#target {{ background-image: url({}); }}')",
+ "globalThis.__childImageSheet.replaceSync('#target {{ background-image: url({}); }} #hidden {{ display:none; background-image:url({}); }}')",
serde_json::to_string(image_url)?,
+ serde_json::to_string(hidden_image_url)?,
))?;
page_vm
.vm_mut()
.screenshot_layout_snapshot(viewport)?
.expect("mutated child document paint");
- assert_eq!(
- page_vm.vm().css_image_discovery_count_for_test(),
- after_first + 1,
- "a child-only CSSOM generation must invalidate root paint discovery",
- );
assert!(
page_vm
.vm()
@@ -2219,7 +2261,16 @@ child.adoptedStyleSheets = [globalThis.__childImageSheet];
.4
.iter()
.any(|url| url == image_url),
- "computed discovery must walk the child Document root",
+ "the recursive child layout must bind its computed URL to the child Document",
+ );
+ assert!(
+ !page_vm
+ .vm()
+ .css_image_resource_observability_for_test()
+ .4
+ .iter()
+ .any(|url| url == hidden_image_url),
+ "a display:none subtree must not fetch a CSS image merely because it exists in the DOM",
);
Ok::<_, anyhow::Error>(())
})
@@ -2228,7 +2279,7 @@ child.adoptedStyleSheets = [globalThis.__childImageSheet];
}
#[tokio::test]
-async fn css_image_discovery_is_generation_gated_across_fresh_paint_passes() {
+async fn css_image_discovery_runs_inside_each_fresh_paint_layout() {
run_page_vm_async_test(async move {
// A lossless 2x2 red WebP. Keep the HTTP fixture encoded so this
// product path exercises metadata probing and bounded WebP decode.
@@ -2262,6 +2313,12 @@ async fn css_image_discovery_is_generation_gated_across_fresh_paint_passes() {
br#"<svg xmlns="http://www.w3.org/2000/svg" width="40" height="20"><rect x="20" width="20" height="20" fill="white"/></svg>"#,
)
);
+ let pseudo_url = format!(
+ "data:image/svg+xml;base64,{}",
+ base64::engine::general_purpose::STANDARD.encode(
+ br#"<svg xmlns="http://www.w3.org/2000/svg" width="2" height="2"><rect width="2" height="2" fill="green"/></svg>"#,
+ )
+ );
let css = format!(
r#"
html,body{{margin:0;padding:0;background:white}}
@@ -2271,10 +2328,12 @@ html,body{{margin:0;padding:0;background:white}}
#masked{{top:60px;background:red;mask-image:url("{mask_url}");mask-size:40px 20px;mask-repeat:no-repeat}}
#inline-line{{position:absolute;left:0;top:90px;font:20px/20px sans-serif}}
#inline-vector{{padding:0 10px;color:transparent;background-image:url("{vector_url}");background-size:20px 20px;background-repeat:repeat-x}}
+#pseudo{{position:absolute;left:50px;top:0;width:20px;height:20px}}
+#pseudo::before{{content:"";display:block;width:20px;height:20px;background-image:url("{pseudo_url}");background-size:20px 20px}}
"#
);
page_vm.vm_mut().eval(&format!(
- "document.head.innerHTML='<style id=fixture></style>';document.getElementById('fixture').textContent={};document.body.innerHTML='<div id=raster class=case></div><div id=vector class=case></div><div id=masked class=case></div><div id=inline-line><span id=inline-vector>X</span></div>';'installed'",
+ "document.head.innerHTML='<style id=fixture></style>';document.getElementById('fixture').textContent={};document.body.innerHTML='<div id=raster class=case></div><div id=vector class=case></div><div id=masked class=case></div><div id=inline-line><span id=inline-vector>X</span></div><div id=pseudo></div>';'installed'",
serde_json::to_string(&css)?,
))?;
page_vm.vm_mut().sync_live_document_style_sources();
@@ -2282,7 +2341,6 @@ html,body{{margin:0;padding:0;background:white}}
// The first paint demand discovers computed CSSOM URLs and queues
// the bounded decoders. CSS images have no DOM load-event task; a
// later screencast/screenshot samples immutable ready resources.
- let discoveries_before = page_vm.vm().css_image_discovery_count_for_test();
let passes_before = page_vm.vm().layout_pass_observability_for_test().1;
page_vm
.vm_mut()
@@ -2291,11 +2349,9 @@ html,body{{margin:0;padding:0;background:white}}
moli_layout::LayoutFlushReason::Screencast,
)?
.expect("CSS image fixture must retain a layout root");
- let discoveries_after_first = page_vm.vm().css_image_discovery_count_for_test();
- assert_eq!(discoveries_after_first, discoveries_before + 1);
let passes_after_first = page_vm.vm().layout_pass_observability_for_test().1;
assert_eq!(passes_after_first, passes_before + 1);
- let urls = [&raster_url, &vector_url, &mask_url];
+ let urls = [&raster_url, &vector_url, &mask_url, &pseudo_url];
let completion_notify = page_vm.vm().css_image_completion_notify_for_test();
let all_ready = tokio::time::timeout(std::time::Duration::from_secs(3), async {
loop {
@@ -2333,13 +2389,8 @@ html,body{{margin:0;padding:0;background:white}}
passes_after_first + 1,
"each explicit paint demand must still execute a fresh layout",
);
- assert_eq!(
- page_vm.vm().css_image_discovery_count_for_test(),
- discoveries_after_first,
- "resource completion and an unchanged paint must reuse CSS image discovery",
- );
assert_eq!(snapshot.images.len(), 1);
- assert_eq!(snapshot.svg_images.len(), 3);
+ assert_eq!(snapshot.svg_images.len(), 4);
assert!(snapshot.fragments.iter().any(|fragment| {
matches!(fragment, moli_layout::PaintFragment::Image(_))
}));
@@ -2359,10 +2410,13 @@ html,body{{margin:0;padding:0;background:white}}
&image.rgba[index..index + 4]
};
assert_eq!(pixel(5, 5), [255, 0, 0, 255]);
+ assert_eq!(pixel(55, 5), [0, 128, 0, 255]);
page_vm
.vm_mut()
.eval("document.getElementById('raster').style.backgroundPosition = '1px 0px'")?;
+ let resources_before_style_only_paint =
+ page_vm.vm().css_image_resource_observability_for_test();
page_vm
.vm_mut()
.paint_layout_snapshot(
@@ -2371,9 +2425,9 @@ html,body{{margin:0;padding:0;background:white}}
)?
.expect("style-mutated CSS image fixture must retain a layout root");
assert_eq!(
- page_vm.vm().css_image_discovery_count_for_test(),
- discoveries_after_first + 1,
- "a style mutation must invalidate CSS image discovery",
+ page_vm.vm().css_image_resource_observability_for_test(),
+ resources_before_style_only_paint,
+ "layout-local discovery must deduplicate already admitted Document/URL resources",
);
assert_eq!(pixel(35, 5), [255, 0, 0, 255]);
assert_eq!(pixel(5, 15), [255, 255, 255, 255]);
diff --git a/moli-renderer-v8/src/runtime/tests.rs b/moli-renderer-v8/src/runtime/tests.rs
index 9d21e8bb1..f058a17bb 100644
--- a/moli-renderer-v8/src/runtime/tests.rs
+++ b/moli-renderer-v8/src/runtime/tests.rs
@@ -578,13 +578,11 @@ async fn screenshot_and_screencast_paint_downloaded_svg_vectors() {
[0, 255, 0, 255]
);
- let screencast = capture_screenshot_with_request(
+ let screencast = capture_screencast_frame_with_request(
&page,
- super::RendererCaptureScreenshotRequest {
- purpose: super::RendererScreenshotPurpose::Screencast,
+ super::RendererCaptureScreencastFrameRequest {
format: super::RendererScreenshotFormat::Png,
quality: 100,
- region: super::RendererScreenshotRegion::Viewport,
optimize_for_speed: true,
max_width: None,
max_height: None,
@@ -592,9 +590,12 @@ async fn screenshot_and_screencast_paint_downloaded_svg_vectors() {
},
)
.await;
- assert_eq!(decoded_png_pixel(&screencast.bytes, 2, 5), [255, 0, 0, 255]);
assert_eq!(
- decoded_png_pixel(&screencast.bytes, 17, 5),
+ decoded_png_pixel(&screencast.image.bytes, 2, 5),
+ [255, 0, 0, 255]
+ );
+ assert_eq!(
+ decoded_png_pixel(&screencast.image.bytes, 17, 5),
[0, 255, 0, 255]
);
}
@@ -695,7 +696,6 @@ async fn capture_screenshot_encodes_jpeg_and_limits_device_dimensions() {
optimize_for_speed: false,
max_width: Some(5),
max_height: Some(4),
- known_visual_state: None,
};
let (reply, _) = page
.run_async_command(RendererPageCommand::CaptureScreenshot(request))
@@ -764,7 +764,6 @@ async fn print_capture_uses_print_media_controls_backgrounds_and_restores_screen
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
},
)
.await;
@@ -783,7 +782,6 @@ async fn print_capture_uses_print_media_controls_backgrounds_and_restores_screen
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
},
)
.await;
@@ -846,7 +844,6 @@ async fn capture_screenshot_clip_and_full_document_keep_the_live_layout_viewport
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
},
)
.await;
@@ -870,7 +867,6 @@ async fn capture_screenshot_clip_and_full_document_keep_the_live_layout_viewport
optimize_for_speed: true,
max_width: None,
max_height: None,
- known_visual_state: None,
},
)
.await;
@@ -929,7 +925,6 @@ async fn bounded_viewport_clip_keeps_root_controls_while_page_clip_omits_them()
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
},
)
.await;
@@ -959,7 +954,6 @@ async fn bounded_viewport_clip_keeps_root_controls_while_page_clip_omits_them()
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
},
)
.await;
@@ -991,7 +985,6 @@ async fn capture_screenshot_rejects_full_document_at_the_128k_css_boundary() {
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
};
let error = match page
@@ -1162,6 +1155,22 @@ async fn capture_screenshot_with_request(
}
}
+async fn capture_screencast_frame_with_request(
+ page: &RendererPageHandle,
+ request: super::RendererCaptureScreencastFrameRequest,
+) -> super::RendererCapturedScreencastFrame {
+ let (reply, _) = page
+ .run_async_command(RendererPageCommand::CaptureScreencastFrame(request))
+ .await
+ .expect("renderer page should capture a screencast frame");
+ match reply {
+ RendererPageReply::CaptureScreencastFrame(
+ super::RendererCaptureScreencastFrameReply::Captured(frame),
+ ) => frame,
+ _ => panic!("expected captured screencast frame reply"),
+ }
+}
+
fn decoded_png_pixel(bytes: &[u8], x: u32, y: u32) -> [u8; 4] {
let decoder = png::Decoder::new(Cursor::new(bytes));
let mut reader = decoder.read_info().expect("valid PNG header");
@@ -12726,13 +12735,11 @@ addEventListener("wheel", event => {
.await
.handled
);
- let screencast = capture_screenshot_with_request(
+ let screencast = capture_screencast_frame_with_request(
&page,
- super::RendererCaptureScreenshotRequest {
- purpose: super::RendererScreenshotPurpose::Screencast,
+ super::RendererCaptureScreencastFrameRequest {
format: super::RendererScreenshotFormat::Png,
quality: 100,
- region: super::RendererScreenshotRegion::Viewport,
optimize_for_speed: true,
max_width: None,
max_height: None,
@@ -12741,7 +12748,7 @@ addEventListener("wheel", event => {
)
.await;
assert_eq!(
- decoded_png_pixel(&screencast.bytes, 10, 10),
+ decoded_png_pixel(&screencast.image.bytes, 10, 10),
[0, 255, 0, 255]
);
diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs
index 2b227d7c3..7b344d615 100644
--- a/moli-renderer-v8/src/script_vm.rs
+++ b/moli-renderer-v8/src/script_vm.rs
@@ -2460,6 +2460,15 @@ impl ScriptVm {
.visual_state_token(document, viewport)
}
+ #[cfg(test)]
+ pub(crate) fn visual_resource_generation_handle_for_test(
+ &self,
+ ) -> crate::native_bridge::visual_resource_generation::VisualResourceGeneration {
+ self._context_host
+ .borrow()
+ .visual_resource_generation_handle_for_test()
+ }
+
fn with_fresh_layout_pass<T>(
&mut self,
request: moli_layout::LayoutPassRequest,
@@ -2467,19 +2476,33 @@ impl ScriptVm {
&mut moli_layout::LayoutPassResult<DomHandle>,
) -> Result<T, moli_layout::LayoutError>,
) -> Result<Option<T>, moli_layout::LayoutError> {
- // Font/CSS source reconciliation is a pre-pass lifecycle step. Once
- // the guard is entered, layout performs no JS, event-loop, observer,
- // or resource completion work and owns no state beyond this call.
+ // Font-source reconciliation is a pre-pass lifecycle step. CSS image
+ // URLs come back from the actual box-construction traversal below.
+ // Once the guard is entered, layout performs no JS, event-loop,
+ // observer, or resource completion work and owns no state beyond this
+ // call.
self.reconcile_document_web_fonts_for_layout();
- let discovered_css_images =
- request.requests_paint() && self.reconcile_document_css_images_for_paint();
+ let requests_paint = request.requests_paint();
let (document, result) = {
let context_host = self._context_host.borrow();
let document = context_host.document_handle();
let result =
- context_host.with_fresh_layout_pass_for_document(document, request, consume);
+ context_host.with_fresh_layout_pass_for_document(document, request, |pass| {
+ let css_images = if requests_paint {
+ pass.css_image_references().to_vec()
+ } else {
+ Vec::new()
+ };
+ consume(pass).map(|value| (value, css_images))
+ });
(document, result)
};
+ let (result, css_images) = match result {
+ Ok(Some((value, css_images))) => (Ok(Some(value)), css_images),
+ Ok(None) => (Ok(None), Vec::new()),
+ Err(error) => (Err(error), Vec::new()),
+ };
+ self.start_css_images_discovered_by_layout(css_images);
if matches!(&result, Ok(Some(_)))
&& let Err(error) = self.with_default_context_scope(|scope, runtime_ptr| {
crate::native_bridge::element::queue_revealed_lazy_image_loads(
@@ -2496,11 +2519,6 @@ impl ScriptVm {
// sampled geometry.
tracing::warn!(?error, "failed to admit lazy images after layout refresh");
}
- if discovered_css_images {
- self._context_host
- .borrow_mut()
- .publish_css_image_discovery_for_paint();
- }
result
}
@@ -2534,13 +2552,6 @@ impl ScriptVm {
.css_image_resource_observability_for_test()
}
- #[cfg(test)]
- pub(crate) fn css_image_discovery_count_for_test(&self) -> u64 {
- self._context_host
- .borrow()
- .css_image_discovery_count_for_test()
- }
-
#[cfg(test)]
pub(crate) fn css_image_completion_notify_for_test(
&self,
@@ -2620,7 +2631,13 @@ impl ScriptVm {
self.start_stylesheet_subresource_fetches(bound);
}
- fn reconcile_document_css_images_for_paint(&mut self) -> bool {
+ fn start_css_images_discovered_by_layout(
+ &mut self,
+ references: Vec<moli_layout::LayoutCssImageReference<DomHandle>>,
+ ) {
+ if references.is_empty() {
+ return;
+ }
let image_fetch_enabled = self
.document_runtime
.current_document_resource_loader()
@@ -2629,47 +2646,35 @@ impl ScriptVm {
.request_client()
.optional_resource_fetch_enabled(crate::types::SubresourceResourceType::Image)
});
- if !image_fetch_enabled
- || !self
- ._context_host
- .borrow()
- .layout_policy()
- .uses_real_layout()
- {
- return false;
- }
- let resources = {
- let host = self._context_host.borrow();
- if !host.css_image_discovery_needed_for_paint() {
- return false;
- }
- host.active_layout_document_handles()
- .into_iter()
- .filter_map(|document| {
- host.dom_host()
- .dom()
- .document_element_handle_for_document(document)
- })
- .flat_map(|root| {
- crate::layout_renderer::current_native_css_image_resources(&host, root)
- })
- .collect::<Vec<_>>()
- };
- if resources.is_empty() {
- return true;
+ if !image_fetch_enabled {
+ return;
}
+ let mut seen = std::collections::HashSet::new();
let bound = {
let mut host = self._context_host.borrow_mut();
- resources
+ references
.into_iter()
- .filter_map(|resource| {
- host.accept_current_main_stylesheet_subresource_load_delay()
- .map(|binding| (binding, resource))
+ .filter_map(|reference| {
+ let document = host.layout_document_for_source(reference.source)?;
+ if !seen.insert((document, reference.resolved_url.clone())) {
+ return None;
+ }
+ if host.stylesheet_css_image_is_current(document, &reference.resolved_url) {
+ return None;
+ }
+ let request_url = url::Url::parse(&reference.resolved_url).ok()?;
+ let binding = host
+ .accept_current_stylesheet_subresource_load_delay_for_document(document)?;
+ Some((
+ binding,
+ crate::css_resource_urls::StylesheetLoadBlockingResource::image(
+ request_url,
+ ),
+ ))
})
.collect::<Vec<_>>()
};
self.start_stylesheet_subresource_fetches(bound);
- true
}
pub(crate) fn observable_geometry_batch_for_current_document(
diff --git a/moli/src/fetch_dump.rs b/moli/src/fetch_dump.rs
index 12f1c578b..afd443bac 100644
--- a/moli/src/fetch_dump.rs
+++ b/moli/src/fetch_dump.rs
@@ -178,7 +178,6 @@ async fn render_pdf_dump_async(page: &mut Page) -> Result<Vec<u8>> {
optimize_for_speed: false,
max_width: None,
max_height: None,
- known_visual_state: None,
},
"pdf",
)
@@ -218,9 +217,6 @@ async fn capture_page_raster(
RendererCaptureScreenshotReply::NoDocument => {
bail!("--dump {dump_mode} requires a loaded HTML document")
}
- RendererCaptureScreenshotReply::ScreencastUnchanged => {
- bail!("--dump {dump_mode} returned an invalid screencast-only reply")
- }
}
}