mirror of
https://github.com/lexmount/moli.git
synced 2026-11-22 00:02:21 +00:00
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.
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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<v8::Context>,
|
||||
callback: v8::Global<v8::Function>,
|
||||
}
|
||||
|
||||
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<FontLoadingCallback> {
|
||||
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
|
||||
}
|
||||
}
|
||||
@@ -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<PendingTextControlChangeCommit>,
|
||||
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,
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<RendererPageFontLoadingTaskId, RendererPageFontLoadingTaskKind>;
|
||||
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<RendererPageFontLoadingOwner>,
|
||||
},
|
||||
}
|
||||
|
||||
#[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<PageFontLoadingTurnAction>;
|
||||
@@ -107,6 +107,19 @@ impl RendererPageMainDocumentRuntimeTask {
|
||||
self.action.kind()
|
||||
}
|
||||
|
||||
pub(crate) fn completion_recheck_owner(&self) -> Option<RendererPageMainDocumentRuntimeOwner> {
|
||||
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
|
||||
}
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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<RendererOwnerWake>,
|
||||
}
|
||||
struct FontLoadingLane {
|
||||
source: Option<RendererPageFontLoadingSource>,
|
||||
initial_sender: RendererPageFontLoadingSender,
|
||||
replacement_sender: RendererPageFontLoadingSender,
|
||||
wake_rx: tokio::sync::mpsc::UnboundedReceiver<RendererOwnerWake>,
|
||||
}
|
||||
struct DeviceSensorLane {
|
||||
source: Option<RendererPageDeviceSensorSource>,
|
||||
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<RendererPageTaskReadyMetadata> {
|
||||
self.source.as_mut()?.pop_front().map(|(ready, _)| ready)
|
||||
}
|
||||
|
||||
fn take_wake(&mut self) -> Option<RendererOwnerWake> {
|
||||
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());
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -347,6 +347,26 @@ impl<Entry> PageTurnScheduler<Entry> {
|
||||
} 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(());
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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<RendererPageFontLoadingTask>;
|
||||
|
||||
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<PageFontLoadingTurnOutcome> {
|
||||
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))
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
|
||||
@@ -137,6 +137,7 @@ impl PageVm {
|
||||
| RendererPageReadyDescriptor::UserInteraction { .. }
|
||||
| RendererPageReadyDescriptor::FileReading { .. }
|
||||
| RendererPageReadyDescriptor::MiscPlatformApi { .. }
|
||||
| RendererPageReadyDescriptor::FontLoading { .. }
|
||||
| RendererPageReadyDescriptor::DeviceSensor { .. }
|
||||
| RendererPageReadyDescriptor::CanvasBlobSerialization { .. }
|
||||
| RendererPageReadyDescriptor::DedicatedWorkerClientEvent { .. }
|
||||
|
||||
@@ -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(
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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<PageFontLoadingTargetEffect> {
|
||||
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<bool> {
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -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(),
|
||||
"<!doctype html><html><head></head><body><span id='probe' style='display:inline-block;font:40px OrderFace'>AAAA</span><iframe id='frame'></iframe></body></html>".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(',')")
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
|
||||
@@ -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),
|
||||
|
||||
Reference in New Issue
Block a user