diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rs index fa5b44db06c..1b6d7fbefcb 100644 --- a/moli-core/tests/web_apis.rs +++ b/moli-core/tests/web_apis.rs @@ -4458,6 +4458,11 @@ async fn chrome_fontfaceset_ready_keeps_stable_promise_until_loading_starts_subs .fetch(&server.url("/compat/chrome-fontfaceset-ready-basic")) .await?; + // The fixture writes its result after FontFaceSet.ready, whose task may + // run after load. Await that completion before inspecting its attributes. + page.evaluate_runtime_expression_with_await_async("document.fonts.ready", true) + .await?; + assert!( page.serialize_html_async() .await diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs index 77bfe227c23..269ccb18c71 100644 --- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs +++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/events.rs @@ -190,10 +190,15 @@ fn queue_font_face_set_task<'s>( .data(data.into()) .build(scope) .expect("font loading task"); - // The internal task scheduler captures this realm's exact Window/Document - // lifetime and discards the callback when that owner retires. + // Keep the CSS Font Loading task source and this Realm's exact lifetime. if let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) { - unsafe { &mut *host_ptr }.queue_internal_task(scope, callback); + use crate::page_task_queue::RendererPageFontLoadingTaskKind; + let kind = if finish { + RendererPageFontLoadingTaskKind::FontFaceSetCompletion + } else { + RendererPageFontLoadingTaskKind::FontFaceSetLoading + }; + unsafe { &mut *host_ptr }.queue_font_loading_task(scope, callback, kind); } else { crate::worker::queue_worker_font_task(scope, callback); } diff --git a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs index 556ca3f788f..c3e724bbd1b 100644 --- a/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs +++ b/moli-renderer-v8/src/context_bootstrap/css_fontface_runtime/loading.rs @@ -393,7 +393,11 @@ pub(super) fn queue_requested_font_loads( .data(face.into()) .build(scope) .expect("font resource task"); - if unsafe { &mut *host_ptr }.queue_internal_task(scope, callback) { + if unsafe { &mut *host_ptr }.queue_font_loading_task( + scope, + callback, + crate::page_task_queue::RendererPageFontLoadingTaskKind::FontFaceLoad, + ) { let queued = v8::Boolean::new(scope, true); set_private_value(scope, face, REQUEST_QUEUED, queued.into()); } else { 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 fd7bec8bfa2..a3a4d736890 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/core.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/core.rs @@ -512,6 +512,7 @@ impl PageScriptHost { file_reading_tasks: super::file_reading_tasks::FileReadingState::default(), misc_platform_api_tasks: super::misc_platform_api_tasks::MiscPlatformApiTaskState::default(), + font_loading_tasks: super::font_loading_tasks::FontLoadingTaskState::default(), device_sensor_tasks: super::device_sensor_tasks::DeviceSensorTaskState::default(), canvas_blob_serialization_tasks: super::canvas_blob_serialization_tasks::CanvasBlobSerializationTaskState::default(), @@ -1087,6 +1088,17 @@ impl PageScriptHost { .misc_platform_api() .clone() } + pub(crate) fn page_font_loading_sender( + &self, + ) -> crate::page_task_queue::RendererPageFontLoadingSender { + self.page_task_capabilities + .get() + .expect( + "a live Page Window must install its complete Page task capabilities before font-loading callback admission", + ) + .font_loading() + .clone() + } pub(crate) fn page_device_sensor_sender( &self, ) -> crate::page_task_queue::RendererPageDeviceSensorSender { diff --git a/moli-renderer-v8/src/native_bridge/context_host/font_loading_tasks.rs b/moli-renderer-v8/src/native_bridge/context_host/font_loading_tasks.rs new file mode 100644 index 00000000000..68e684e8759 --- /dev/null +++ b/moli-renderer-v8/src/native_bridge/context_host/font_loading_tasks.rs @@ -0,0 +1,143 @@ +use crate::{ + native_bridge::WindowExecutionContextIdentity, + page_task_queue::{ + PageFontLoadingTargetEffect, RendererPageFontLoadingTaskId, RendererPageFontLoadingTaskKind, + }, +}; + +use super::window_document_tasks::{ExactWindowDocumentTaskLedger, PendingExactWindowDocumentTask}; +use super::{PageScriptHost, WindowDocumentTaskTarget}; + +pub(super) type FontLoadingTaskState = ExactWindowDocumentTaskLedger< + RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, + FontLoadingCallback, +>; + +/// Browser-created font algorithms retain their creation Realm, independently +/// of whichever Window is current when the Page selects the task. +pub(crate) struct FontLoadingCallback { + identity: WindowExecutionContextIdentity, + context: v8::Global, + callback: v8::Global, +} + +impl PageScriptHost { + pub(crate) fn queue_font_loading_task<'s>( + &mut self, + scope: &mut v8::PinScope<'s, '_>, + callback: v8::Local<'s, v8::Function>, + kind: RendererPageFontLoadingTaskKind, + ) -> bool { + let Some(context) = callback.get_creation_context(scope) else { + return false; + }; + let scope = &mut v8::ContextScope::new(scope, context); + let Some(identity) = self.current_runtime_window_execution_context_identity(scope) else { + return false; + }; + let Some(target) = self.current_window_document_task_target(scope) else { + return false; + }; + let task_id = self + .font_loading_tasks + .allocate_task_id(RendererPageFontLoadingTaskId::from_raw); + let payload = FontLoadingCallback { + identity, + context: v8::Global::new(scope, context), + callback: v8::Global::new(scope, callback), + }; + self.font_loading_tasks + .push(PendingExactWindowDocumentTask::new( + task_id, target, kind, payload, + )); + if self + .page_font_loading_sender() + .send(target, task_id, kind) + .is_ok() + { + return true; + } + let _ = self.font_loading_tasks.remove_exact(task_id, target, kind); + false + } + + pub(crate) fn current_pending_font_loading_task( + &self, + task_id: RendererPageFontLoadingTaskId, + ) -> Option<(WindowDocumentTaskTarget, RendererPageFontLoadingTaskKind)> { + let pending = self.font_loading_tasks.pending(task_id)?; + if !self.window_execution_context_identity_is_current(pending.payload().identity) { + return None; + } + let current = self.current_window_document_task_target_for_dispatch_scope( + pending.target().dispatch_scope(), + )?; + Some((current, pending.kind())) + } + + pub(crate) fn take_pending_font_loading_task_for_exact_target( + &mut self, + task_id: RendererPageFontLoadingTaskId, + target: WindowDocumentTaskTarget, + kind: RendererPageFontLoadingTaskKind, + ) -> Option { + self.font_loading_tasks + .remove_exact(task_id, target, kind) + .map(PendingExactWindowDocumentTask::into_payload) + } + + pub(crate) fn discard_pending_font_loading_task( + &mut self, + task_id: RendererPageFontLoadingTaskId, + ) -> bool { + self.font_loading_tasks.remove(task_id).is_some() + } + + pub(crate) fn dispatch_authorized_font_loading_task( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + _host_ptr: *mut PageScriptHost, + target: WindowDocumentTaskTarget, + task: FontLoadingCallback, + ) -> PageFontLoadingTargetEffect { + if !self.window_execution_context_identity_is_current(task.identity) + || self.current_window_document_task_target_for_dispatch_scope( + task.identity.dispatch_scope(), + ) != Some(target) + { + return PageFontLoadingTargetEffect::CurrentOwnerCallbackRetired; + } + let context = v8::Local::new(scope, &task.context); + let scope = &mut v8::ContextScope::new(scope, context); + let dispatch_scope = target.dispatch_scope(); + let previous = dispatch_scope.enter(scope); + let callback = v8::Local::new(scope, &task.callback); + let receiver = context.global(scope); + // This is a browser algorithm, not an author timer or a Web IDL + // callback. Its selected Page task owns the eventual checkpoint. + let result = + moli_webidl_callback::with_webidl_callback_contexts(scope, context, context, |scope| { + crate::exception_reporting::invoke_callback_with_report( + scope, + "font loading task", + "font loading task threw", + crate::exception_reporting::CallbackExceptionLogLevel::Debug, + "font loading task", + callback, + receiver.into(), + &[], + ) + }); + if let Err(report) = result { + crate::host::report_window_timer_exception( + scope, + Some(task.identity), + Some(callback), + &report, + ); + } + dispatch_scope.restore(scope, previous); + PageFontLoadingTargetEffect::CallbackInvokedForCurrentOwner + } +} 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 1cbefd3b400..a737e2c09e0 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/mod.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/mod.rs @@ -130,6 +130,7 @@ mod interaction_batch; pub(crate) use interaction_batch::PendingScrollObservableEffects; mod canvas_blob_serialization_tasks; mod device_sensor_tasks; +mod font_loading_tasks; mod internal_node_refs; mod layout; mod layout_snapshot; @@ -1059,6 +1060,7 @@ pub(crate) struct PageScriptHost { pending_text_control_change_commit: Option, file_reading_tasks: file_reading_tasks::FileReadingState, misc_platform_api_tasks: misc_platform_api_tasks::MiscPlatformApiTaskState, + font_loading_tasks: font_loading_tasks::FontLoadingTaskState, device_sensor_tasks: device_sensor_tasks::DeviceSensorTaskState, canvas_blob_serialization_tasks: canvas_blob_serialization_tasks::CanvasBlobSerializationTaskState, diff --git a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs index fcf7cc14da9..c8dd2348a24 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/runtime_observable.rs @@ -241,6 +241,7 @@ impl PageScriptHost { self.pending_window_messages.clear(); drop(std::mem::take(&mut self.file_reading_tasks)); drop(std::mem::take(&mut self.misc_platform_api_tasks)); + drop(std::mem::take(&mut self.font_loading_tasks)); drop(std::mem::take(&mut self.device_sensor_tasks)); drop(std::mem::take(&mut self.file_entry_file_callbacks)); drop(std::mem::take(&mut self.user_interaction_tasks)); diff --git a/moli-renderer-v8/src/page_task_queue.rs b/moli-renderer-v8/src/page_task_queue.rs index 7bd2bdafce4..f591e04d53d 100644 --- a/moli-renderer-v8/src/page_task_queue.rs +++ b/moli-renderer-v8/src/page_task_queue.rs @@ -39,6 +39,7 @@ pub(crate) use webrtc::{ RendererPageWebRtcTaskKind, }; mod device_sensor; +mod font_loading; mod message_port_delivery; mod misc_platform_api; mod module_reaction; @@ -276,6 +277,11 @@ pub(crate) use self::file_reading::{ RendererPageFileReaderPhase, RendererPageFileReadingOwner, RendererPageFileReadingSender, RendererPageFileReadingTask, RendererPageFileReadingTaskId, RendererPageFileReadingTaskKind, }; +pub(crate) use self::font_loading::{ + PageFontLoadingTargetEffect, PageFontLoadingTurnAction, PageFontLoadingTurnOutcome, + RendererPageFontLoadingOwner, RendererPageFontLoadingSender, RendererPageFontLoadingTask, + RendererPageFontLoadingTaskId, RendererPageFontLoadingTaskKind, +}; pub(crate) use self::form_navigation::{ PageFormNavigationTargetEffect, PageFormNavigationTurnAction, PageFormNavigationTurnOutcome, RendererPageFormNavigationOwner, RendererPageFormNavigationSender, diff --git a/moli-renderer-v8/src/page_task_queue/font_loading.rs b/moli-renderer-v8/src/page_task_queue/font_loading.rs new file mode 100644 index 00000000000..d045033924c --- /dev/null +++ b/moli-renderer-v8/src/page_task_queue/font_loading.rs @@ -0,0 +1,73 @@ +//! Exact Window/Document tasks from the CSS Font Loading task source. +//! +//! This source is intentionally separate from timers, DOM manipulation, and +//! storage events. A Web API binding may publish an immutable task envelope, +//! but only the Page owner may authorize its exact Window/Document and the +//! selected-task dispatcher remains the sole task-completion authority. + +use crate::runtime::PageOwnerTurnOutcome; + +use super::{ + RendererPageWindowDocumentTask, RendererPageWindowDocumentTaskOwner, + window_document_task_source::{ + RendererPageWindowDocumentTaskRoute, RendererPageWindowDocumentTaskSender, + RendererPageWindowDocumentTaskSource, + }, +}; + +/// Host-local identity for one admitted font-loading callback. +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] +pub(crate) struct RendererPageFontLoadingTaskId(u64); + +impl RendererPageFontLoadingTaskId { + pub(crate) const fn from_raw(raw: u64) -> Self { + Self(raw) + } +} + +/// Concrete result already selected by the owning Web API algorithm. +/// +/// The kind exists for exact envelope/payload matching and diagnostics. It +/// does not decide callback presence, owner currentness, or completion policy. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum RendererPageFontLoadingTaskKind { + FontFaceSetLoading, + FontFaceSetCompletion, + FontFaceLoad, +} + +pub(crate) type RendererPageFontLoadingOwner = RendererPageWindowDocumentTaskOwner; +pub(crate) type RendererPageFontLoadingTask = + RendererPageWindowDocumentTask; +pub(super) type RendererPageFontLoadingRoute = RendererPageWindowDocumentTaskRoute< + RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, +>; +pub(crate) type RendererPageFontLoadingSender = RendererPageWindowDocumentTaskSender< + RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, +>; +pub(super) type RendererPageFontLoadingSource = RendererPageWindowDocumentTaskSource< + RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, +>; + +/// Execution fact produced after exact Window/Document authorization. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) enum PageFontLoadingTargetEffect { + CallbackInvokedForCurrentOwner, + CurrentOwnerCallbackRetired, + DiscardedStaleOwner { + current_owner: Option, + }, +} + +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(crate) struct PageFontLoadingTurnAction { + pub(crate) owner: RendererPageFontLoadingOwner, + pub(crate) task_id: RendererPageFontLoadingTaskId, + pub(crate) kind: RendererPageFontLoadingTaskKind, + pub(crate) target_effect: PageFontLoadingTargetEffect, +} + +pub(crate) type PageFontLoadingTurnOutcome = PageOwnerTurnOutcome; diff --git a/moli-renderer-v8/src/page_task_queue/main_document_runtime.rs b/moli-renderer-v8/src/page_task_queue/main_document_runtime.rs index 74451fdfd2c..4199b355e53 100644 --- a/moli-renderer-v8/src/page_task_queue/main_document_runtime.rs +++ b/moli-renderer-v8/src/page_task_queue/main_document_runtime.rs @@ -107,6 +107,19 @@ impl RendererPageMainDocumentRuntimeTask { self.action.kind() } + pub(crate) fn completion_recheck_owner(&self) -> Option { + let RendererPageMainDocumentRuntimeAction::ExecuteReadyPostParseWork(work) = &self.action + else { + return None; + }; + matches!( + work.0.as_lifecycle_work(), + Some(super::PostParseLifecycleWork::CheckMainDocumentCompletion { owner }) + if *owner == self.owner.document_owner() + ) + .then_some(self.owner) + } + pub(crate) fn into_action(self) -> RendererPageMainDocumentRuntimeAction { self.action } diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources.rs b/moli-renderer-v8/src/page_task_queue/owner_sources.rs index de7837a710c..f9dcf2af1f0 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources.rs @@ -73,6 +73,10 @@ use super::{ RendererPageFileReadingOwner, RendererPageFileReadingRoute, RendererPageFileReadingSender, RendererPageFileReadingSource, RendererPageFileReadingTask, }, + font_loading::{ + RendererPageFontLoadingOwner, RendererPageFontLoadingRoute, RendererPageFontLoadingSender, + RendererPageFontLoadingSource, RendererPageFontLoadingTask, + }, indexed_db_task::{ RendererPageIndexedDbTask, RendererPageIndexedDbTaskOwner, RendererPageIndexedDbTaskRoute, RendererPageIndexedDbTaskSender, RendererPageIndexedDbTaskSource, @@ -188,6 +192,7 @@ pub(crate) struct RendererPageOwnedTaskSources { user_interaction: RendererPageUserInteractionSource, file_reading: RendererPageFileReadingSource, misc_platform_api: RendererPageMiscPlatformApiSource, + font_loading: RendererPageFontLoadingSource, device_sensor: RendererPageDeviceSensorSource, canvas_blob_serialization: RendererPageCanvasBlobSerializationSource, navigation_and_traversal: RendererPageNavigationAndTraversalSource, @@ -228,6 +233,7 @@ pub(crate) struct RendererPageTaskProducerRoutes { user_interaction: RendererPageUserInteractionRoute, file_reading: RendererPageFileReadingRoute, misc_platform_api: RendererPageMiscPlatformApiRoute, + font_loading: RendererPageFontLoadingRoute, device_sensor: RendererPageDeviceSensorRoute, canvas_blob_serialization: RendererPageCanvasBlobSerializationRoute, navigation_and_traversal: RendererPageNavigationAndTraversalRoute, @@ -290,6 +296,10 @@ pub(crate) enum RendererPageReadyDescriptor { ready: RendererPageTaskReadyMetadata, owner: RendererPageMiscPlatformApiOwner, }, + FontLoading { + ready: RendererPageTaskReadyMetadata, + owner: RendererPageFontLoadingOwner, + }, DeviceSensor { ready: RendererPageTaskReadyMetadata, owner: RendererPageDeviceSensorOwner, @@ -416,6 +426,7 @@ impl RendererPageReadyDescriptor { | Self::UserInteraction { ready, .. } | Self::FileReading { ready, .. } | Self::MiscPlatformApi { ready, .. } + | Self::FontLoading { ready, .. } | Self::DeviceSensor { ready, .. } | Self::CanvasBlobSerialization { ready, .. } | Self::NavigationAndTraversal { ready, .. } @@ -456,6 +467,7 @@ impl RendererPageReadyDescriptor { Self::UserInteraction { .. } => RendererPageTaskSourceKind::UserInteraction, Self::FileReading { .. } => RendererPageTaskSourceKind::FileReading, Self::MiscPlatformApi { .. } => RendererPageTaskSourceKind::MiscPlatformApi, + Self::FontLoading { .. } => RendererPageTaskSourceKind::FontLoading, Self::DeviceSensor { .. } => RendererPageTaskSourceKind::DeviceSensor, Self::CanvasBlobSerialization { .. } => { RendererPageTaskSourceKind::CanvasBlobSerialization @@ -515,6 +527,7 @@ impl RendererPageReadyDescriptor { | Self::UserInteraction { ready, .. } | Self::FileReading { ready, .. } | Self::MiscPlatformApi { ready, .. } + | Self::FontLoading { ready, .. } | Self::DeviceSensor { ready, .. } | Self::CanvasBlobSerialization { ready, .. } | Self::NavigationAndTraversal { ready, .. } @@ -565,6 +578,7 @@ pub(crate) enum RendererPageTaskSourceKind { UserInteraction, FileReading, MiscPlatformApi, + FontLoading, DeviceSensor, CanvasBlobSerialization, NavigationAndTraversal, @@ -595,13 +609,14 @@ pub(crate) enum RendererPageTaskSourceKind { } impl RendererPageTaskSourceKind { - pub(crate) const ALL: [Self; 33] = [ + pub(crate) const ALL: [Self; 34] = [ Self::ActionWindow, Self::Timer, Self::DomManipulation, Self::UserInteraction, Self::FileReading, Self::MiscPlatformApi, + Self::FontLoading, Self::DeviceSensor, Self::CanvasBlobSerialization, Self::NavigationAndTraversal, @@ -646,6 +661,7 @@ pub(crate) enum RendererPageSchedulerTask { UserInteraction(RendererPageUserInteractionTask), FileReading(RendererPageFileReadingTask), MiscPlatformApi(RendererPageMiscPlatformApiTask), + FontLoading(RendererPageFontLoadingTask), DeviceSensor(RendererPageDeviceSensorTask), CanvasBlobSerialization(RendererPageCanvasBlobSerializationTask), NavigationAndTraversal(RendererPageNavigationAndTraversalTask), @@ -709,6 +725,10 @@ impl RendererPageOwnedTaskSources { owner_wake.clone(), RendererOwnerWakeSource::MiscPlatformApiTask, ); + let font_loading = RendererPageFontLoadingSource::new( + owner_wake.clone(), + RendererOwnerWakeSource::FontLoadingTask, + ); let device_sensor = RendererPageDeviceSensorSource::new( owner_wake.clone(), RendererOwnerWakeSource::DeviceSensorTask, @@ -764,6 +784,7 @@ impl RendererPageOwnedTaskSources { user_interaction: user_interaction.route(), file_reading: file_reading.route(), misc_platform_api: misc_platform_api.route(), + font_loading: font_loading.route(), device_sensor: device_sensor.route(), canvas_blob_serialization: canvas_blob_serialization.route(), navigation_and_traversal: navigation_and_traversal.route(), @@ -799,6 +820,7 @@ impl RendererPageOwnedTaskSources { user_interaction, file_reading, misc_platform_api, + font_loading, device_sensor, canvas_blob_serialization, navigation_and_traversal, @@ -842,6 +864,7 @@ impl RendererPageOwnedTaskSources { && self .misc_platform_api .route_matches(&routes.misc_platform_api) + && self.font_loading.route_matches(&routes.font_loading) && self.device_sensor.route_matches(&routes.device_sensor) && self .canvas_blob_serialization @@ -930,6 +953,7 @@ impl RendererPageOwnedTaskSources { user_interaction: self.user_interaction.route(), file_reading: self.file_reading.route(), misc_platform_api: self.misc_platform_api.route(), + font_loading: self.font_loading.route(), device_sensor: self.device_sensor.route(), canvas_blob_serialization: self.canvas_blob_serialization.route(), navigation_and_traversal: self.navigation_and_traversal.route(), @@ -998,6 +1022,15 @@ impl RendererPageOwnedTaskSources { .expect("ready miscellaneous-platform task must retain its exact owner"), } }); + let font_loading = self.font_loading.next_ready_metadata().map(|ready| { + RendererPageReadyDescriptor::FontLoading { + ready, + owner: self + .font_loading + .next_ready_owner() + .expect("ready font-loading task must retain its exact owner"), + } + }); let device_sensor = self.device_sensor.next_ready_metadata().map(|ready| { RendererPageReadyDescriptor::DeviceSensor { ready, @@ -1285,6 +1318,7 @@ impl RendererPageOwnedTaskSources { user_interaction, file_reading, misc_platform_api, + font_loading, device_sensor, canvas_blob_serialization, navigation_and_traversal, @@ -1372,6 +1406,17 @@ impl RendererPageOwnedTaskSources { ); RendererPageSchedulerTask::MiscPlatformApi(task) } + RendererPageReadyDescriptor::FontLoading { ready, .. } => { + let (actual, task) = self + .font_loading + .pop_front() + .expect("selected font-loading task must remain queued"); + assert_eq!( + actual, ready, + "selected font-loading head changed before dequeue" + ); + RendererPageSchedulerTask::FontLoading(task) + } RendererPageReadyDescriptor::DeviceSensor { ready, .. } => { let (actual, task) = self .device_sensor @@ -1708,6 +1753,7 @@ impl RendererPageOwnedTaskSources { || self.user_interaction.has_ready_task() || self.file_reading.has_ready_task() || self.misc_platform_api.has_ready_task() + || self.font_loading.has_ready_task() || self.device_sensor.has_ready_task() || self.canvas_blob_serialization.has_ready_task() || self.navigation_and_traversal.has_ready_task() @@ -1756,6 +1802,7 @@ impl RendererPageOwnedTaskSources { self.user_interaction.clear(); self.file_reading.clear(); self.misc_platform_api.clear(); + self.font_loading.clear(); self.device_sensor.clear(); self.canvas_blob_serialization.clear(); self.navigation_and_traversal.clear(); @@ -1840,6 +1887,12 @@ impl RendererPageTaskProducerRoutes { ) -> RendererPageMiscPlatformApiSender { self.misc_platform_api.sender(root_document) } + pub(crate) fn font_loading_sender( + &self, + root_document: RendererDocumentToken, + ) -> RendererPageFontLoadingSender { + self.font_loading.sender(root_document) + } pub(crate) fn device_sensor_sender( &self, root_document: RendererDocumentToken, diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs index b8dfd9f358a..0c9bf788f53 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs @@ -60,6 +60,10 @@ use crate::{ RendererPageWebCryptoTaskSender, RendererPageWindowMessageSender, RendererPageWindowMessageTaskId, }, + page_task_queue::{ + RendererPageFontLoadingSender, RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, + }, resource_ready::RendererPageTaskReadyMetadata, runtime::{RendererDocumentToken, RendererPageToken}, shared_worker_runtime::SharedWorkerClientEvent, @@ -76,15 +80,16 @@ use super::{ RendererPageDeviceSensorSource, RendererPageDomManipulationSource, RendererPageDomManipulationTask, RendererPageDynamicImportOwnerActionSender, RendererPageDynamicImportOwnerActionSource, RendererPageFileReadingSource, - RendererPageIndexedDbTaskSource, RendererPageInternalLoadingSource, - RendererPageMainDocumentRuntimeSource, RendererPageMediaElementEventSource, - RendererPageMessagePortDeliverySource, RendererPageMiscPlatformApiSource, - RendererPageModuleReactionSource, RendererPageModulepreloadStartSender, - RendererPageModulepreloadStartSource, RendererPageNavigationAndTraversalSource, - RendererPageNetworkingSource, RendererPageOwnedTaskSources, RendererPageReadyDescriptor, - RendererPageRenderingUpdateSource, RendererPageSchedulerTask, - RendererPageSharedWorkerClientEventSource, RendererPageUserInteractionSource, - RendererPageWebCryptoTaskSource, RendererPageWindowMessageSource, + RendererPageFontLoadingSource, RendererPageIndexedDbTaskSource, + RendererPageInternalLoadingSource, RendererPageMainDocumentRuntimeSource, + RendererPageMediaElementEventSource, RendererPageMessagePortDeliverySource, + RendererPageMiscPlatformApiSource, RendererPageModuleReactionSource, + RendererPageModulepreloadStartSender, RendererPageModulepreloadStartSource, + RendererPageNavigationAndTraversalSource, RendererPageNetworkingSource, + RendererPageOwnedTaskSources, RendererPageReadyDescriptor, RendererPageRenderingUpdateSource, + RendererPageSchedulerTask, RendererPageSharedWorkerClientEventSource, + RendererPageUserInteractionSource, RendererPageWebCryptoTaskSource, + RendererPageWindowMessageSource, }; use crate::page_task_queue::{ RendererPageBroadcastChannelDeliveryProducer, RendererPageBroadcastChannelDeliverySender, @@ -243,6 +248,12 @@ struct MiscPlatformApiLane { replacement_sender: RendererPageMiscPlatformApiSender, wake_rx: tokio::sync::mpsc::UnboundedReceiver, } +struct FontLoadingLane { + source: Option, + initial_sender: RendererPageFontLoadingSender, + replacement_sender: RendererPageFontLoadingSender, + wake_rx: tokio::sync::mpsc::UnboundedReceiver, +} struct DeviceSensorLane { source: Option, initial_sender: RendererPageDeviceSensorSender, @@ -1410,6 +1421,42 @@ impl MiscPlatformApiLane { .is_ok() } } +impl FontLoadingLane { + fn new() -> Self { + let (wake_tx, wake_rx) = tokio::sync::mpsc::unbounded_channel(); + let source = RendererPageFontLoadingSource::new( + RendererOwnerWakeSender::new( + wake_tx, + RendererPageToken::new_for_testing(document_token(1).page_id), + ), + RendererOwnerWakeSource::FontLoadingTask, + ); + let route = source.route(); + Self { + source: Some(source), + initial_sender: route.sender(document_token(1)), + replacement_sender: route.sender(document_token(2)), + wake_rx, + } + } + + fn enqueue_with(sender: &RendererPageFontLoadingSender, sequence: u64) -> bool { + sender + .send( + WindowDocumentTaskTarget::new( + WindowDocumentOwner::Frame(task_owner(sequence + 1_730)), + OwnerDispatchScope::Top, + ), + RendererPageFontLoadingTaskId::from_raw(sequence), + match sequence % 3 { + 0 => RendererPageFontLoadingTaskKind::FontFaceSetLoading, + 1 => RendererPageFontLoadingTaskKind::FontFaceSetCompletion, + _ => RendererPageFontLoadingTaskKind::FontFaceLoad, + }, + ) + .is_ok() + } +} impl DeviceSensorLane { fn new() -> Self { let (wake_tx, wake_rx) = tokio::sync::mpsc::unbounded_channel(); @@ -1464,6 +1511,27 @@ impl TypedPageSourceConformance for MiscPlatformApiLane { drop(self.source.take()); } } +impl TypedPageSourceConformance for FontLoadingLane { + fn enqueue_initial(&mut self, sequence: u64) -> bool { + Self::enqueue_with(&self.initial_sender, sequence) + } + + fn enqueue_replacement(&mut self, sequence: u64) -> bool { + Self::enqueue_with(&self.replacement_sender, sequence) + } + + fn pop_ready_metadata(&mut self) -> Option { + self.source.as_mut()?.pop_front().map(|(ready, _)| ready) + } + + fn take_wake(&mut self) -> Option { + self.wake_rx.try_recv().ok() + } + + fn retire_consumer(&mut self) { + drop(self.source.take()); + } +} impl TypedPageSourceConformance for DeviceSensorLane { fn enqueue_initial(&mut self, sequence: u64) -> bool { Self::enqueue_with(&self.initial_sender, sequence) @@ -2762,3 +2830,8 @@ fn unified_ready_descriptors_expose_one_fifo_head_per_typed_source() { "one Page turn must remove only the selected source head" ); } + +#[test] +fn font_loading_source_conforms_to_page_queue_contract() { + assert_fifo_replacement_and_route_retirement(FontLoadingLane::new()); +} diff --git a/moli-renderer-v8/src/page_task_queue/resource_completions.rs b/moli-renderer-v8/src/page_task_queue/resource_completions.rs index ece706275af..6f20bfa50ce 100644 --- a/moli-renderer-v8/src/page_task_queue/resource_completions.rs +++ b/moli-renderer-v8/src/page_task_queue/resource_completions.rs @@ -193,6 +193,8 @@ pub(crate) enum RendererOwnerWakeSource { /// A callback entered the exact Window/Document miscellaneous-platform /// task source. The Host-local payload owns callback Realm identity. MiscPlatformApiTask, + /// A font algorithm entered its exact Window/Document font-loading source. + FontLoadingTask, DeviceSensorTask, CanvasBlobSerializationTask, /// One exact Window/realm history traversal entered the stable HTML diff --git a/moli-renderer-v8/src/page_task_queue/senders.rs b/moli-renderer-v8/src/page_task_queue/senders.rs index c2b68d4c374..a683b312e96 100644 --- a/moli-renderer-v8/src/page_task_queue/senders.rs +++ b/moli-renderer-v8/src/page_task_queue/senders.rs @@ -26,6 +26,7 @@ use crate::page_task_queue::RendererPageChildModulepreloadEventActionSender; use crate::page_task_queue::RendererPageDedicatedWorkerClientEventSender; use crate::page_task_queue::RendererPageDeviceSensorSender; use crate::page_task_queue::RendererPageFileReadingSender; +use crate::page_task_queue::RendererPageFontLoadingSender; use crate::page_task_queue::RendererPageIndexedDbTaskSender; use crate::page_task_queue::RendererPageInternalLoadingSender; use crate::page_task_queue::RendererPageMainParserContinuationSender; @@ -77,6 +78,7 @@ pub(crate) struct RendererPageJsContextTaskSenders { user_interaction: RendererPageUserInteractionSender, file_reading: RendererPageFileReadingSender, misc_platform_api: RendererPageMiscPlatformApiSender, + font_loading: RendererPageFontLoadingSender, device_sensor: RendererPageDeviceSensorSender, canvas_blob_serialization: RendererPageCanvasBlobSerializationSender, navigation_and_traversal: RendererPageNavigationAndTraversalSender, @@ -152,6 +154,9 @@ impl RendererPageJsContextTaskSenders { pub(crate) fn misc_platform_api(&self) -> &RendererPageMiscPlatformApiSender { &self.misc_platform_api } + pub(crate) fn font_loading(&self) -> &RendererPageFontLoadingSender { + &self.font_loading + } pub(crate) fn device_sensor(&self) -> &RendererPageDeviceSensorSender { &self.device_sensor } @@ -374,6 +379,7 @@ impl PageRuntimeTaskSource { user_interaction: routes.user_interaction_sender(root_document), file_reading: routes.file_reading_sender(root_document), misc_platform_api: routes.misc_platform_api_sender(root_document), + font_loading: routes.font_loading_sender(root_document), device_sensor: routes.device_sensor_sender(root_document), canvas_blob_serialization: routes.canvas_blob_serialization_sender(root_document), navigation_and_traversal: routes.navigation_and_traversal_sender(root_document), diff --git a/moli-renderer-v8/src/runtime/mod.rs b/moli-renderer-v8/src/runtime/mod.rs index 095ea8d5107..4551a1109dc 100644 --- a/moli-renderer-v8/src/runtime/mod.rs +++ b/moli-renderer-v8/src/runtime/mod.rs @@ -146,6 +146,7 @@ pub(crate) use self::page_vm::AuthorizedCurrentPageDeviceSensorTask; pub(crate) use self::page_vm::AuthorizedCurrentPageElementToggleEvent; pub(crate) use self::page_vm::AuthorizedCurrentPageFileEntryFileCallback; pub(crate) use self::page_vm::AuthorizedCurrentPageFileReadingTask; +pub(crate) use self::page_vm::AuthorizedCurrentPageFontLoadingTask; pub(crate) use self::page_vm::AuthorizedCurrentPageFormNavigation; pub(crate) use self::page_vm::AuthorizedCurrentPageHashChangeDelivery; pub(crate) use self::page_vm::AuthorizedCurrentPageHistoryTraversal; diff --git a/moli-renderer-v8/src/runtime/owner.rs b/moli-renderer-v8/src/runtime/owner.rs index ab1c2618f30..6cb902b4d0c 100644 --- a/moli-renderer-v8/src/runtime/owner.rs +++ b/moli-renderer-v8/src/runtime/owner.rs @@ -1109,6 +1109,7 @@ fn page_turn_trigger_log_label(trigger: PageTurnTrigger) -> &'static str { Some(RendererOwnerWakeSource::UserInteractionTask) => "user-interaction-task-wake", Some(RendererOwnerWakeSource::FileReadingTask) => "file-reading-task-wake", Some(RendererOwnerWakeSource::MiscPlatformApiTask) => "misc-platform-api-task-wake", + Some(RendererOwnerWakeSource::FontLoadingTask) => "font-loading-task-wake", Some(RendererOwnerWakeSource::DeviceSensorTask) => "device-sensor-task-wake", Some(RendererOwnerWakeSource::CanvasBlobSerializationTask) => { "canvas-blob-serialization-task-wake" diff --git a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs index 9d9fe2f195a..ba1ec3dd59c 100644 --- a/moli-renderer-v8/src/runtime/owner_local_store/bound.rs +++ b/moli-renderer-v8/src/runtime/owner_local_store/bound.rs @@ -967,6 +967,10 @@ pub(in crate::runtime) async fn advance_page_owner_one_turn_via_local_task( ) => Some(task.owner), _ => None, }; + let main_completion_recheck_owner = match &task { + RendererPageSchedulerTask::MainDocumentRuntime(task) => task.completion_recheck_owner(), + _ => None, + }; let replacement_lifecycle_snapshot = entry .page_vm() .document_replacement_lifecycle_action_snapshot(); @@ -1000,16 +1004,21 @@ pub(in crate::runtime) async fn advance_page_owner_one_turn_via_local_task( }; if application.is_ok() - && main_lifecycle_owner.is_some_and(|owner| { + && (main_lifecycle_owner.is_some_and(|owner| { owner.root_document == entry.page_vm().document_lifecycle.identity().document && entry.page_vm().vm().current_main_document_task_owner() == Some(owner.body.owner()) - }) + }) || main_completion_recheck_owner.is_some_and(|owner| { + owner.root_document() == entry.page_vm().document_lifecycle.identity().document + && entry.page_vm().vm().current_main_document_task_owner() == Some(owner.document_owner()) + && entry.page_vm().vm().check_main_document_completion(owner.document_owner()) == Some(true) + })) { let (_, pending) = entry.page_vm_and_document_lifecycle_turn_mut(); if let Some(pending) = pending { - // Resume the exact driver to consume its receipt. An - // executed event publishes the reached stage before other - // sources run; a blocked load returns to its prerequisites. + // Resume an exact event receipt or a completion recheck + // that just made the parked lifecycle ready. Admit its + // next DOM task before ordinary sources can overtake it; + // that task still revalidates its owner and load delays. pending.owner_turn_is_runnable = true; } } diff --git a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs index d0ecda65457..a316aefda38 100644 --- a/moli-renderer-v8/src/runtime/page_turn_scheduler.rs +++ b/moli-renderer-v8/src/runtime/page_turn_scheduler.rs @@ -347,6 +347,26 @@ impl PageTurnScheduler { } else { oldest }; + // Font loading has its own task source. Prefer a ready posted message + // over deferred font work, so message protocols can finish their + // current exchange before font completion callbacks. This is a Page + // scheduling policy, not a specified cross-source ordering. Apply the + // ordinary bounded-run fairness below to prevent message starvation + // of font work, and never inspect or reorder either source's payloads. + let oldest = if matches!(oldest, RendererPageReadyDescriptor::FontLoading { .. }) { + descriptors + .iter() + .copied() + .find(|descriptor| { + matches!( + descriptor, + RendererPageReadyDescriptor::WindowMessage { .. } + ) + }) + .unwrap_or(oldest) + } else { + oldest + }; let oldest_source = oldest.source_kind(); let should_apply_fairness = self.arbitration.last_selected_source == Some(oldest_source) && self.arbitration.consecutive_from_source >= MAX_CONSECUTIVE_PAGE_TASKS_PER_SOURCE @@ -503,16 +523,17 @@ mod tests { RendererPageChildRealmMaterializationTarget, RendererPageDedicatedWorkerClientEventOwner, RendererPageDeviceSensorOwner, RendererPageDomManipulationOwner, RendererPageFileReadingOwner, - RendererPageHistoryTraversalOwner, RendererPageHistoryTraversalTaskId, - RendererPageHistoryTraversalTaskKind, RendererPageIndexedDbTaskOwner, - RendererPageMediaElementEventOwner, RendererPageMessagePortDeliveryOwner, - RendererPageMiscPlatformApiOwner, RendererPageNavigationAndTraversalHead, - RendererPageNetworkingOwner, RendererPageOpfsTaskId, RendererPageOpfsTaskOwner, - RendererPageRenderingUpdateHead, RendererPageRenderingUpdateOwner, - RendererPageRenderingUpdateTaskId, RendererPageRenderingUpdateTaskKind, - RendererPageSharedWorkerClientEventOwner, RendererPageUserInteractionOwner, - RendererPageWebCryptoTaskId, RendererPageWebCryptoTaskOwner, - RendererPageWebLocksTaskId, RendererPageWebLocksTaskOwner, RendererPageWebSocketOwner, + RendererPageFontLoadingOwner, RendererPageHistoryTraversalOwner, + RendererPageHistoryTraversalTaskId, RendererPageHistoryTraversalTaskKind, + RendererPageIndexedDbTaskOwner, RendererPageMediaElementEventOwner, + RendererPageMessagePortDeliveryOwner, RendererPageMiscPlatformApiOwner, + RendererPageNavigationAndTraversalHead, RendererPageNetworkingOwner, + RendererPageOpfsTaskId, RendererPageOpfsTaskOwner, RendererPageRenderingUpdateHead, + RendererPageRenderingUpdateOwner, RendererPageRenderingUpdateTaskId, + RendererPageRenderingUpdateTaskKind, RendererPageSharedWorkerClientEventOwner, + RendererPageUserInteractionOwner, RendererPageWebCryptoTaskId, + RendererPageWebCryptoTaskOwner, RendererPageWebLocksTaskId, + RendererPageWebLocksTaskOwner, RendererPageWebSocketOwner, RendererPageWebSocketReadiness, RendererPageWindowMessageOwner, RendererPageWindowMessageTaskId, }, @@ -604,6 +625,22 @@ mod tests { ), } } + fn font_loading_descriptor(ready_at: Instant, order: u64) -> RendererPageReadyDescriptor { + RendererPageReadyDescriptor::FontLoading { + ready: ready_metadata(ready_at, order), + owner: RendererPageFontLoadingOwner::new( + RendererDocumentToken::new_for_testing(crate::PageId::new_for_testing(1), 1), + WindowDocumentTaskTarget::new( + WindowDocumentOwner::Frame(FrameDocumentTaskOwner::new( + FrameSchedulerLaneId(order), + LocalWindowId(order + 1), + DocumentId(order + 2), + )), + OwnerDispatchScope::Top, + ), + ), + } + } fn device_sensor_descriptor(ready_at: Instant, order: u64) -> RendererPageReadyDescriptor { RendererPageReadyDescriptor::DeviceSensor { ready: ready_metadata(ready_at, order), @@ -1113,6 +1150,9 @@ mod tests { RendererPageTaskSourceKind::MiscPlatformApi => { misc_platform_api_descriptor(runnable_since, order) } + RendererPageTaskSourceKind::FontLoading => { + font_loading_descriptor(runnable_since, order) + } RendererPageTaskSourceKind::DeviceSensor => { device_sensor_descriptor(runnable_since, order) } @@ -1661,7 +1701,7 @@ mod tests { } #[test] - fn oldest_runnable_head_can_win_from_every_page_source() { + fn oldest_runnable_head_respects_posted_message_over_font_policy() { let base = Instant::now(); for expected in RendererPageTaskSourceKind::ALL { let descriptors = @@ -1681,12 +1721,39 @@ mod tests { .expect("each source matrix must retain a runnable head"); assert_eq!( selected.source_kind(), - expected, - "the oldest runnable head from {expected:?} must be selectable" + if expected == RendererPageTaskSourceKind::FontLoading { + RendererPageTaskSourceKind::WindowMessage + } else { + expected + }, + "the oldest runnable head from {expected:?} must respect source policy" ); } } + #[test] + fn posted_messages_precede_font_work_with_bounded_fairness() { + let mut scheduler = PageTurnScheduler::new(()); + let base = Instant::now(); + let font = font_loading_descriptor(base, 1); + let message = window_message_descriptor(base + std::time::Duration::from_millis(1), 2); + for _ in 0..MAX_CONSECUTIVE_PAGE_TASKS_PER_SOURCE { + assert_eq!( + scheduler.select_ready_descriptor([font, message]), + Some(message) + ); + } + assert_eq!( + scheduler.select_ready_descriptor([font, message]), + Some(font) + ); + assert_eq!(scheduler.select_ready_descriptor([font]), Some(font)); + assert_eq!( + scheduler.select_ready_descriptor([font, message]), + Some(message) + ); + } + #[test] fn fairness_bound_rotates_across_all_waiting_sources() { let mut scheduler = PageTurnScheduler::new(()); diff --git a/moli-renderer-v8/src/runtime/page_vm/mod.rs b/moli-renderer-v8/src/runtime/page_vm/mod.rs index 268f51690b0..597e669a764 100644 --- a/moli-renderer-v8/src/runtime/page_vm/mod.rs +++ b/moli-renderer-v8/src/runtime/page_vm/mod.rs @@ -126,6 +126,7 @@ pub(crate) use page_webtransport::AuthorizedCurrentPageWebTransport; mod page_webrtc; pub(crate) use page_webrtc::AuthorizedCurrentPageWebRtc; mod page_device_sensor; +mod page_font_loading; #[cfg(test)] mod page_media_element_event_body_test_support; mod page_message_port_delivery; @@ -242,6 +243,7 @@ pub(crate) use page_dynamic_import_owner_action::AuthorizedCurrentChildDynamicIm pub(crate) use page_element_toggle_event::AuthorizedCurrentPageElementToggleEvent; pub(crate) use page_file_entry_file_callback::AuthorizedCurrentPageFileEntryFileCallback; pub(crate) use page_file_reading::AuthorizedCurrentPageFileReadingTask; +pub(crate) use page_font_loading::AuthorizedCurrentPageFontLoadingTask; pub(crate) use page_form_navigation::AuthorizedCurrentPageFormNavigation; pub(crate) use page_hash_change_delivery::AuthorizedCurrentPageHashChangeDelivery; pub(crate) use page_history_traversal::AuthorizedCurrentPageHistoryTraversal; diff --git a/moli-renderer-v8/src/runtime/page_vm/page_font_loading.rs b/moli-renderer-v8/src/runtime/page_vm/page_font_loading.rs new file mode 100644 index 00000000000..1fb391f8af5 --- /dev/null +++ b/moli-renderer-v8/src/runtime/page_vm/page_font_loading.rs @@ -0,0 +1,80 @@ +use crate::page_task_queue::{ + PageFontLoadingTargetEffect, PageFontLoadingTurnAction, PageFontLoadingTurnOutcome, + RendererPageFontLoadingOwner, RendererPageFontLoadingTask, RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, +}; + +use super::{ + AuthorizedCurrentWindowDocumentTask, IntoPageTaskCompletion, PageTaskCompletion, PageVm, +}; + +impl IntoPageTaskCompletion for PageFontLoadingTurnAction { + fn into_page_task_completion(self) -> PageTaskCompletion { + match self.target_effect { + PageFontLoadingTargetEffect::CallbackInvokedForCurrentOwner => { + PageTaskCompletion::CallbackCompletion + } + PageFontLoadingTargetEffect::CurrentOwnerCallbackRetired => { + PageTaskCompletion::CheckpointOnly + } + PageFontLoadingTargetEffect::DiscardedStaleOwner { .. } => { + PageTaskCompletion::NoCompletion + } + } + } +} + +pub(crate) type AuthorizedCurrentPageFontLoadingTask = + AuthorizedCurrentWindowDocumentTask; + +impl PageVm { + fn current_page_font_loading_owner( + &self, + task_id: RendererPageFontLoadingTaskId, + ) -> Option<( + RendererPageFontLoadingOwner, + RendererPageFontLoadingTaskKind, + )> { + self.vm().current_pending_font_loading_owner( + task_id, + self.document_lifecycle.identity().document, + ) + } + + pub(in crate::runtime) fn apply_selected_page_font_loading_turn( + &mut self, + task: RendererPageFontLoadingTask, + ) -> anyhow::Result { + let owner = task.owner(); + let task_id = task.task_id(); + let kind = task.kind(); + let current = self.current_page_font_loading_owner(task_id); + let target_effect = + match self.authorize_current_window_document_task(task, owner, kind, current) { + Ok(authorization) => self + .vm_mut() + .apply_current_font_loading_task_body(authorization)?, + Err(stale) => { + if stale.may_discard_local_payload() { + self.vm_mut().discard_stale_font_loading_task(task_id); + } + let current_owner = stale.current_owner(); + tracing::debug!( + ?owner, + ?current_owner, + ?task_id, + ?kind, + "discarded stale exact-Document font-loading task" + ); + PageFontLoadingTargetEffect::DiscardedStaleOwner { current_owner } + } + }; + let action = PageFontLoadingTurnAction { + owner, + task_id, + kind, + target_effect, + }; + Ok(PageFontLoadingTurnOutcome::new(action)) + } +} diff --git a/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs b/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs index d26f8597737..f728ab793cc 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_selected_task_test_harness.rs @@ -57,6 +57,7 @@ pub(crate) enum PageSelectedTaskTestSelector { DynamicImportOwnerAction, FileReading, MiscPlatformApi, + FontLoading, ContentSecurityPolicyViolation, DeviceSensor, CanvasBlobSerialization, @@ -307,6 +308,9 @@ impl PageSelectedTaskTestSelector { RendererPageReadyDescriptor::MiscPlatformApi { .. } ) } + Self::FontLoading => { + matches!(descriptor, RendererPageReadyDescriptor::FontLoading { .. }) + } Self::DeviceSensor => { matches!(descriptor, RendererPageReadyDescriptor::DeviceSensor { .. }) } @@ -428,6 +432,7 @@ impl PageSelectedTaskTestSelector { ) | (Self::FileReading, RendererPageSchedulerTask::FileReading(_)) | (Self::MiscPlatformApi, RendererPageSchedulerTask::MiscPlatformApi(_)) + | (Self::FontLoading, RendererPageSchedulerTask::FontLoading(_)) | (Self::DeviceSensor, RendererPageSchedulerTask::DeviceSensor(_)) | ( Self::CanvasBlobSerialization, diff --git a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs index 6e5feab2761..e18f5805c4a 100644 --- a/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs +++ b/moli-renderer-v8/src/runtime/page_vm/page_typed_immediate_source.rs @@ -137,6 +137,7 @@ impl PageVm { | RendererPageReadyDescriptor::UserInteraction { .. } | RendererPageReadyDescriptor::FileReading { .. } | RendererPageReadyDescriptor::MiscPlatformApi { .. } + | RendererPageReadyDescriptor::FontLoading { .. } | RendererPageReadyDescriptor::DeviceSensor { .. } | RendererPageReadyDescriptor::CanvasBlobSerialization { .. } | RendererPageReadyDescriptor::DedicatedWorkerClientEvent { .. } diff --git a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs index 29cb5e59ead..a288c03fec4 100644 --- a/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs +++ b/moli-renderer-v8/src/runtime/page_vm/selected_page_task.rs @@ -56,6 +56,15 @@ impl PageVm { .await?; Ok(()) } + RendererPageSchedulerTask::FontLoading(task) => { + let outcome = self.apply_selected_page_font_loading_turn(task)?; + self.finish_selected_page_task_completion( + outcome.action.into_page_task_completion(), + loader, + ) + .await?; + Ok(()) + } RendererPageSchedulerTask::DeviceSensor(task) => { let outcome = self.apply_selected_page_device_sensor_turn(task)?; self.finish_selected_page_task_completion( diff --git a/moli-renderer-v8/src/runtime/page_vm/test_support.rs b/moli-renderer-v8/src/runtime/page_vm/test_support.rs index 1dfabaac320..ab680280aa5 100644 --- a/moli-renderer-v8/src/runtime/page_vm/test_support.rs +++ b/moli-renderer-v8/src/runtime/page_vm/test_support.rs @@ -108,6 +108,17 @@ impl PageVmTaskExecutorTestHarness { .await } + pub(crate) fn has_ready_font_loading_task_for_test(&self) -> bool { + self.page_vm + .page_task_executor_sources_for_test() + .has_scheduler_task_for_executor_test(|descriptor| { + matches!( + descriptor, + crate::page_task_queue::RendererPageReadyDescriptor::FontLoading { .. } + ) + }) + } + pub(crate) fn has_ready_dom_manipulation_family_for_test( &self, family: super::PageDomManipulationTestFamily, diff --git a/moli-renderer-v8/src/runtime/page_vm/tests/child_host_load.rs b/moli-renderer-v8/src/runtime/page_vm/tests/child_host_load.rs index a91561a94e6..146b8b59176 100644 --- a/moli-renderer-v8/src/runtime/page_vm/tests/child_host_load.rs +++ b/moli-renderer-v8/src/runtime/page_vm/tests/child_host_load.rs @@ -51,7 +51,10 @@ document.body.append(frame); .await; for _ in 0..8 { if !page_vm - .run_one_due_timer_selected_task_for_test(&loader) + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::FontLoading, + &loader, + ) .await? { break; @@ -79,7 +82,10 @@ document.body.append(frame); } for _ in 0..8 { if !page_vm - .run_one_due_timer_selected_task_for_test(&loader) + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::FontLoading, + &loader, + ) .await? { break; @@ -102,7 +108,10 @@ document.body.append(frame); ); for _ in 0..8 { if !page_vm - .run_one_due_timer_selected_task_for_test(&loader) + .run_exact_selected_page_task_for_test( + PageSelectedTaskTestSelector::FontLoading, + &loader, + ) .await? { break; diff --git a/moli-renderer-v8/src/script_vm.rs b/moli-renderer-v8/src/script_vm.rs index a18eea6fa3b..33268e4ab42 100644 --- a/moli-renderer-v8/src/script_vm.rs +++ b/moli-renderer-v8/src/script_vm.rs @@ -731,6 +731,7 @@ pub(crate) use inspector::dispatch_inspector_main_owner_wake; mod canvas_blob_serialization; mod device_sensor; mod document_context_transition; +mod font_loading_tasks; mod initial_window_document; mod isolated_worlds; mod main_document_lifecycle; diff --git a/moli-renderer-v8/src/script_vm/font_loading_tasks.rs b/moli-renderer-v8/src/script_vm/font_loading_tasks.rs new file mode 100644 index 00000000000..75ac180b5c7 --- /dev/null +++ b/moli-renderer-v8/src/script_vm/font_loading_tasks.rs @@ -0,0 +1,108 @@ +use anyhow::{Result, anyhow}; + +use super::ScriptVm; +use crate::{ + page_task_queue::{ + PageFontLoadingTargetEffect, RendererPageFontLoadingOwner, RendererPageFontLoadingTaskId, + RendererPageFontLoadingTaskKind, + }, + runtime::{AuthorizedCurrentPageFontLoadingTask, RendererDocumentToken}, +}; + +impl ScriptVm { + pub(crate) fn current_pending_font_loading_owner( + &self, + task_id: RendererPageFontLoadingTaskId, + root_document: RendererDocumentToken, + ) -> Option<( + RendererPageFontLoadingOwner, + RendererPageFontLoadingTaskKind, + )> { + let (target, kind) = self + ._context_host + .borrow() + .current_pending_font_loading_task(task_id)?; + Some(( + RendererPageFontLoadingOwner::new(root_document, target), + kind, + )) + } + + /// Execute one already-authorized font-loading callback body. + /// + /// The selected Page-task dispatcher, not this body, owns checkpoint and + /// runtime follow-up. + pub(crate) fn apply_current_font_loading_task_body( + &mut self, + authorization: AuthorizedCurrentPageFontLoadingTask, + ) -> Result { + let task = authorization.into_task(); + let owner = task.owner(); + let task_id = task.task_id(); + let kind = task.kind(); + let Some(callback) = self + ._context_host + .borrow_mut() + .take_pending_font_loading_task_for_exact_target(task_id, owner.target(), kind) + else { + return Err(anyhow!( + "authorized font-loading task lost its exact callback payload" + )); + }; + self.with_default_context_scope(|scope, host_ptr| { + Ok( + unsafe { &mut *host_ptr }.dispatch_authorized_font_loading_task( + scope, + host_ptr, + owner.target(), + callback, + ), + ) + }) + } + + pub(crate) fn discard_stale_font_loading_task( + &mut self, + task_id: RendererPageFontLoadingTaskId, + ) -> bool { + self._context_host + .borrow_mut() + .discard_pending_font_loading_task(task_id) + } +} + +// Standalone domain fixtures apply bodies and checkpoints separately. They do +// not provide Page arbitration or authorize foreign/replaced Page namespaces. +#[cfg(test)] +impl ScriptVm { + pub(crate) fn apply_next_font_loading_body_for_test(&mut self) -> Result { + use crate::page_task_queue::{RendererPageReadyDescriptor, RendererPageSchedulerTask}; + let residence = self + ._page_task_residence_for_executor_test + .as_ref() + .expect("font body fixture must retain its production Page source"); + let root_document = residence.root_document(); + let Some(task) = residence + .task_sources() + .take_scheduler_task_for_executor_test(|descriptor| { + matches!(descriptor, RendererPageReadyDescriptor::FontLoading { .. }) + }) + else { + return Ok(false); + }; + let RendererPageSchedulerTask::FontLoading(task) = task else { + unreachable!("font descriptor must dequeue a font task"); + }; + let owner = task.owner(); + anyhow::ensure!( + owner.root_document() == root_document + && self.current_pending_font_loading_owner(task.task_id(), root_document) + == Some((owner, task.kind())), + "body-only font fixture cannot authorize stale or foreign-Page tasks" + ); + self.apply_current_font_loading_task_body( + AuthorizedCurrentPageFontLoadingTask::new_for_executor_test(task), + )?; + Ok(true) + } +} diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/automatic.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/automatic.rs index d48eaf0ba80..ef4695067c4 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/automatic.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/automatic.rs @@ -14,6 +14,49 @@ fn automatic_vm() -> ( (vm, completions) } +fn automatic_page_vm() -> ( + crate::runtime::PageVmTaskExecutorTestHarness, + crate::network::ResourceRequestClientOwner, +) { + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + loader.set_optional_resource_fetch_mask(OptionalResourceFetchMask::FONT); + let dom=DomHost::from_dom(HtmlParser::SCRIPTING_ENABLED.parse( + Url::parse("https://font-selection-order.test/").unwrap(), + "AAAA".to_owned(), + )); + let mut page = crate::runtime::PageVmTaskExecutorTestHarness::new_with_dom_host(dom, &loader); + finish_main_document_load_for_test(&mut page); + page.set_layout_policy(moli_page_types::LayoutPolicy::OnDemand); + (page, loader) +} + +async fn complete_page_font_resources( + page: &mut crate::runtime::PageVmTaskExecutorTestHarness, + loader: &ResourceRequestClient, +) { + for _ in 0..32 { + if page + .run_one_exact_selected_page_task_executor_turn( + crate::runtime::PageSelectedTaskTestSelector::FontLoading, + loader, + ) + .await + .unwrap() + { + continue; + } + if page + .run_one_page_resource_completion_selected_task_executor_turn(loader) + .await + .unwrap() + { + continue; + } + return; + } + panic!("font Page tasks did not become idle"); +} + #[test] fn automatic_font_requests_follow_the_document_resource_policy() { let (_, wide) = order_font_data(); @@ -310,18 +353,21 @@ fn resources_match_capabilities_before_unicode_ranges() { ); } -#[test] -fn font_resource_requests_run_as_window_owned_tasks() { - let (mut vm, mut completions) = automatic_vm(); +#[tokio::test] +async fn font_resource_requests_run_as_window_owned_tasks() { + let (mut vm, loader) = automatic_page_vm(); let (_, wide) = order_font_data(); vm.eval(&format!("globalThis.face=new FontFace('OrderFace','url(data:font/ttf;base64,{wide})');document.fonts.add(face)")).unwrap(); vm.reconcile_document_font_resources(); assert!( - vm.has_ready_timeout(), + vm.has_ready_font_loading_task_for_test(), "resource processing must schedule a load without another JS read" ); - complete_local_font_resources(&mut vm, &mut completions); - refresh_layout_for_test(&mut vm); + complete_page_font_resources(&mut vm, &loader).await; + assert!( + vm.refresh_layout_snapshot_for_test(moli_layout::LayoutViewport::new(800, 600, 1.0)) + .unwrap() + ); assert_eq!( vm.eval("[face.status,probe.getBoundingClientRect().width].join(',')") .unwrap(), @@ -659,10 +705,10 @@ fn font_set_ready_waits_for_all_synchronous_fallback_failures() { } } -#[test] -fn automatic_fonts_retired_creation_window_does_not_block_live_fallback() { +#[tokio::test] +async fn automatic_fonts_retired_creation_window_does_not_block_live_fallback() { for retirement in ["before-demand", "after-queue", "live"] { - let (mut vm, mut completions) = automatic_vm(); + let (mut vm, loader) = automatic_page_vm(); vm.set_layout_policy(moli_page_types::LayoutPolicy::Mock); let (_, wide) = order_font_data(); vm.eval(&format!( @@ -679,7 +725,7 @@ fn automatic_fonts_retired_creation_window_does_not_block_live_fallback() { if retirement == "after-queue" { vm.eval("probe.style.fontFamily='RetiredFace'").unwrap(); vm.reconcile_document_font_resources(); - assert!(vm.has_ready_timeout()); + assert!(vm.has_ready_font_loading_task_for_test()); } if retirement != "live" { vm.eval("frame.remove()").unwrap(); @@ -689,7 +735,7 @@ fn automatic_fonts_retired_creation_window_does_not_block_live_fallback() { // synchronously start a stranded queued face and mask this failure. for _ in 0..3 { vm.prime_document_lifecycle_processing_and_record_stylesheet_network_results(); - complete_local_font_resources(&mut vm, &mut completions); + complete_page_font_resources(&mut vm, &loader).await; } assert_eq!( vm.eval("[retired.status,fallback.status].join(',')") diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs index 2c6c5284190..3f15462d6d4 100644 --- a/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs +++ b/moli-renderer-v8/src/script_vm/tests/browser_api/fonts/readiness.rs @@ -735,6 +735,70 @@ async fn font_set_finish_task_rechecks_fonts_started_before_dispatch() { ); } +#[tokio::test] +async fn font_loading_uses_its_own_source_and_task_end_checkpoint() { + use crate::runtime::PageSelectedTaskTestSelector; + let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); + let mut page = + new_storage_page_task_executor_test_vm_with_loader("https://font-source.test/", &loader); + finish_main_document_load_for_test(&mut page); + page.eval( + r#" + globalThis.fontTrace = []; + const fonts = document.fonts; + fonts.addEventListener('loading', () => { + fontTrace.push('loading'); + queueMicrotask(() => fontTrace.push('loading-microtask')); + }); + fonts.addEventListener('loadingdone', () => fontTrace.push('done')); + fonts.addEventListener('loadingerror', () => fontTrace.push('error')); + const face = new FontFace('Missing', 'local("MoliMissingFontSource-93465")'); + fonts.add(face); + face.load().catch(() => {}); + fonts.ready.then(() => fontTrace.push('ready')); + "#, + ) + .unwrap(); + assert!( + !page.has_ready_timeout(), + "font work must not enter the author timer heap" + ); + assert_eq!(page.eval("fontTrace.join('|')").unwrap(), ""); + assert!( + page.run_one_exact_selected_page_task_executor_turn( + PageSelectedTaskTestSelector::FontLoading, + &loader, + ) + .await + .unwrap() + ); + assert_eq!( + page.eval("fontTrace.join('|')").unwrap(), + "loading|loading-microtask" + ); + assert!( + page.run_one_exact_selected_page_task_executor_turn( + PageSelectedTaskTestSelector::FontLoading, + &loader, + ) + .await + .unwrap() + ); + assert_eq!( + page.eval("fontTrace.join('|')").unwrap(), + "loading|loading-microtask|done|error|ready" + ); + assert!( + !page + .run_one_exact_selected_page_task_executor_turn( + PageSelectedTaskTestSelector::FontLoading, + &loader, + ) + .await + .unwrap() + ); +} + #[tokio::test] async fn font_loading_tasks_preserve_order_and_reentrant_cycle_promises() { let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap(); diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs index a0cc6591be5..f983aee2261 100644 --- a/moli-renderer-v8/src/script_vm/tests/mod.rs +++ b/moli-renderer-v8/src/script_vm/tests/mod.rs @@ -632,10 +632,10 @@ fn refresh_layout_for_test(vm: &mut StandaloneScriptVmHarness) { // separately by the font event ordering and Window retirement tests. fn run_font_tasks(vm: &mut ScriptVm) { for _ in 0..16 { - if !vm.has_ready_timeout() { + if !vm.apply_next_font_loading_body_for_test().unwrap() { return; } - assert!(vm.run_next_timeout_for_test().unwrap().consumed_heap_head()); + vm.perform_owner_lane_task_microtask_checkpoints().unwrap(); } panic!("font loading tasks did not become idle"); } diff --git a/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs b/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs index 1aff6203aa7..0e3b60a27ad 100644 --- a/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs +++ b/moli-renderer-v8/src/webidl_callback_source_boundary_tests.rs @@ -45,6 +45,11 @@ const RAW_GLOBAL_FUNCTION_ALLOWLIST: &[(&str, usize)] = &[ ("abort_signal_route.rs", 1), ("custom_elements/construction.rs", 1), ("host/timers.rs", 1), + // Font Loading retains only the native algorithm functions created by + // run_font_face_set_task and run_requested_font_load. Author loading event + // listeners stay in the typed EventTarget registry; the Page source owns + // exact Window/Document/Realm retirement and the task-end checkpoint. + ("native_bridge/context_host/font_loading_tasks.rs", 1), ("native_bridge/history_queue.rs", 3), ("script_vm/frame_script_jobs.rs", 3), ("worker/timer_callback.rs", 1),