From 42db7643ebacfa239940b530480fbedee9288df0 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Fri, 17 Jul 2026 20:18:29 +0800 Subject: [PATCH] fix(images): track current request transitions --- .../wpt-cross-current/failed-cases.txt | 2 - .../wpt-cross-current/passed-cases.txt | 2 + .../src/native_bridge/context_host/core.rs | 21 +- .../context_host/image_decodes.rs | 8 +- .../native_bridge/context_host/image_loads.rs | 118 ++++-- .../context_host/image_resources/mod.rs | 85 ++-- .../context_host/image_resources/preload.rs | 2 +- .../context_host/image_resources/state.rs | 46 ++- .../src/native_bridge/context_host/mod.rs | 29 +- .../src/native_bridge/element/images/src.rs | 268 +++++++----- moli-renderer-v8/src/network_host/image.rs | 8 +- .../runtime/page_vm/tests/image_load_event.rs | 26 +- .../extracted/inserted_resource_lifecycle.rs | 380 +++++++++--------- .../src/script_vm/tests/browser_api/images.rs | 259 +++++++++++- .../src/script_vm/tests/canvas_webgl.rs | 49 ++- .../extracted/child_document_lifecycle.rs | 2 +- 16 files changed, 901 insertions(+), 404 deletions(-) diff --git a/moli-benchmark/wpt-cross-current/failed-cases.txt b/moli-benchmark/wpt-cross-current/failed-cases.txt index da96f4605c0..be56e5d2172 100644 --- a/moli-benchmark/wpt-cross-current/failed-cases.txt +++ b/moli-benchmark/wpt-cross-current/failed-cases.txt @@ -2854,7 +2854,6 @@ html/semantics/embedded-content/the-img-element/image-loading-lazy-in-scroller-n html/semantics/embedded-content/the-img-element/image-loading-lazy-in-scroller.html html/semantics/embedded-content/the-img-element/image-loading-lazy-in-viewport-dynamic.html html/semantics/embedded-content/the-img-element/image-loading-lazy-move-document.html -html/semantics/embedded-content/the-img-element/img-picture-ancestor.html html/semantics/embedded-content/the-img-element/natural-size-orientation.html html/semantics/embedded-content/the-img-element/naturalWidth-naturalHeight-width-height.html html/semantics/embedded-content/the-img-element/relevant-mutations-lazy.html @@ -2866,7 +2865,6 @@ html/semantics/embedded-content/the-img-element/source-media-outside-doc.html html/semantics/embedded-content/the-img-element/source-relevant-mutations.html html/semantics/embedded-content/the-img-element/svg-img-density-vs-zoom.html html/semantics/embedded-content/the-img-element/update-the-image-data/current-request-microtask-002.html -html/semantics/embedded-content/the-img-element/update-the-image-data/current-request-microtask.html html/semantics/embedded-content/the-img-element/update-the-image-data/lazy-out-of-band-load.html html/semantics/embedded-content/the-img-element/update-the-image-data/not-broken-while-load-task-scheduled.html html/semantics/embedded-content/the-img-element/update-the-image-data/src-then-lazy-load.html diff --git a/moli-benchmark/wpt-cross-current/passed-cases.txt b/moli-benchmark/wpt-cross-current/passed-cases.txt index d3ff93e1783..226bb8acb22 100644 --- a/moli-benchmark/wpt-cross-current/passed-cases.txt +++ b/moli-benchmark/wpt-cross-current/passed-cases.txt @@ -6895,6 +6895,7 @@ html/semantics/embedded-content/the-img-element/image-loading-lazy-subframe-deta html/semantics/embedded-content/the-img-element/image-loading-lazy-to-eager.html html/semantics/embedded-content/the-img-element/image-loading-lazy-use-list-of-available-images.html html/semantics/embedded-content/the-img-element/img-created-in-active-document-crash.html +html/semantics/embedded-content/the-img-element/img-picture-ancestor.html html/semantics/embedded-content/the-img-element/img-src-in-synthetic-document.html html/semantics/embedded-content/the-img-element/img.complete.html html/semantics/embedded-content/the-img-element/invalid-src.html @@ -6915,6 +6916,7 @@ html/semantics/embedded-content/the-img-element/srcset/select-an-image-source.ht html/semantics/embedded-content/the-img-element/srcset/srcset-media-dynamic.html html/semantics/embedded-content/the-img-element/update-media.html html/semantics/embedded-content/the-img-element/update-src-complete.html +html/semantics/embedded-content/the-img-element/update-the-image-data/current-request-microtask.html html/semantics/embedded-content/the-img-element/update-the-image-data/fail-to-resolve.html html/semantics/embedded-content/the-object-element/block-object-with-ruby-crash.html html/semantics/embedded-content/the-object-element/document-getters-return-null-for-cross-origin.html 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 f598b7d4ef9..cc21084a75a 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -486,6 +486,7 @@ impl PageScriptHost { super::user_interaction_tasks::UserInteractionTaskState::default(), pending_image_load_events: HashMap::new(), next_image_load_event_id: 1, + current_image_requests: HashMap::new(), pending_media_load_sequences: HashMap::new(), next_media_load_sequence_id: 1, pending_text_track_load_sequences: HashMap::new(), @@ -1689,7 +1690,7 @@ impl PageScriptHost { &self, handle: DomHandle, ) -> Option { - self.pending_image_load_events.get(&handle).copied() + self.pending_image_load_events.get(&handle).cloned() } pub(crate) fn next_image_load_event_id(&mut self) -> super::ImageLoadEventId { @@ -1832,6 +1833,24 @@ impl PageScriptHost { self.lazy_media_load_candidates.iter().copied().collect() } + pub(crate) fn set_current_image_request( + &mut self, + handle: DomHandle, + request_key: Option, + ) { + if let Some(request_key) = request_key { + self.current_image_requests.insert(handle, request_key); + } else { + self.current_image_requests.remove(&handle); + } + } + + pub(crate) fn current_image_request_url(&self, handle: DomHandle) -> Option<&str> { + self.current_image_requests + .get(&handle) + .map(crate::types::ImageRequestKey::url) + } + pub(crate) fn begin_form_data_construction(&mut self, form_handle: DomHandle) -> bool { if self.constructing_form_data_forms.contains(&form_handle) { return false; diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_decodes.rs b/moli-renderer-v8/src/native_bridge/context_host/image_decodes.rs index fcadaca0d0c..9522a5b8c4b 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_decodes.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_decodes.rs @@ -106,7 +106,8 @@ impl PageScriptHost { .pending_image_load_events .get(&request.element) .is_some_and(|pending| { - self.pending_image_load_event_is_current(request.element, *pending) + self.pending_image_load_event_is_current(request.element, pending) + && pending.request_key() == Some(&request.request_key) && !matches!( pending.network_state, PendingImageLoadNetworkState::Failed(_) @@ -352,5 +353,8 @@ fn image_source_can_decode(runtime: &PageScriptHost, handle: DomHandle, source: { return false; } - runtime.image_resource_is_ready(handle) && image_intrinsic_dimensions(runtime, handle).is_some() + (runtime.image_resource_is_ready(handle) + && image_intrinsic_dimensions(runtime, handle).is_some()) + || image_selected_request_key(runtime, handle) + .is_some_and(|request_key| runtime.has_ready_image_request(&request_key)) } diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_loads.rs b/moli-renderer-v8/src/native_bridge/context_host/image_loads.rs index 62a4d8c6093..5792aac9b64 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_loads.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_loads.rs @@ -97,11 +97,10 @@ impl PageScriptHost { request_initiator_type, resource_timing_initiator_type, ); - if !self.insert_pending_image_load_event(image_handle, pending) { + if !self.insert_pending_image_load_event(image_handle, pending.clone()) { let _ = self.settle_pending_image_load_event(pending, true); return None; } - self.begin_pending_image_resource(image_handle, pending); match pending.owner() { PendingImageLoadEventOwner::Main(binding) => tracing::debug!( image = image_handle.index(), @@ -125,7 +124,7 @@ impl PageScriptHost { pub(crate) fn pending_image_load_event_is_current( &self, image_handle: DomHandle, - pending: PendingImageLoadEvent, + pending: &PendingImageLoadEvent, ) -> bool { if self.dom_host().owner_document_handle(image_handle) != Some(pending.owner_document_handle()) @@ -145,6 +144,34 @@ impl PageScriptHost { } } + pub(crate) fn prepare_pending_image_load_request_if_matches( + &mut self, + image_handle: DomHandle, + id: ImageLoadEventId, + request_key: crate::types::ImageRequestKey, + ) -> bool { + let pending = { + let Some(pending) = self.pending_image_load_events.get_mut(&image_handle) else { + return false; + }; + if pending.id != id + || pending.request_key.is_some() + || pending.network_state != PendingImageLoadNetworkState::Unbound + { + return false; + } + pending.request_key = Some(request_key); + pending.clone() + }; + self.begin_pending_image_resource(image_handle, &pending); + tracing::debug!( + image = image_handle.index(), + sequence = id.get(), + "selected image request identity" + ); + true + } + pub(crate) fn bind_pending_image_load_network_request_if_matches( &mut self, image_handle: DomHandle, @@ -154,7 +181,10 @@ impl PageScriptHost { let Some(pending) = self.pending_image_load_events.get_mut(&image_handle) else { return false; }; - if pending.id != id || pending.network_state != PendingImageLoadNetworkState::Unbound { + if pending.id != id + || pending.request_key.is_none() + || pending.network_state != PendingImageLoadNetworkState::Unbound + { return false; } pending.network_state = PendingImageLoadNetworkState::Pending(internal_id); @@ -173,24 +203,32 @@ impl PageScriptHost { id: ImageLoadEventId, successful: bool, ) -> Option { - let pending = self.pending_image_load_events.get_mut(&image_handle)?; - if pending.id != id || pending.network_state != PendingImageLoadNetworkState::Unbound { - return None; - } + self.pending_image_load_events + .get(&image_handle) + .filter(|pending| { + pending.id == id && pending.network_state == PendingImageLoadNetworkState::Unbound + })?; let _ = self.retire_image_resource_for_element(image_handle); - let pending = self.pending_image_load_events.get_mut(&image_handle)?; - pending.network_state = if successful { - PendingImageLoadNetworkState::Ready(PendingImageLoadTerminalSource::Local) - } else { - PendingImageLoadNetworkState::Failed(PendingImageLoadTerminalSource::Local) + let (followup, current_request) = { + let pending = self.pending_image_load_events.get_mut(&image_handle)?; + pending.network_state = if successful { + PendingImageLoadNetworkState::Ready(PendingImageLoadTerminalSource::Local) + } else { + PendingImageLoadNetworkState::Failed(PendingImageLoadTerminalSource::Local) + }; + ( + pending_image_load_terminal_followup(pending), + pending.request_key.clone(), + ) }; + self.set_current_image_request(image_handle, current_request); tracing::debug!( image = image_handle.index(), sequence = id.get(), successful, "completed local or policy image resource" ); - pending_image_load_terminal_followup(pending) + followup } pub(crate) fn complete_pending_image_load_reused_resource_if_matches( @@ -201,18 +239,25 @@ impl PageScriptHost { if !self.image_resource_is_ready(image_handle) { return None; } - let pending = self.pending_image_load_events.get_mut(&image_handle)?; - if pending.id != id || pending.network_state != PendingImageLoadNetworkState::Unbound { - return None; - } - pending.network_state = - PendingImageLoadNetworkState::Ready(PendingImageLoadTerminalSource::Reused); + let (followup, current_request) = { + let pending = self.pending_image_load_events.get_mut(&image_handle)?; + if pending.id != id || pending.network_state != PendingImageLoadNetworkState::Unbound { + return None; + } + pending.network_state = + PendingImageLoadNetworkState::Ready(PendingImageLoadTerminalSource::Reused); + ( + pending_image_load_terminal_followup(pending), + pending.request_key.clone(), + ) + }; + self.set_current_image_request(image_handle, current_request); tracing::debug!( image = image_handle.index(), sequence = id.get(), "reused active decoded image resource without another fetch or decode" ); - pending_image_load_terminal_followup(pending) + followup } pub(crate) fn complete_pending_image_load_network_request_if_matches( @@ -222,9 +267,13 @@ impl PageScriptHost { internal_id: u64, successful: bool, ) -> Option { - let pending = self.pending_image_load_events.get_mut(&image_handle)?; - if pending.id != id - || pending.network_state != PendingImageLoadNetworkState::Pending(internal_id) + if !self + .pending_image_load_events + .get(&image_handle) + .is_some_and(|pending| { + pending.id == id + && pending.network_state == PendingImageLoadNetworkState::Pending(internal_id) + }) { tracing::debug!( image = image_handle.index(), @@ -236,12 +285,19 @@ impl PageScriptHost { return None; } let _ = self.retire_image_resource_for_element(image_handle); - let pending = self.pending_image_load_events.get_mut(&image_handle)?; - pending.network_state = if successful { - PendingImageLoadNetworkState::Ready(PendingImageLoadTerminalSource::Network) - } else { - PendingImageLoadNetworkState::Failed(PendingImageLoadTerminalSource::Network) + let (followup, current_request) = { + let pending = self.pending_image_load_events.get_mut(&image_handle)?; + pending.network_state = if successful { + PendingImageLoadNetworkState::Ready(PendingImageLoadTerminalSource::Network) + } else { + PendingImageLoadNetworkState::Failed(PendingImageLoadTerminalSource::Network) + }; + ( + pending_image_load_terminal_followup(pending), + pending.request_key.clone(), + ) }; + self.set_current_image_request(image_handle, current_request); tracing::debug!( image = image_handle.index(), sequence = id.get(), @@ -249,7 +305,7 @@ impl PageScriptHost { successful, "applied image network terminal to lifecycle sequence" ); - pending_image_load_terminal_followup(pending) + followup } pub(crate) fn pending_image_load_terminal_followup_if_ready( @@ -271,7 +327,7 @@ impl PageScriptHost { let pending = self .pending_image_load_event(task_id.element()) .filter(|pending| pending.id() == task_id.sequence())?; - if !self.pending_image_load_event_is_current(task_id.element(), pending) { + if !self.pending_image_load_event_is_current(task_id.element(), &pending) { return None; } let kind = pending 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 786b085e003..b5c9d74947c 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 @@ -90,7 +90,7 @@ impl ImageResponseCompletion { } impl super::PendingImageLoadEvent { - fn document_task_owner(self) -> FrameDocumentTaskOwner { + fn document_task_owner(&self) -> FrameDocumentTaskOwner { match self.owner() { super::PendingImageLoadEventOwner::Main(binding) => binding.owner(), super::PendingImageLoadEventOwner::Child(binding) => binding.owner(), @@ -114,21 +114,26 @@ impl super::PageScriptHost { pub(super) fn begin_pending_image_resource( &mut self, element: DomHandle, - pending: super::PendingImageLoadEvent, + pending: &super::PendingImageLoadEvent, ) { - let Some(request_key) = - crate::native_bridge::element::image_selected_request_key(self, element) - else { + let Some(request_key) = pending.request_key().cloned() else { self.image_resources.retire_element(element); return; }; - self.image_resources.begin(ImageResourceRequestIdentity { - element, - sequence: pending.id(), - document_handle: pending.owner_document_handle(), - document_owner: pending.document_task_owner(), - request_key, - }); + let retain_current = self.dom_host().is_html_element_named(element, "img"); + let retained_current = self.image_resources.begin( + ImageResourceRequestIdentity { + element, + sequence: pending.id(), + document_handle: pending.owner_document_handle(), + document_owner: pending.document_task_owner(), + request_key: request_key.clone(), + }, + retain_current, + ); + if !retained_current { + self.set_current_image_request(element, Some(request_key)); + } } pub(crate) fn retire_image_resource_for_element(&mut self, element: DomHandle) -> bool { @@ -330,14 +335,16 @@ impl super::PageScriptHost { descriptor: Option, encoded: ParkableImage, ) -> ImageResponseCompletion { - self.complete_pending_image_response_if_matches( + let completion = self.complete_pending_image_response_if_matches( element, sequence, None, super::PendingImageLoadTerminalSource::Local, descriptor, encoded, - ) + ); + self.update_current_image_request_after_response(element, completion); + completion } pub(crate) fn complete_pending_image_load_network_response_if_matches( @@ -348,14 +355,34 @@ impl super::PageScriptHost { descriptor: Option, encoded: ParkableImage, ) -> ImageResponseCompletion { - self.complete_pending_image_response_if_matches( + let completion = self.complete_pending_image_response_if_matches( element, sequence, Some(internal_id), super::PendingImageLoadTerminalSource::Network, descriptor, encoded, - ) + ); + self.update_current_image_request_after_response(element, completion); + completion + } + + fn update_current_image_request_after_response( + &mut self, + element: DomHandle, + completion: ImageResponseCompletion, + ) { + if !completion.accepted() { + return; + } + let Some(pending) = self + .pending_image_load_events + .get(&element) + .filter(|pending| pending.terminal_source().is_some()) + else { + return; + }; + self.set_current_image_request(element, pending.request_key().cloned()); } fn complete_pending_image_response_if_matches( @@ -568,18 +595,22 @@ impl super::PageScriptHost { false } }; - let Some(pending) = self.pending_image_load_events.get_mut(&task_id.element()) else { - return false; + let request_key = { + let Some(pending) = self.pending_image_load_events.get_mut(&task_id.element()) else { + return false; + }; + if pending.id != task_id.sequence() { + return false; + } + pending.network_state = if successful { + super::PendingImageLoadNetworkState::Ready(source) + } else { + super::PendingImageLoadNetworkState::Failed(source) + }; + pending.terminal_followup_queued = true; + pending.request_key.clone() }; - if pending.id != task_id.sequence() { - return false; - } - pending.network_state = if successful { - super::PendingImageLoadNetworkState::Ready(source) - } else { - super::PendingImageLoadNetworkState::Failed(source) - }; - pending.terminal_followup_queued = true; + self.set_current_image_request(task_id.element(), request_key); true } } diff --git a/moli-renderer-v8/src/native_bridge/context_host/image_resources/preload.rs b/moli-renderer-v8/src/native_bridge/context_host/image_resources/preload.rs index d2e907a1a71..891436e4b85 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/image_resources/preload.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/image_resources/preload.rs @@ -591,7 +591,7 @@ mod tests { document_owner: owner(1), request_key: key, }; - resources.begin(identity.clone()); + resources.begin(identity.clone(), false); let claimed = resources .claim_scanned_preload(element) .expect("the exact element should claim the decoded preload"); 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 860da13104e..7d908eb5d3c 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 @@ -36,9 +36,19 @@ pub(in crate::native_bridge::context_host) struct ImageResourceStore { struct ImageResourceSlot { identity: ImageResourceRequestIdentity, state: ImageResourceState, + retained_current: Option>, scanned_preload: Option, } +impl ImageResourceSlot { + fn current_ready(&self) -> Option<&Arc> { + match &self.state { + ImageResourceState::Ready(resource) => Some(resource), + _ => self.retained_current.as_ref(), + } + } +} + enum ImageResourceState { Pending, DecodeQueued(ImageResponseDescriptor), @@ -118,17 +128,38 @@ impl ImageResourceStore { } } - pub(super) fn begin(&mut self, identity: ImageResourceRequestIdentity) { + pub(super) fn begin( + &mut self, + identity: ImageResourceRequestIdentity, + retain_current: bool, + ) -> bool { let ready = self.ready_by_request.get(&identity.request_key); + // The latest admission owns transport and decode. An available HTML + // image keeps its current response until the replacement settles. + let retained_current = if retain_current && ready.is_none() { + self.slots + .get(&identity.element) + .filter(|slot| { + slot.identity.document_handle == identity.document_handle + && slot.identity.document_owner == identity.document_owner + }) + .and_then(ImageResourceSlot::current_ready) + .cloned() + } else { + None + }; + let has_retained_current = retained_current.is_some(); self.slots.insert( identity.element, ImageResourceSlot { identity, state: ready.map_or(ImageResourceState::Pending, ImageResourceState::Ready), + retained_current, scanned_preload: None, }, ); self.visual_generation.bump(); + has_retained_current } pub(super) fn identity(&self, element: DomHandle) -> Option<&ImageResourceRequestIdentity> { @@ -219,6 +250,7 @@ impl ImageResourceStore { } ImageResourceState::Pending => { slot.state = ImageResourceState::Ready(resource); + slot.retained_current = None; slot.scanned_preload = None; self.visual_generation.bump(); true @@ -251,6 +283,7 @@ impl ImageResourceStore { self.ready_by_request .insert(identity.request_key.clone(), &resource); slot.state = ImageResourceState::Ready(resource); + slot.retained_current = None; slot.scanned_preload = None; self.visual_generation.bump(); true @@ -264,16 +297,14 @@ impl ImageResourceStore { return false; } slot.state = ImageResourceState::Failed; + slot.retained_current = None; slot.scanned_preload = None; self.visual_generation.bump(); true } pub(super) fn ready_for_layout(&self, element: DomHandle) -> Option { - let slot = self.slots.get(&element)?; - let ImageResourceState::Ready(resource) = &slot.state else { - return None; - }; + let resource = self.slots.get(&element)?.current_ready()?; let (intrinsic_width, intrinsic_height) = intrinsic_dimensions(resource); Some(ReadyImageForLayout { intrinsic_width, @@ -294,10 +325,7 @@ impl ImageResourceStore { } pub(super) fn intrinsic_dimensions(&self, element: DomHandle) -> Option<(f32, f32)> { - let slot = self.slots.get(&element)?; - let ImageResourceState::Ready(resource) = &slot.state else { - return None; - }; + let resource = self.slots.get(&element)?.current_ready()?; Some(intrinsic_dimensions(resource)) } 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 b909f2cb798..ae0d663c1e0 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -721,7 +721,7 @@ pub(crate) enum PendingImageLoadEventOwner { Child(FrameDocumentImageLoadEventBinding), } -#[derive(Clone, Copy, Debug)] +#[derive(Clone, Debug)] pub(crate) struct PendingImageLoadEvent { id: ImageLoadEventId, owner_document_handle: DomHandle, @@ -729,6 +729,7 @@ pub(crate) struct PendingImageLoadEvent { owner: PendingImageLoadEventOwner, request_initiator_type: crate::types::SubresourceRequestInitiatorType, resource_timing_initiator_type: &'static str, + request_key: Option, network_state: PendingImageLoadNetworkState, terminal_followup_queued: bool, } @@ -766,36 +767,41 @@ impl PendingImageLoadEvent { owner, request_initiator_type, resource_timing_initiator_type, + request_key: None, network_state: PendingImageLoadNetworkState::Unbound, terminal_followup_queued: false, } } - pub(crate) fn id(self) -> ImageLoadEventId { + pub(crate) fn id(&self) -> ImageLoadEventId { self.id } - pub(crate) fn owner_document_handle(self) -> DomHandle { + pub(crate) fn owner_document_handle(&self) -> DomHandle { self.owner_document_handle } - pub(crate) fn target(self) -> WindowDocumentTaskTarget { + pub(crate) fn target(&self) -> WindowDocumentTaskTarget { self.target } - pub(crate) fn owner(self) -> PendingImageLoadEventOwner { + pub(crate) fn owner(&self) -> PendingImageLoadEventOwner { self.owner } - pub(crate) fn request_initiator_type(self) -> crate::types::SubresourceRequestInitiatorType { + pub(crate) fn request_initiator_type(&self) -> crate::types::SubresourceRequestInitiatorType { self.request_initiator_type } - pub(crate) fn resource_timing_initiator_type(self) -> &'static str { + pub(crate) fn resource_timing_initiator_type(&self) -> &'static str { self.resource_timing_initiator_type } - pub(crate) fn network_request_id(self) -> Option { + pub(crate) fn request_key(&self) -> Option<&ImageRequestKey> { + self.request_key.as_ref() + } + + pub(crate) fn network_request_id(&self) -> Option { match self.network_state { PendingImageLoadNetworkState::Pending(internal_id) => Some(internal_id), PendingImageLoadNetworkState::Unbound @@ -805,7 +811,7 @@ impl PendingImageLoadEvent { } } - pub(crate) fn terminal_source(self) -> Option { + pub(crate) fn terminal_source(&self) -> Option { match self.network_state { PendingImageLoadNetworkState::Ready(source) | PendingImageLoadNetworkState::Failed(source) => Some(source), @@ -816,7 +822,7 @@ impl PendingImageLoadEvent { } pub(crate) fn terminal_followup( - self, + &self, ) -> Option { if !self.terminal_followup_queued { return None; @@ -973,6 +979,9 @@ pub(crate) struct PageScriptHost { user_interaction_tasks: user_interaction_tasks::UserInteractionTaskState, pending_image_load_events: HashMap, next_image_load_event_id: u64, + // Source selection can change before its pending request becomes available or broken. Keep + // the request exposed by currentSrc separate from the element's mutable source attributes. + current_image_requests: HashMap, pending_media_load_sequences: HashMap, next_media_load_sequence_id: u64, pending_text_track_load_sequences: HashMap, diff --git a/moli-renderer-v8/src/native_bridge/element/images/src.rs b/moli-renderer-v8/src/native_bridge/element/images/src.rs index 79a9cc3c3d1..c7b34590924 100644 --- a/moli-renderer-v8/src/native_bridge/element/images/src.rs +++ b/moli-renderer-v8/src/native_bridge/element/images/src.rs @@ -6,7 +6,7 @@ use crate::page_task_queue::{ RendererPageImageLoadEventTaskId, }; use crate::types::{ImageRequestCorsMode, ImageRequestKey, SubresourceRequestInitiatorType}; -use crate::util::v8_string; +use crate::util::{context_host_ptr_from_global_bridge, v8_string}; use moli_browser_profile::DEFAULT_WINDOW_SURFACE_PROFILE; use crate::style_engine::media_list::evaluate_media_query_list; @@ -16,11 +16,15 @@ use super::super::geometry::compute_mock_client_rect; use super::super::{construct_simple_event, dispatch_public_event, resolve_url_like_attribute}; use super::lazy::{image_load_is_deferred, revealed_lazy_image_handles}; -#[derive(Clone, Copy)] +const IMAGE_UPDATE_HANDLE_INDEX: u32 = 0; +const IMAGE_UPDATE_ID_INDEX: u32 = 1; +const IMAGE_UPDATE_TRIGGER_INDEX: u32 = 2; + +#[derive(Clone, Copy, Eq, PartialEq)] +#[repr(u32)] enum ImageLoadQueueTrigger { SourceOrInsertion, LazyReveal, - DocumentAdoption, } pub(crate) fn queue_image_load_event_if_needed( @@ -46,7 +50,7 @@ pub(crate) fn queue_image_load_event_after_document_adoption( scope, runtime_ptr, handle, - ImageLoadQueueTrigger::DocumentAdoption, + ImageLoadQueueTrigger::SourceOrInsertion, SubresourceRequestInitiatorType::Other, ); } @@ -99,7 +103,7 @@ pub(crate) fn queue_image_load_event_for_loading_change( scope, runtime_ptr, handle, - ImageLoadQueueTrigger::SourceOrInsertion, + ImageLoadQueueTrigger::LazyReveal, SubresourceRequestInitiatorType::Script, ); } @@ -116,15 +120,9 @@ fn queue_image_load_event( if image_load_is_deferred(runtime, handle) && !allow_deferred_lazy { return; } - if image_load_is_suppressed_for_non_active_parent(runtime, handle) - && !matches!(trigger, ImageLoadQueueTrigger::DocumentAdoption) + if image_selected_source(runtime, handle).is_none() + && !connected_empty_src_without_srcset(runtime, handle) { - return; - } - let selected_source = image_selected_source_url(runtime, handle); - let invalid_empty_source = - selected_source.is_empty() && connected_empty_src_without_srcset(runtime, handle); - if selected_source.is_empty() && !invalid_empty_source { let _ = runtime.cancel_pending_image_load_event(handle); let _ = runtime.process_image_decode_requests_for_element(scope, handle); return; @@ -149,7 +147,7 @@ fn queue_image_load_event( if let Some(pending) = runtime .pending_image_load_event(handle) .or(pending_before_registration) - .filter(|pending| runtime.pending_image_load_event_is_current(handle, *pending)) + .filter(|pending| runtime.pending_image_load_event_is_current(handle, pending)) { let followup = runtime.pending_image_load_terminal_followup_if_ready(handle, pending.id()); @@ -163,11 +161,91 @@ fn queue_image_load_event( let _ = runtime.process_image_decode_requests_for_element(scope, handle); return; }; - let request_url = if invalid_empty_source { - Err("an empty image source cannot be fetched".to_owned()) - } else { - url::Url::parse(&selected_source).map_err(|error| error.to_string()) + queue_image_update_microtask(scope, runtime_ptr, handle, pending.id(), trigger); +} + +fn queue_image_update_microtask( + scope: &mut v8::PinScope<'_, '_>, + runtime_ptr: *mut PageScriptHost, + handle: DomHandle, + sequence: ImageLoadEventId, + trigger: ImageLoadQueueTrigger, +) { + let data = v8::Array::new(scope, 3); + let _ = data.set_index( + scope, + IMAGE_UPDATE_HANDLE_INDEX, + v8::BigInt::new_from_u64(scope, handle.index() as u64).into(), + ); + let _ = data.set_index( + scope, + IMAGE_UPDATE_ID_INDEX, + v8::BigInt::new_from_u64(scope, sequence.get()).into(), + ); + let _ = data.set_index( + scope, + IMAGE_UPDATE_TRIGGER_INDEX, + v8::Integer::new_from_unsigned(scope, trigger as u32).into(), + ); + let Some(callback) = v8::Function::builder(queued_image_update_microtask_callback) + .data(data.into()) + .build(scope) + else { + let _ = unsafe { &mut *runtime_ptr } + .cancel_pending_image_load_event_if_matches(handle, sequence); + return; }; + scope.enqueue_microtask(callback); +} + +fn queued_image_update_microtask_callback<'s>( + scope: &mut v8::PinScope<'s, '_>, + args: v8::FunctionCallbackArguments<'s>, + _rv: v8::ReturnValue<'_, v8::Value>, +) { + let Some(runtime_ptr) = context_host_ptr_from_global_bridge(scope) else { + return; + }; + let Some((handle, sequence, trigger)) = + image_update_target_from_callback_data(scope, args.data()) + else { + return; + }; + let runtime = unsafe { &mut *runtime_ptr }; + let Some(pending) = runtime + .pending_image_load_event(handle) + .filter(|pending| pending.id() == sequence) + else { + return; + }; + if !runtime.pending_image_load_event_is_current(handle, &pending) { + let _ = runtime.cancel_pending_image_load_event_if_matches(handle, sequence); + return; + } + if pending.request_key().is_some() { + return; + } + if image_load_is_deferred(runtime, handle) && trigger != ImageLoadQueueTrigger::LazyReveal { + let _ = runtime.cancel_pending_image_load_event_if_matches(handle, sequence); + return; + } + + let Some(request_key) = image_selected_request_key(runtime, handle) else { + if connected_empty_src_without_srcset(runtime, handle) { + let followup = runtime + .complete_pending_image_load_local_resource_if_matches(handle, sequence, false); + queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, sequence, followup); + } else { + let _ = runtime.cancel_pending_image_load_event_if_matches(handle, sequence); + } + let _ = runtime.process_image_decode_requests_for_element(scope, handle); + return; + }; + if !runtime.prepare_pending_image_load_request_if_matches(handle, sequence, request_key.clone()) + { + return; + } + let request_url = url::Url::parse(request_key.url()).map_err(|error| error.to_string()); // Cached pixels must pass the requesting element's current Document policy // before they can satisfy its load or decode work. if let Ok(request_url) = &request_url @@ -180,91 +258,99 @@ fn queue_image_load_event( ) .blocks_request() { - let followup = runtime.complete_pending_image_load_local_resource_if_matches( - handle, - pending.id(), - false, - ); - queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, pending.id(), followup); + let followup = + runtime.complete_pending_image_load_local_resource_if_matches(handle, sequence, false); + queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, sequence, followup); let _ = runtime.process_image_decode_requests_for_element(scope, handle); return; } - // Register the current request before reconsidering decode() promises. An - // image may receive src and decode() while detached, then be inserted in - // the same script job. Processing the promise before this registration - // would reject it even though insertion has just started its exact request. - let _ = runtime.process_image_decode_requests_for_element(scope, handle); + if runtime.image_resource_is_ready(handle) && !runtime.has_scanned_image_preload_for_element(handle) { let followup = - runtime.complete_pending_image_load_reused_resource_if_matches(handle, pending.id()); - queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, pending.id(), followup); + runtime.complete_pending_image_load_reused_resource_if_matches(handle, sequence); + queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, sequence, followup); + let _ = runtime.process_image_decode_requests_for_element(scope, handle); return; } + let start = request_url.and_then(|request_url| { crate::network_host::start_image_element_resource_fetch( scope, runtime, handle, - pending.id(), + sequence, request_url, ) }); match start { Ok(crate::network_host::ImageElementResourceFetchStart::Pending) => {} Ok(crate::network_host::ImageElementResourceFetchStart::PolicySkipped) => { - let followup = runtime.complete_pending_image_load_local_resource_if_matches( - handle, - pending.id(), - true, - ); - queue_image_load_terminal_followup_if_ready( - runtime_ptr, - handle, - pending.id(), - followup, - ); + let followup = runtime + .complete_pending_image_load_local_resource_if_matches(handle, sequence, true); + queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, sequence, followup); } Ok(crate::network_host::ImageElementResourceFetchStart::Local { descriptor, encoded, }) => { let completion = runtime.complete_pending_image_load_local_response_if_matches( - handle, - pending.id(), - descriptor, - encoded, + handle, sequence, descriptor, encoded, ); queue_image_load_terminal_followup_if_ready( runtime_ptr, handle, - pending.id(), + sequence, completion.followup(), ); } Err(error) => { tracing::debug!( image = handle.index(), - sequence = pending.id().get(), + sequence = sequence.get(), %error, "image resource selection failed" ); - let followup = runtime.complete_pending_image_load_local_resource_if_matches( - handle, - pending.id(), - false, - ); - queue_image_load_terminal_followup_if_ready( - runtime_ptr, - handle, - pending.id(), - followup, - ); + let followup = runtime + .complete_pending_image_load_local_resource_if_matches(handle, sequence, false); + queue_image_load_terminal_followup_if_ready(runtime_ptr, handle, sequence, followup); } } } +fn image_update_target_from_callback_data( + scope: &mut v8::PinScope<'_, '_>, + data: v8::Local<'_, v8::Value>, +) -> Option<(DomHandle, ImageLoadEventId, ImageLoadQueueTrigger)> { + let data = v8::Local::::try_from(data).ok()?; + let handle = data.get_index(scope, IMAGE_UPDATE_HANDLE_INDEX)?; + let handle = v8::Local::::try_from(handle).ok()?; + let (handle, handle_lossless) = handle.u64_value(); + let sequence = data.get_index(scope, IMAGE_UPDATE_ID_INDEX)?; + let sequence = v8::Local::::try_from(sequence).ok()?; + let (sequence, sequence_lossless) = sequence.u64_value(); + let trigger = data + .get_index(scope, IMAGE_UPDATE_TRIGGER_INDEX)? + .uint32_value(scope) + .and_then(|value| match value { + value if value == ImageLoadQueueTrigger::SourceOrInsertion as u32 => { + Some(ImageLoadQueueTrigger::SourceOrInsertion) + } + value if value == ImageLoadQueueTrigger::LazyReveal as u32 => { + Some(ImageLoadQueueTrigger::LazyReveal) + } + _ => None, + })?; + (handle_lossless && sequence_lossless).then(|| { + ( + DomHandle::new(handle as usize), + ImageLoadEventId::new(sequence), + trigger, + ) + }) +} + pub(crate) fn image_selected_source(runtime: &PageScriptHost, handle: DomHandle) -> Option { image_selected_source_candidate(runtime, handle).map(|candidate| candidate.url) } @@ -368,22 +454,6 @@ fn image_selected_picture_source( None } -fn image_load_is_suppressed_for_non_active_parent( - runtime: &PageScriptHost, - handle: DomHandle, -) -> bool { - runtime - .dom_host() - .node(handle) - .is_some_and(|node| !node.is_connected() && node.parent_node().is_some()) -} - -pub(crate) fn image_selected_source_url(runtime: &PageScriptHost, handle: DomHandle) -> String { - image_selected_resource(runtime, handle) - .map(|selected| selected.url) - .unwrap_or_default() -} - fn image_selected_resource( runtime: &PageScriptHost, handle: DomHandle, @@ -523,7 +593,10 @@ pub(crate) fn apply_image_attribute_mutation_plan( pub(crate) fn reset_image_load_dispatch(runtime: &mut PageScriptHost, handle: DomHandle) { let _ = runtime.cancel_pending_image_load_event(handle); - let _ = runtime.retire_image_resource_for_element(handle); + if image_selected_request_key(runtime, handle).is_none() { + runtime.set_current_image_request(handle, None); + let _ = runtime.retire_image_resource_for_element(handle); + } if let Some(element) = runtime .dom_host_mut() .node_mut(handle) @@ -543,21 +616,18 @@ pub(crate) fn mark_image_load_dispatched(runtime: &mut PageScriptHost, handle: D } } -fn record_local_image_resource_performance_entry( +fn record_image_resource_performance_entry_for_pending( scope: &mut v8::PinScope<'_, '_>, - runtime: &PageScriptHost, - handle: DomHandle, - initiator_type: &'static str, + pending: &crate::native_bridge::PendingImageLoadEvent, ) { - let url = image_selected_source_url(runtime, handle); - if url.is_empty() { + let Some(request_key) = pending.request_key() else { return; - } + }; crate::context_bootstrap::record_resource_performance_entry( scope, crate::context_bootstrap::ResourcePerformanceEntry::without_network_result( - url, - initiator_type, + request_key.url(), + pending.resource_timing_initiator_type(), None, ), ); @@ -590,7 +660,7 @@ pub(crate) fn apply_authorized_image_load_event_in_context( } let pending = runtime.take_pending_image_load_event_task_for_exact_target(task_id, target, kind)?; - let dispatched = dispatch_queued_image_load_event(scope, runtime_ptr, handle, pending, kind); + let dispatched = dispatch_queued_image_load_event(scope, runtime_ptr, handle, &pending, kind); let _ = runtime.settle_pending_image_load_event(pending, true); Some(if dispatched { PageImageLoadEventTargetEffect::DispatchedToCurrentOwner @@ -603,7 +673,7 @@ fn dispatch_queued_image_load_event( scope: &mut v8::PinScope<'_, '_>, runtime_ptr: *mut PageScriptHost, handle: DomHandle, - pending: crate::native_bridge::PendingImageLoadEvent, + pending: &crate::native_bridge::PendingImageLoadEvent, kind: RendererPageImageLoadEventKind, ) -> bool { let runtime = unsafe { &mut *runtime_ptr }; @@ -615,12 +685,7 @@ fn dispatch_queued_image_load_event( && pending.terminal_source() == Some(crate::native_bridge::PendingImageLoadTerminalSource::Local) { - record_local_image_resource_performance_entry( - scope, - runtime, - handle, - pending.resource_timing_initiator_type(), - ); + record_image_resource_performance_entry_for_pending(scope, pending); } let _ = runtime.process_pending_image_decode_requests(scope); let already_dispatched = runtime @@ -1072,17 +1137,10 @@ fn image_current_src_value<'s>( } fn image_current_src_value_for_handle(runtime: &PageScriptHost, handle: DomHandle) -> String { - let complete = runtime - .dom_host() - .node(handle) - .and_then(Node::as_element) - .is_some_and(|element| element.image_load_dispatched()) - || runtime.image_resource_is_ready(handle); - if complete { - image_selected_source_url(runtime, handle) - } else { - String::new() - } + runtime + .current_image_request_url(handle) + .unwrap_or_default() + .to_owned() } #[cfg(test)] diff --git a/moli-renderer-v8/src/network_host/image.rs b/moli-renderer-v8/src/network_host/image.rs index 70a9f4db4d8..9904d664dcc 100644 --- a/moli-renderer-v8/src/network_host/image.rs +++ b/moli-renderer-v8/src/network_host/image.rs @@ -170,9 +170,15 @@ pub(crate) fn start_image_element_resource_fetch( .pending_image_load_event(image_handle) .filter(|pending| pending.id() == sequence) .ok_or_else(|| "image lifecycle sequence is no longer pending".to_owned())?; - if !host.pending_image_load_event_is_current(image_handle, pending) { + if !host.pending_image_load_event_is_current(image_handle, &pending) { return Err("image lifecycle sequence owner is stale".to_owned()); } + if pending + .request_key() + .is_none_or(|request_key| request_key.url() != request_url.as_str()) + { + return Err("image lifecycle request identity changed before fetch".to_owned()); + } let owner = match pending.owner() { PendingImageLoadEventOwner::Main(binding) if host.main_document_task_owner_is_current(binding.owner()) => diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/image_load_event.rs b/moli-renderer-v8/src/runtime/page_vm/tests/image_load_event.rs index f1a6e1ea6f7..486259e2de9 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/image_load_event.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/image_load_event.rs @@ -187,7 +187,7 @@ image.src = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABA } #[tokio::test(flavor = "current_thread")] -async fn image_event_discards_a_document_open_task_before_applying_the_replacement_tail() { +async fn image_update_discards_a_retired_document_request_before_queuing_its_terminal_task() { run_page_vm_async_test(async move { let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default()).expect("loader"); @@ -232,28 +232,8 @@ currentImage.src = "/current-without-network.png"; "image event dispatch must not acquire a PageTimer descriptor" ); - let stale_task = take_next_image_load_event_task_for_test(&mut page_vm) - .expect("retired image task should settle as one explicit turn"); - let stale = page_vm.apply_selected_page_image_load_event_turn(stale_task)?; - let stale_action = stale.action; - assert_eq!( - stale_action.target_effect, - PageImageLoadEventTargetEffect::DiscardedStaleOwner { - current_owner: None, - stale_payload_effect: PageImageLoadEventStalePayloadEffect::NoSettledExactPayload, - } - ); - - assert_eq!( - page_vm - .vm_mut() - .eval("__documentExactImageEvents.join('|')")?, - "" - ); - let current = take_next_image_load_event_task_for_test(&mut page_vm) - .expect("replacement image task should survive stale-head settlement"); - assert_ne!(stale_action.owner.target(), current.owner().target()); + .expect("replacement image task should survive retired request cancellation"); page_vm .run_claimed_dom_manipulation_task_through_selected_dispatcher_for_test( crate::page_task_queue::RendererPageDomManipulationTask::ImageLoadEvent(current), @@ -268,7 +248,7 @@ currentImage.src = "/current-without-network.png"; ); assert!( take_next_image_load_event_task_for_test(&mut page_vm).is_none(), - "both exact-Document tasks must consume exactly two turns" + "the retired request must be cancelled before it manufactures a terminal task" ); Ok::<_, anyhow::Error>(()) }) diff --git a/moli-renderer-v8/src/runtime/phase_one/tests/extracted/inserted_resource_lifecycle.rs b/moli-renderer-v8/src/runtime/phase_one/tests/extracted/inserted_resource_lifecycle.rs index ac7f214255a..61f92843814 100644 --- a/moli-renderer-v8/src/runtime/phase_one/tests/extracted/inserted_resource_lifecycle.rs +++ b/moli-renderer-v8/src/runtime/phase_one/tests/extracted/inserted_resource_lifecycle.rs @@ -752,89 +752,96 @@ fn parser_document_fragment_insertion_queues_resource_followups_from_hoisted_roo .expect("current-thread runtime should build"); runtime.block_on(tokio::task::LocalSet::new().run_until(async move { - let mut page_vm = new_phase_one_page_vm_for_test(); - let body = create_connected_html_body_for_test(&mut page_vm); - let context_host = page_vm + let mut page_vm = new_phase_one_page_vm_for_test(); + let body = create_connected_html_body_for_test(&mut page_vm); + let context_host = page_vm + .vm() + .context_host_weak_for_test() + .upgrade() + .expect("context host should be alive"); + + let (fragment, _container, image, video) = + create_parser_resource_fragment_for_test(&mut page_vm, "parser-fragment-resource"); + assert!( + !context_host + .borrow() + .has_pending_image_load_event_for_test(image), + "disconnected fragment setup should not queue image load events" + ); + assert!( + !context_host + .borrow() + .lazy_media_load_candidates() + .contains(&video), + "disconnected fragment setup should not register lazy media candidates" + ); + assert_eq!( + page_vm.vm().ms_to_next_timeout(), + None, + "disconnected fragment setup should not queue text-track timers" + ); + + let custom_element_reaction_roots = { + apply_parser_dom_mutation_for_test( + &mut page_vm, + ParserDomMutation::AppendChild { + parent: body, + child: fragment, + }, + "parser fragment resource insertion should apply", + ) + }; + assert!( + custom_element_reaction_roots.is_empty(), + "plain resource fragment insertion should not queue custom element reactions" + ); + assert_eq!( + page_vm .vm() - .context_host_weak_for_test() - .upgrade() - .expect("context host should be alive"); - - let (fragment, _container, image, video) = - create_parser_resource_fragment_for_test(&mut page_vm, "parser-fragment-resource"); - assert!( - !context_host - .borrow() - .has_pending_image_load_event_for_test(image), - "disconnected fragment setup should not queue image load events" - ); - assert!( - !context_host - .borrow() - .lazy_media_load_candidates() - .contains(&video), - "disconnected fragment setup should not register lazy media candidates" - ); - assert_eq!( - page_vm.vm().ms_to_next_timeout(), - None, - "disconnected fragment setup should not queue text-track timers" - ); - - let custom_element_reaction_roots = { - apply_parser_dom_mutation_for_test( - &mut page_vm, - ParserDomMutation::AppendChild { - parent: body, - child: fragment, - }, - "parser fragment resource insertion should apply", - ) - }; - assert!( - custom_element_reaction_roots.is_empty(), - "plain resource fragment insertion should not queue custom element reactions" - ); - assert_eq!( - page_vm - .vm() - .document_runtime - .dom_host() - .child_handles(fragment) - .count(), - 0, - "parser DocumentFragment resource insertion should hoist and empty the fragment" - ); - assert!( - context_host - .borrow() - .has_pending_image_load_event_for_test(image), - "parser DocumentFragment insertion should queue image load events for hoisted subtree children" - ); - assert!( - context_host - .borrow() - .lazy_media_load_candidates() - .contains(&video), - "parser DocumentFragment insertion should register hoisted lazy media candidates" - ); - assert_eq!( - page_vm.vm().ms_to_next_timeout(), - None, - "parser DocumentFragment insertion must not represent text-track default-mode work as a timer" - ); - assert!(matches!( + .document_runtime + .dom_host() + .child_handles(fragment) + .count(), + 0, + "parser DocumentFragment resource insertion should hoist and empty the fragment" + ); + assert!( + context_host + .borrow() + .has_pending_image_load_event_for_test(image), + "parser DocumentFragment insertion should queue image load events for hoisted subtree children" + ); + assert!( + context_host + .borrow() + .lazy_media_load_candidates() + .contains(&video), + "parser DocumentFragment insertion should register hoisted lazy media candidates" + ); + assert_eq!( + page_vm.vm().ms_to_next_timeout(), + None, + "parser DocumentFragment insertion must not represent text-track default-mode work as a timer" + ); + page_vm + .vm_mut() + .perform_script_task_checkpoint(None) + .expect("parser task-end checkpoint should select the image request"); + assert!( + matches!( + take_next_dom_manipulation_task_for_test(&page_vm), + crate::page_task_queue::RendererPageDomManipulationTask::TextTrackDefaultMode(_) + ), + "the synchronous text-track task should precede the image terminal queued by the task-end microtask" + ); + assert!( + matches!( take_next_dom_manipulation_task_for_test(&page_vm), crate::page_task_queue::RendererPageDomManipulationTask::ImageLoadEvent(_) - )); - assert!( - matches!( - take_next_dom_manipulation_task_for_test(&page_vm), - crate::page_task_queue::RendererPageDomManipulationTask::TextTrackDefaultMode(_) - ), - "hoisted text track should follow the earlier image in the shared DOM FIFO" - ); - })); + ), + "the image-update microtask should queue its terminal after the earlier text-track task" + ); + })); } #[test] fn parser_document_fragment_insert_before_queues_resource_followups_from_hoisted_roots() { @@ -844,113 +851,120 @@ fn parser_document_fragment_insert_before_queues_resource_followups_from_hoisted .expect("current-thread runtime should build"); runtime.block_on(tokio::task::LocalSet::new().run_until(async move { - let mut page_vm = new_phase_one_page_vm_for_test(); - let body = create_connected_html_body_for_test(&mut page_vm); - let context_host = page_vm - .vm() - .context_host_weak_for_test() - .upgrade() - .expect("context host should be alive"); - let reference = { - let dom_host = page_vm.vm_mut().document_runtime.dom_host_mut(); - let reference = dom_host.create_parser_element_without_attributes( - "span".to_owned(), - "http://www.w3.org/1999/xhtml".to_owned(), - None, - ); - assert!(dom_host.set_attribute(reference, "id", "parser-fragment-resource-ref")); - assert!(dom_host.append_child(body, reference)); - reference - }; + let mut page_vm = new_phase_one_page_vm_for_test(); + let body = create_connected_html_body_for_test(&mut page_vm); + let context_host = page_vm + .vm() + .context_host_weak_for_test() + .upgrade() + .expect("context host should be alive"); + let reference = { + let dom_host = page_vm.vm_mut().document_runtime.dom_host_mut(); + let reference = dom_host.create_parser_element_without_attributes( + "span".to_owned(), + "http://www.w3.org/1999/xhtml".to_owned(), + None, + ); + assert!(dom_host.set_attribute(reference, "id", "parser-fragment-resource-ref")); + assert!(dom_host.append_child(body, reference)); + reference + }; - let (fragment, container, image, video) = create_parser_resource_fragment_for_test( + let (fragment, container, image, video) = create_parser_resource_fragment_for_test( + &mut page_vm, + "parser-fragment-resource-before", + ); + assert!( + !context_host + .borrow() + .has_pending_image_load_event_for_test(image), + "disconnected fragment setup should not queue image load events" + ); + assert!( + !context_host + .borrow() + .lazy_media_load_candidates() + .contains(&video), + "disconnected fragment setup should not register lazy media candidates" + ); + assert_eq!( + page_vm.vm().ms_to_next_timeout(), + None, + "disconnected fragment setup should not queue text-track timers" + ); + + let custom_element_reaction_roots = { + apply_parser_dom_mutation_for_test( &mut page_vm, - "parser-fragment-resource-before", - ); - assert!( - !context_host - .borrow() - .has_pending_image_load_event_for_test(image), - "disconnected fragment setup should not queue image load events" - ); - assert!( - !context_host - .borrow() - .lazy_media_load_candidates() - .contains(&video), - "disconnected fragment setup should not register lazy media candidates" - ); - assert_eq!( - page_vm.vm().ms_to_next_timeout(), - None, - "disconnected fragment setup should not queue text-track timers" - ); - - let custom_element_reaction_roots = { - apply_parser_dom_mutation_for_test( - &mut page_vm, - ParserDomMutation::InsertBefore { - parent: body, - child: fragment, - reference_child: Some(reference), - }, - "parser fragment resource insertBefore should apply", - ) - }; - assert!( - custom_element_reaction_roots.is_empty(), - "plain resource fragment insertBefore should not queue custom element reactions" - ); - assert_eq!( - page_vm - .vm() - .document_runtime - .dom_host() - .child_handles(fragment) - .count(), - 0, - "parser DocumentFragment resource insertBefore should hoist and empty the fragment" - ); - assert_eq!( - page_vm - .vm() - .document_runtime - .dom_host() - .child_handles(body) - .collect::>(), - vec![container, reference], - "parser DocumentFragment resource insertBefore should place the hoisted root before the reference child" - ); - assert!( - context_host - .borrow() - .has_pending_image_load_event_for_test(image), - "parser DocumentFragment insertBefore should queue image load events for hoisted subtree children" - ); - assert!( - context_host - .borrow() - .lazy_media_load_candidates() - .contains(&video), - "parser DocumentFragment insertBefore should register hoisted lazy media candidates" - ); - assert_eq!( - page_vm.vm().ms_to_next_timeout(), - None, - "parser DocumentFragment insertBefore must not represent text-track default-mode work as a timer" - ); - assert!(matches!( + ParserDomMutation::InsertBefore { + parent: body, + child: fragment, + reference_child: Some(reference), + }, + "parser fragment resource insertBefore should apply", + ) + }; + assert!( + custom_element_reaction_roots.is_empty(), + "plain resource fragment insertBefore should not queue custom element reactions" + ); + assert_eq!( + page_vm + .vm() + .document_runtime + .dom_host() + .child_handles(fragment) + .count(), + 0, + "parser DocumentFragment resource insertBefore should hoist and empty the fragment" + ); + assert_eq!( + page_vm + .vm() + .document_runtime + .dom_host() + .child_handles(body) + .collect::>(), + vec![container, reference], + "parser DocumentFragment resource insertBefore should place the hoisted root before the reference child" + ); + assert!( + context_host + .borrow() + .has_pending_image_load_event_for_test(image), + "parser DocumentFragment insertBefore should queue image load events for hoisted subtree children" + ); + assert!( + context_host + .borrow() + .lazy_media_load_candidates() + .contains(&video), + "parser DocumentFragment insertBefore should register hoisted lazy media candidates" + ); + assert_eq!( + page_vm.vm().ms_to_next_timeout(), + None, + "parser DocumentFragment insertBefore must not represent text-track default-mode work as a timer" + ); + page_vm + .vm_mut() + .perform_script_task_checkpoint(None) + .expect("parser task-end checkpoint should select the image request"); + assert!( + matches!( + take_next_dom_manipulation_task_for_test(&page_vm), + crate::page_task_queue::RendererPageDomManipulationTask::TextTrackDefaultMode(_) + ), + "the synchronous text-track task should precede the image terminal queued by the task-end microtask" + ); + assert!( + matches!( take_next_dom_manipulation_task_for_test(&page_vm), crate::page_task_queue::RendererPageDomManipulationTask::ImageLoadEvent(_) - )); - assert!( - matches!( - take_next_dom_manipulation_task_for_test(&page_vm), - crate::page_task_queue::RendererPageDomManipulationTask::TextTrackDefaultMode(_) - ), - "insertBefore-hoisted text track should follow the image in the shared DOM FIFO" - ); - })); + ), + "the image-update microtask should queue its terminal after the earlier text-track task" + ); + })); } #[test] fn js_insert_before_inserted_lazy_media_registers_candidate_from_mutation_owner() { diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/images.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/images.rs index 107169d96ba..4c698ded19e 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/images.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/images.rs @@ -262,6 +262,176 @@ async fn image_fetch_enabled_discards_stale_queued_terminal_event() { ); } +#[tokio::test] +async fn image_current_src_switches_only_when_the_update_microtask_selects_a_current_request() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + loader.set_image_fetch_enabled(true); + let (mut vm, _resource_completion_queue) = + new_storage_test_vm_with_loader_and_resource_completion_queue( + "https://image-current-request.test/page.html", + &loader, + ); + + let before_update = vm + .eval( + r#" + (() => { + const picture = document.createElement("picture"); + const nonMatchingSource = document.createElement("source"); + nonMatchingSource.media = "not all"; + nonMatchingSource.srcset = "data:,a"; + picture.append(nonMatchingSource); + + const matchingSource = document.createElement("source"); + matchingSource.media = "all"; + matchingSource.srcset = "data:,b"; + picture.append(matchingSource); + + const image = document.createElement("img"); + globalThis.__imageCurrentRequestObservations = []; + image.src = "data:,c"; + const beforeUpdate = image.currentSrc; + queueMicrotask(() => { + __imageCurrentRequestObservations.push(`first:${image.currentSrc}`); + picture.append(image); + __imageCurrentRequestObservations.push(`inserted:${image.currentSrc}`); + queueMicrotask(() => { + __imageCurrentRequestObservations.push(`second:${image.currentSrc}`); + }); + }); + return beforeUpdate; + })() + "#, + ) + .expect("image current request setup should evaluate"); + assert_eq!(before_update, ""); + assert_eq!( + vm.eval("globalThis.__imageCurrentRequestObservations.join('|')") + .expect("image current request observations should evaluate"), + "first:data:,c|inserted:data:,c|second:data:,b" + ); +} + +#[tokio::test] +async fn image_current_src_distinguishes_initial_and_replacement_requests() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + loader.set_image_fetch_enabled(true); + let mut vm = new_storage_page_task_executor_test_vm_with_loader( + "https://image-current-request.test/page.html", + &loader, + ); + vm.set_fetch_subresource_interception( + crate::types::SubresourceInterceptionClasses::for_resource_type( + crate::types::SubresourceResourceType::Image, + ), + ); + + assert_eq!( + vm.eval( + r#" + (() => { + const image = globalThis.__currentRequestImage = new Image(); + image.src = "first.gif"; + image.srcset = "first.gif"; + return image.currentSrc; + })() + "#, + ) + .expect("initial request should be queued"), + "" + ); + let observe = |vm: &mut crate::runtime::PageVmTaskExecutorTestHarness| { + vm.eval( + r#" + (() => { + const image = __currentRequestImage; + return [image.currentSrc, image.naturalWidth].join("|"); + })() + "#, + ) + .expect("current request state should be readable") + }; + let first = vm.take_pending_subresource_fetch_infos(); + assert_eq!(first.len(), 1); + assert_eq!(first[0].url.path(), "/first.gif"); + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/first.gif|0" + ); + vm.fulfill_pending_subresource_fetch( + first[0].internal_id, + 200, + vec![("Content-Type".to_owned(), "image/gif".to_owned())], + one_by_one_gif_response_body(), + ) + .expect("initial image request should fulfill"); + run_next_image_event_task(&mut vm, &loader, "initial image decode").await; + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/first.gif|1" + ); + + vm.eval( + r#" + __currentRequestImage.src = "replacement.gif"; + __currentRequestImage.removeAttribute("srcset"); + "#, + ) + .expect("replacement image request should start"); + let replacement = vm.take_pending_subresource_fetch_infos(); + assert_eq!(replacement.len(), 1); + assert_eq!(replacement[0].url.path(), "/replacement.gif"); + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/first.gif|1" + ); + vm.fulfill_pending_subresource_fetch( + replacement[0].internal_id, + 200, + vec![("Content-Type".to_owned(), "image/gif".to_owned())], + one_by_one_gif_response_body(), + ) + .expect("replacement image request should fulfill"); + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/first.gif|1", + "the current image survives until the replacement decode commits" + ); + run_next_image_event_task(&mut vm, &loader, "replacement image decode").await; + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/replacement.gif|1" + ); + + vm.eval(r#"__currentRequestImage.src = "broken.gif""#) + .expect("broken replacement should start"); + let broken = vm.take_pending_subresource_fetch_infos(); + assert_eq!(broken.len(), 1); + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/replacement.gif|1" + ); + vm.fulfill_pending_subresource_fetch( + broken[0].internal_id, + 200, + vec![("Content-Type".to_owned(), "image/gif".to_owned())], + crate::runtime::RendererSyntheticResponseBody::from_bytes(b"invalid GIF".to_vec()), + ) + .expect("broken image response should settle"); + run_next_image_event_task(&mut vm, &loader, "broken image error").await; + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/broken.gif|0" + ); + + vm.eval(r#"__currentRequestImage.src = "recovery.gif""#) + .expect("recovery image request should start"); + assert_eq!( + observe(&mut vm), + "https://image-current-request.test/recovery.gif|0" + ); +} + #[tokio::test] async fn image_fetch_enabled_dispatches_http_error_after_resource_timing() { let (base_url, request_rx, server) = @@ -517,6 +687,85 @@ async fn inserting_completed_detached_image_does_not_restart_request() { ); } +#[tokio::test] +async fn image_update_microtask_freezes_request_after_observing_live_base_url() { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); + loader.set_image_fetch_enabled(true); + let mut vm = new_storage_page_task_executor_test_vm_with_loader( + "https://image-update-base.test/page.html", + &loader, + ); + vm.set_fetch_subresource_interception( + crate::types::SubresourceInterceptionClasses::for_resource_type( + crate::types::SubresourceResourceType::Image, + ), + ); + + vm.eval( + r#" + (() => { + const image = new Image(); + globalThis.__baseSelectedImage = image; + globalThis.__baseSelectedImageEvents = []; + image.onload = () => __baseSelectedImageEvents.push("load"); + image.onerror = () => __baseSelectedImageEvents.push("error"); + image.src = "green.png"; + + const root = document.documentElement || + document.appendChild(document.createElement("html")); + const head = document.head || + root.insertBefore(document.createElement("head"), root.firstChild); + const base = document.createElement("base"); + base.href = "/resources/"; + head.appendChild(base); + globalThis.__baseSelectedImageBase = base; + })() + "#, + ) + .expect("image and base should update in one script turn"); + + let pending = vm.take_pending_subresource_fetch_infos(); + assert_eq!(pending.len(), 1); + assert_eq!( + pending[0].url.as_str(), + "https://image-update-base.test/resources/green.png", + "URL selection must happen in the queued image-update microtask" + ); + vm.fulfill_pending_subresource_fetch( + pending[0].internal_id, + 200, + vec![("Content-Type".to_owned(), "image/gif".to_owned())], + one_by_one_gif_response_body(), + ) + .expect("base-selected image response should complete"); + + vm.eval( + r#" + (() => { + __baseSelectedImageBase.href = "/bogus/"; + (document.body || document.documentElement).appendChild(__baseSelectedImage); + })() + "#, + ) + .expect("completed detached image should insert after a later base change"); + assert!( + vm.take_pending_subresource_fetch_infos().is_empty(), + "ordinary insertion must preserve the request selected by the update microtask" + ); + + run_next_image_event_task(&mut vm, &loader, "base-selected image event").await; + assert_eq!( + vm.eval( + r#"__baseSelectedImageEvents.join("|") + ":" + + performance.getEntriesByName( + "https://image-update-base.test/resources/green.png" + ).length"#, + ) + .expect("base-selected image result should evaluate"), + "load:1" + ); +} + #[tokio::test] async fn removed_lazy_image_suppresses_in_flight_terminal_event() { let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); @@ -550,6 +799,8 @@ async fn removed_lazy_image_suppresses_in_flight_terminal_event() { vm.refresh_layout_snapshot_for_test(moli_layout::LayoutViewport::new(800, 600, 1.0,)) .expect("near lazy-image layout refresh should succeed") ); + vm.perform_owner_lane_task_microtask_checkpoints() + .expect("layout task should finish its image-update microtask checkpoint"); let pending = vm.take_pending_subresource_fetch_infos(); assert_eq!(pending.len(), 1); @@ -893,7 +1144,7 @@ async fn image_request_interception_fulfills_through_image_continuation() { } #[tokio::test] -async fn image_decode_waits_for_in_flight_pixels_and_reuses_the_ready_resource() { +async fn image_decode_quick_attach_distinguishes_uncached_and_ready_requests() { let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader"); loader.set_image_fetch_enabled(true); let mut vm = new_storage_page_task_executor_test_vm_with_loader( @@ -928,8 +1179,8 @@ async fn image_decode_waits_for_in_flight_pixels_and_reuses_the_ready_resource() assert_eq!(pending.len(), 1); assert_eq!( vm.eval("globalThis.__firstSharedDecode") - .expect("in-flight image decode state should evaluate"), - "pending" + .expect("uncached quick-attach image decode state should evaluate"), + "reject:EncodingError" ); vm.fulfill_pending_subresource_fetch( pending[0].internal_id, @@ -942,7 +1193,7 @@ async fn image_decode_waits_for_in_flight_pixels_and_reuses_the_ready_resource() assert_eq!( vm.eval("globalThis.__firstSharedDecode") .expect("first image decode result should evaluate"), - "resolve" + "reject:EncodingError" ); let first_image = vm .document_runtime diff --git a/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs b/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs index 3696d9930af..bc2d4c8db14 100644 --- a/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs +++ b/moli-renderer-v8/src/script_vm/tests/canvas_webgl.rs @@ -2605,6 +2605,7 @@ fn html_image_data_gif_exposes_intrinsic_dimensions() { r#" (() => { const img = new Image(4, 5); + globalThis.__lmDataGifImage = img; img.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'; return [ img.complete, @@ -2618,7 +2619,16 @@ fn html_image_data_gif_exposes_intrinsic_dimensions() { ) .expect("data image dimensions should be readable"); - assert_eq!(result, "true|4|5|1|1"); + assert_eq!(result, "true|4|5|0|0"); + assert_eq!( + vm.eval( + "[__lmDataGifImage.complete, __lmDataGifImage.width, \ + __lmDataGifImage.height, __lmDataGifImage.naturalWidth, \ + __lmDataGifImage.naturalHeight].join('|')", + ) + .expect("data image dimensions should settle at the task checkpoint"), + "true|4|5|1|1" + ); } #[test] @@ -2681,6 +2691,13 @@ fn html_image_data_svg_exposes_intrinsic_dimensions() { const fractionalConcreteHeight = new Image(); fractionalConcreteHeight.src = 'data:image/svg+xml,'; + globalThis.__lmDataSvgImages = { + sized, + ratioWidth, + noSize, + fractionalConcreteHeight + }; + return [ [sized.naturalWidth, sized.naturalHeight].join('x'), [ratioWidth.naturalWidth, ratioWidth.naturalHeight].join('x'), @@ -2692,6 +2709,24 @@ fn html_image_data_svg_exposes_intrinsic_dimensions() { ) .expect("data SVG image dimensions should be readable"); + assert_eq!(result, "0x0|0x0|0x0|0x0"); + + let result = vm + .eval( + r#" +(() => { + const { sized, ratioWidth, noSize, fractionalConcreteHeight } = __lmDataSvgImages; + return [ + [sized.naturalWidth, sized.naturalHeight].join('x'), + [ratioWidth.naturalWidth, ratioWidth.naturalHeight].join('x'), + [noSize.naturalWidth, noSize.naturalHeight].join('x'), + [fractionalConcreteHeight.naturalWidth, fractionalConcreteHeight.naturalHeight].join('x') + ].join('|'); +})() +"#, + ) + .expect("data SVG dimensions should settle at the task checkpoint"); + // Blink resolves an external SVG with neither dimensions nor a viewBox // against the replaced-element default object size. // Its DOM natural dimensions remain integers even when layout retains the @@ -2774,7 +2809,7 @@ async fn html_image_load_runs_on_its_dom_task_not_window_load_dispatch() { ) .expect("image setup should evaluate"); - assert_eq!(before_load, "1|1|1|1|pending"); + assert_eq!(before_load, "0|0|0|0|pending"); vm.dispatch_window_load_event() .expect("window load should not dispatch pending image loads"); @@ -2925,8 +2960,8 @@ async fn html_image_complete_tracks_pending_src_and_srcset_loads() { assert_eq!( drain_canvas_image_load_event_tasks(&mut vm, &loader).await, - 4, - "src, srcset, empty-src, and retired-source work must each settle one queued task" + 3, + "src, srcset, and empty-src work must settle queued tasks; the retired source is cancelled before its update microtask can manufacture one" ); let after_load = vm @@ -3515,6 +3550,8 @@ async fn parser_image_load_honors_meta_img_src_csp() { .expect("parser EOF should prepare interactive"); vm.apply_main_document_interactive_lifecycle_action(interactive) .expect("interactive transition should register the parser image"); + vm.perform_script_task_checkpoint(None) + .expect("parser task-end checkpoint should select the image request"); run_one_canvas_image_load_event_task(&mut vm, &loader).await; assert_eq!( drain_pre_domcontentloaded_non_script_page_tasks_for_test(&mut vm), @@ -4111,6 +4148,8 @@ async fn html_image_lazy_detached_sources_wait_until_inserted() { vm.refresh_layout_snapshot_for_test(moli_layout::LayoutViewport::new(800, 600, 1.0,)) .expect("inserted lazy-image layout refresh should succeed") ); + vm.perform_owner_lane_task_microtask_checkpoints() + .expect("layout task should finish its image-update microtask checkpoint"); assert!( drain_canvas_image_load_event_tasks(&mut vm, &loader).await > 0, "inserted lazy image events should dispatch" @@ -4204,6 +4243,8 @@ async fn html_image_below_viewport_lazy_waits_until_scroll_reveal() { vm.refresh_layout_snapshot_for_test(moli_layout::LayoutViewport::new(800, 600, 1.0,)) .expect("initial lazy-image layout refresh should succeed") ); + vm.perform_owner_lane_task_microtask_checkpoints() + .expect("layout task should finish its image-update microtask checkpoint"); assert!( drain_canvas_image_load_event_tasks(&mut vm, &loader).await > 0, "the near-viewport lazy image should be admitted" diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs index d865e5bc1c1..cd8c1167331 100644 --- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs +++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface/extracted/child_document_lifecycle.rs @@ -1065,7 +1065,7 @@ async fn child_image_network_failure_releases_lifecycle_before_later_host_load() assert!( vm._context_host .borrow() - .pending_image_load_event_is_current(child_image, detached_pending), + .pending_image_load_event_is_current(child_image, &detached_pending), "same-document detach must preserve current image ownership" ); assert!(