From 824b56fc4c8633624427d7e9dbc331ff3bfd1752 Mon Sep 17 00:00:00 2001 From: ldm0 Date: Sat, 7 Nov 2026 18:20:54 +0800 Subject: [PATCH] fix(fonts): dispatch Window font callbacks on their task source Route FontFaceSet events and CSS font requests through an exact Window/Document task source instead of the author timer heap. Prefer ready posted messages over font work while retaining bounded source fairness, and resume the current document lifecycle when its completion recheck becomes ready. Cover source FIFO and retirement, message fairness, and the font event task-end checkpoint. --- moli-core/tests/web_apis.rs | 5 + .../css_fontface_runtime/events.rs | 11 +- .../css_fontface_runtime/loading.rs | 6 +- .../src/native_bridge/context_host/core.rs | 12 ++ .../context_host/font_loading_tasks.rs | 143 ++++++++++++++++++ .../src/native_bridge/context_host/mod.rs | 2 + .../context_host/runtime_observable.rs | 1 + moli-renderer-v8/src/page_task_queue.rs | 6 + .../src/page_task_queue/font_loading.rs | 73 +++++++++ .../page_task_queue/main_document_runtime.rs | 13 ++ .../src/page_task_queue/owner_sources.rs | 55 ++++++- .../owner_sources/conformance_tests.rs | 91 +++++++++-- .../page_task_queue/resource_completions.rs | 2 + .../src/page_task_queue/senders.rs | 6 + moli-renderer-v8/src/runtime/mod.rs | 1 + moli-renderer-v8/src/runtime/owner.rs | 1 + .../src/runtime/owner_local_store/bound.rs | 19 ++- .../src/runtime/page_turn_scheduler.rs | 93 ++++++++++-- moli-renderer-v8/src/runtime/page_vm/mod.rs | 2 + .../src/runtime/page_vm/page_font_loading.rs | 80 ++++++++++ .../page_selected_task_test_harness.rs | 5 + .../page_vm/page_typed_immediate_source.rs | 1 + .../src/runtime/page_vm/selected_page_task.rs | 9 ++ .../src/runtime/page_vm/test_support.rs | 11 ++ .../runtime/page_vm/tests/child_host_load.rs | 15 +- moli-renderer-v8/src/script_vm.rs | 1 + .../src/script_vm/font_loading_tasks.rs | 108 +++++++++++++ .../tests/browser_api/fonts/automatic.rs | 68 +++++++-- .../tests/browser_api/fonts/readiness.rs | 64 ++++++++ moli-renderer-v8/src/script_vm/tests/mod.rs | 4 +- .../webidl_callback_source_boundary_tests.rs | 5 + 31 files changed, 865 insertions(+), 48 deletions(-) create mode 100644 moli-renderer-v8/src/native_bridge/context_host/font_loading_tasks.rs create mode 100644 moli-renderer-v8/src/page_task_queue/font_loading.rs create mode 100644 moli-renderer-v8/src/runtime/page_vm/page_font_loading.rs create mode 100644 moli-renderer-v8/src/script_vm/font_loading_tasks.rs 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),