diff --git a/moli-core/tests/fixtures/font-csp.js b/moli-core/tests/fixtures/font-csp.js
new file mode 100644
index 00000000000..3603118b691
--- /dev/null
+++ b/moli-core/tests/fixtures/font-csp.js
@@ -0,0 +1,61 @@
+async function(crossOrigin) {
+ const rows = [], failures = [];
+ const control = (action, token, origin = location.origin) =>
+ fetch(origin + '/probe-' + action + '?token=' + token).then(r => r.json());
+ const url = (token, origin = location.origin, path = '/probe-asset') =>
+ origin + path + '?as=font&token=' + token;
+ const frame = async (policy, reportOnly = false) => {
+ const iframe = document.createElement('iframe');
+ const ready = new Promise(resolve => iframe.onload = resolve);
+ if (reportOnly) iframe.src = '/?reportPolicy=' + encodeURIComponent(policy);
+ else iframe.srcdoc = `
font CSP`;
+ document.body.append(iframe); await ready;
+ return iframe;
+ };
+ const outcome = face => face.load().then(() => 'loaded', e => e.name);
+ const check = (name, actual, expected) => {
+ rows.push({name, actual});
+ if (JSON.stringify(actual) !== JSON.stringify(expected)) failures.push({name, actual, expected});
+ };
+
+ const denied = await frame("font-src 'none'");
+ const child = denied.contentWindow;
+ const violation = new Promise(resolve => child.addEventListener('securitypolicyviolation', resolve, {once: true}));
+ await control('release', 'child-block'); await control('release', 'parent-allow');
+ const childFace = new child.FontFace('Blocked', `url("${url('child-block')}")`);
+ const childResult = await FontFace.prototype.load.call(childFace).then(() => 'loaded', e => e.name);
+ const event = await violation;
+ check('creation-document-csp', [childResult, event.effectiveDirective, event.target === child.document,
+ (await control('stats', 'child-block')).count,
+ await outcome(new FontFace('Allowed', `url("${url('parent-allow')}")`))],
+ ['NetworkError', 'font-src', true, 0, 'loaded']);
+ denied.remove();
+
+ const redirectFrame = await frame('font-src ' + location.origin + '/probe-asset');
+ const other = redirectFrame.contentWindow;
+ await control('release', 'redirect-cross'); await control('release', 'blocked-final', crossOrigin);
+ const initial = url('redirect-cross') + '&status=302&redirect=' + encodeURIComponent(url('blocked-final', crossOrigin));
+ const redirectedViolation = new Promise(resolve => other.addEventListener('securitypolicyviolation', resolve, {once: true}));
+ const redirected = await outcome(new other.FontFace('RedirectBlocked', `url("${initial}")`));
+ const redirectEvent = await redirectedViolation;
+ check('redirect-blocks-before-wire', [redirected, redirectEvent.effectiveDirective, redirectEvent.blockedURI,
+ (await control('stats', 'redirect-cross')).count, (await control('stats', 'blocked-final', crossOrigin)).count],
+ ['NetworkError', 'font-src', initial, 1, 0]);
+
+ await control('release', 'redirect-path'); await control('release', 'allowed-final');
+ const pathRedirect = url('redirect-path') + '&status=302&redirect=' + encodeURIComponent(url('allowed-final', location.origin, '/probe-font-final'));
+ check('redirect-ignores-source-path', [await outcome(new other.FontFace('RedirectPath', `url("${pathRedirect}")`)),
+ (await control('stats', 'redirect-path')).count, (await control('stats', 'allowed-final')).count], ['loaded', 1, 1]);
+ redirectFrame.remove();
+
+ const reported = await frame("font-src 'none'", true);
+ const reporting = reported.contentWindow;
+ const report = new Promise(resolve => reporting.addEventListener('securitypolicyviolation', resolve, {once: true}));
+ await control('release', 'report-only');
+ const reportedResult = await outcome(new reporting.FontFace('Reported', `url("${url('report-only')}")`));
+ const reportEvent = await report;
+ check('report-only-does-not-block', [reportedResult, reportEvent.disposition, reportEvent.effectiveDirective,
+ (await control('stats', 'report-only')).count], ['loaded', 'report', 'font-src', 1]);
+ reported.remove();
+ return {rows, failures};
+}
diff --git a/moli-core/tests/fixtures/font-loading.js b/moli-core/tests/fixtures/font-loading.js
new file mode 100644
index 00000000000..b9226acef39
--- /dev/null
+++ b/moli-core/tests/fixtures/font-loading.js
@@ -0,0 +1,108 @@
+async function(crossOrigin) {
+ const rows = [], failures = [];
+ const check = (name, actual, expected) => {
+ rows.push({name, actual});
+ if (JSON.stringify(actual) !== JSON.stringify(expected)) failures.push({name, actual, expected});
+ };
+ const url = (token, query = '', origin = location.origin) =>
+ origin + '/probe-asset?as=font&token=' + token + query;
+ const control = (action, token, origin = location.origin) =>
+ fetch(origin + '/probe-' + action + '?token=' + token).then(r => r.json());
+ const outcome = face => face.load().then(value => value === face ? 'loaded' : 'wrong value', e => e.name);
+ const event = name => new Promise(resolve => document.fonts.addEventListener(name, resolve, {once: true}));
+
+ const face = new FontFace('AsyncFont', `url("${url('async')}")`);
+ document.fonts.add(face);
+ const previousReady = document.fonts.ready;
+ const done = event('loadingdone');
+ const loaded = face.load();
+ const setLoad = document.fonts.load('16px AsyncFont');
+ const ready = document.fonts.ready;
+ let settled = false, setSettled = false, readySettled = false;
+ loaded.then(() => settled = true);
+ setLoad.then(() => setSettled = true);
+ ready.then(() => readySettled = true);
+ check('synchronous-state', [face.status, document.fonts.status, face.loaded === loaded,
+ face.load() === loaded, ready !== previousReady, document.fonts.check('16px AsyncFont')],
+ ['loading', 'loading', true, true, true, false]);
+ // Font loading and its events are native tasks, outside the public timer ids.
+ for (let id = 1; id < 100; id++) clearTimeout(id);
+ await control('started', 'async');
+ await Promise.resolve();
+ check('waits-for-bytes', [settled, setSettled, readySettled], [false, false, false]);
+ await control('release', 'async');
+ const values = await setLoad;
+ await ready;
+ const completed = await done;
+ check('completed-state', [face.status, document.fonts.status, values.length, values[0] === face,
+ completed.fontfaces.length, completed.fontfaces[0] === face, document.fonts.check('16px AsyncFont'),
+ (await control('stats', 'async')).count, performance.getEntriesByName(url('async')).map(e => e.initiatorType)],
+ ['loaded', 'loaded', 1, true, 1, true, true, 1, ['css']]);
+
+ const one = new FontFace('GroupOne', `url("${url('one')}")`);
+ const two = new FontFace('GroupTwo', `url("${url('two')}")`);
+ document.fonts.add(one); document.fonts.add(two);
+ const groupDone = event('loadingdone');
+ const first = outcome(one), second = outcome(two);
+ const groupReady = document.fonts.ready;
+ let groupSettled = false; groupReady.then(() => groupSettled = true);
+ await control('started', 'one'); await control('started', 'two');
+ await control('release', 'one'); await first; await Promise.resolve();
+ check('ready-waits-for-all', [groupSettled, document.fonts.status], [false, 'loading']);
+ document.fonts.delete(two);
+ await groupReady;
+ const groupEvent = await groupDone;
+ await control('release', 'two'); await second;
+ check('removing-pending-face', [document.fonts.status, groupEvent.fontfaces.map(f => f.family)], ['loaded', ['GroupOne']]);
+
+ for (const [token, query] of [['invalid', '&invalid=1'], ['http-error', '&status=404']]) {
+ await control('release', token);
+ check(token, await outcome(new FontFace(token, `url("${url(token, query)}")`)), 'NetworkError');
+ }
+ await control('release', 'fallback-bad'); await control('release', 'fallback-good');
+ const fallback = new FontFace('Fallback', `url("${url('fallback-bad', '&invalid=1')}"), url("${url('fallback-good')}")`);
+ check('fallback-after-decode-failure', [await outcome(fallback), (await control('stats', 'fallback-bad')).count,
+ (await control('stats', 'fallback-good')).count], ['loaded', 1, 1]);
+
+ await control('release', 'cross-good', crossOrigin); await control('release', 'cross-bad', crossOrigin);
+ check('cors', [await outcome(new FontFace('CrossGood', `url("${url('cross-good', '', crossOrigin)}")`)),
+ await outcome(new FontFace('CrossBad', `url("${url('cross-bad', '&cors=none', crossOrigin)}")`))], ['loaded', 'NetworkError']);
+
+ const base = document.createElement('base'); base.href = location.origin + '/before/'; document.head.append(base);
+ const relative = new FontFace('Relative', 'url("../probe-asset?as=font&token=relative")');
+ base.href = location.origin + '/after/sub/'; await control('release', 'relative');
+ check('creation-base-url', await outcome(relative), 'loaded'); base.remove();
+
+ await control('release', 'local');
+ const bytes = await (await fetch(url('local'))).arrayBuffer();
+ const blob = URL.createObjectURL(new Blob([bytes], {type: 'font/ttf'}));
+ const data = 'data:font/ttf;base64,' + btoa(String.fromCharCode(...new Uint8Array(bytes)));
+ check('local-font-validation', [await outcome(new FontFace('BlobFont', `url("${blob}")`)),
+ await outcome(new FontFace('DataFont', `url("${data}")`)),
+ await outcome(new FontFace('Truncated', 'url("data:font/ttf;base64,AAEAAA==")'))], ['loaded', 'loaded', 'NetworkError']);
+ URL.revokeObjectURL(blob);
+
+ const iframe = document.createElement('iframe');
+ const frameReady = new Promise(resolve => iframe.onload = resolve);
+ iframe.srcdoc = 'child'; document.body.append(iframe); await frameReady;
+ const other = iframe.contentWindow;
+ const childFace = new other.FontFace('ChildFont', `url("${url('child')}")`);
+ await control('release', 'child');
+ const childLoad = FontFace.prototype.load.call(childFace);
+ check('cross-realm-load', [childLoad instanceof other.Promise, await childLoad === childFace, childFace.status], [true, true, 'loaded']);
+ iframe.remove();
+
+ const failed = new FontFace('RejectedSet', `url("${url('set-error', '&invalid=1')}")`);
+ document.fonts.add(failed); await control('release', 'set-error');
+ const loadingError = event('loadingerror');
+ const result = await document.fonts.load('16px RejectedSet').then(() => 'loaded', e => e.name);
+ await document.fonts.ready;
+ check('set-rejection-and-ready', [result, document.fonts.status, (await loadingError).fontfaces[0] === failed], ['NetworkError', 'loaded', true]);
+
+ const meta = document.createElement('meta'); meta.httpEquiv = 'Content-Security-Policy'; meta.content = "font-src 'none'"; document.head.append(meta);
+ const violation = new Promise(resolve => addEventListener('securitypolicyviolation', e => resolve(e.effectiveDirective), {once: true}));
+ await control('release', 'csp');
+ check('font-csp', [await outcome(new FontFace('BlockedFont', `url("${url('csp')}")`)), await violation,
+ (await control('stats', 'csp')).count], ['NetworkError', 'font-src', 0]);
+ return {rows, failures};
+}
diff --git a/moli-core/tests/fixtures/font-preload.js b/moli-core/tests/fixtures/font-preload.js
new file mode 100644
index 00000000000..be4a18bb1d4
--- /dev/null
+++ b/moli-core/tests/fixtures/font-preload.js
@@ -0,0 +1,38 @@
+async function() {
+ const control = (action, token) => fetch('/probe-' + action + '?token=' + token).then(r => r.json());
+ await control('release', 'font-hash');
+ const bytes = await (await fetch('/probe-asset?as=font&token=font-hash')).arrayBuffer();
+ const hash = await crypto.subtle.digest('SHA-384', bytes);
+ const integrity = 'sha384-' + btoa(String.fromCharCode(...new Uint8Array(hash)));
+ const rows = [], failures = [];
+ for (const phase of ['pending', 'completed']) {
+ for (const crossOrigin of ['anonymous', 'use-credentials', null]) {
+ for (const valid of [true, false]) {
+ const token = 'font-preload-' + rows.length;
+ const url = new URL('/probe-asset?as=font&token=' + token, location.href).href;
+ const link = document.createElement('link');
+ Object.assign(link, {rel: 'preload', as: 'font', href: url, integrity: valid ? integrity : 'sha384-AAAA==='});
+ if (crossOrigin !== null) link.crossOrigin = crossOrigin;
+ const preload = new Promise(resolve => link.onload = link.onerror = e => resolve(e.type));
+ document.head.append(link);
+ await control('started', token);
+ if (phase === 'completed') { await control('release', token); await preload; }
+ const face = new FontFace('Preloaded' + rows.length, `url("${url}")`);
+ const loaded = face.load().then(() => 'loaded', e => e.name);
+ if (phase === 'pending') {
+ if (face.status !== 'loading') failures.push({phase, crossOrigin, valid, status: face.status});
+ await control('release', token);
+ }
+ const actual = [await preload, await loaded, (await control('stats', token)).count,
+ performance.getEntriesByName(url).map(e => e.initiatorType).sort()];
+ const shared = crossOrigin === 'anonymous';
+ const expected = [valid ? 'load' : 'error', shared && !valid ? 'NetworkError' : 'loaded',
+ shared ? 1 : 2, shared ? ['link'] : ['css', 'link']];
+ rows.push({phase, crossOrigin, valid, actual});
+ if (JSON.stringify(actual) !== JSON.stringify(expected)) failures.push({phase, crossOrigin, valid, actual, expected});
+ link.remove();
+ }
+ }
+ }
+ return {rows, failures};
+}
diff --git a/moli-core/tests/scripts.rs b/moli-core/tests/scripts.rs
index dcc96a4b89a..34532f78d51 100644
--- a/moli-core/tests/scripts.rs
+++ b/moli-core/tests/scripts.rs
@@ -1,5 +1,7 @@
#[path = "scripts/child_script_text.rs"]
mod child_script_text;
+#[path = "scripts/font_loading.rs"]
+mod font_loading;
#[path = "scripts/integrity.rs"]
mod integrity;
#[path = "scripts/worker_fetch_metadata.rs"]
diff --git a/moli-core/tests/scripts/font_loading.rs b/moli-core/tests/scripts/font_loading.rs
new file mode 100644
index 00000000000..28f436b253e
--- /dev/null
+++ b/moli-core/tests/scripts/font_loading.rs
@@ -0,0 +1,44 @@
+use super::preload_consumption::PreloadServer;
+use super::*;
+use anyhow::Context;
+
+#[tokio::test(flavor = "multi_thread")]
+async fn font_faces_fetch_validate_fallback_and_wait_for_font_sets() -> Result<()> {
+ run_font_probe(include_str!("../fixtures/font-loading.js"), 14).await
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn font_faces_consume_matching_pending_and_completed_preloads() -> Result<()> {
+ run_font_probe(include_str!("../fixtures/font-preload.js"), 12).await
+}
+
+#[tokio::test(flavor = "multi_thread")]
+async fn font_faces_enforce_document_csp_before_initial_and_redirect_requests() -> Result<()> {
+ run_font_probe(include_str!("../fixtures/font-csp.js"), 4).await
+}
+
+async fn run_font_probe(probe: &str, count: usize) -> Result<()> {
+ let server = PreloadServer::spawn().await?;
+ let cross = PreloadServer::spawn().await?;
+ let mut config = AppConfig::default();
+ config.set_optional_resource_fetch_mask(moli_page_types::OptionalResourceFetchMask::ALL);
+ let browser = Browser::new(config)?;
+ let mut page = browser.fetch(&server.origin).await?;
+ let expression = format!(
+ "({probe})({}).then(JSON.stringify, error => JSON.stringify({{error: String(error.stack || error)}}))",
+ serde_json::to_string(&cross.origin)?
+ );
+ let result = tokio::time::timeout(
+ Duration::from_secs(30),
+ page.evaluate_runtime_expression_with_await_async(&expression, true),
+ )
+ .await??;
+ let value: serde_json::Value = serde_json::from_str(
+ result["value"]
+ .as_str()
+ .context("FontFace loading results")?,
+ )?;
+ assert_eq!(value["failures"], serde_json::json!([]), "{value}");
+ assert_eq!(value["rows"].as_array().unwrap().len(), count, "{value}");
+ Ok(())
+}
diff --git a/moli-core/tests/scripts/preload_consumption.rs b/moli-core/tests/scripts/preload_consumption.rs
index 869633ffdd3..2d78a181ac0 100644
--- a/moli-core/tests/scripts/preload_consumption.rs
+++ b/moli-core/tests/scripts/preload_consumption.rs
@@ -48,8 +48,8 @@ impl Asset {
}
}
-struct PreloadServer {
- origin: String,
+pub(super) struct PreloadServer {
+ pub(super) origin: String,
task: JoinHandle<()>,
}
@@ -60,7 +60,7 @@ impl Drop for PreloadServer {
}
impl PreloadServer {
- async fn spawn() -> Result {
+ pub(super) async fn spawn() -> Result {
let listener = TcpListener::bind("127.0.0.1:0").await?;
let origin = format!("http://{}", listener.local_addr()?);
let task = tokio::spawn(async move {
@@ -86,7 +86,7 @@ impl PreloadServer {
let mut cache = "no-store".to_owned();
let (mime, body) = match url.path() {
"/probe-worker.js" => ("text/javascript", include_str!("../fixtures/preload-consumption-worker.js").to_owned()),
- "/probe-asset" => {
+ "/probe-asset" | "/probe-font-final" => {
asset.count.fetch_add(1, Ordering::AcqRel);
asset.started.notify_waiters();
asset.wait(true).await;
@@ -107,9 +107,21 @@ impl PreloadServer {
}
_ => ("text/html", "preload consumption".to_owned()),
};
+ let font = matches!(url.path(), "/probe-asset" | "/probe-font-final") && query.get("as").is_some_and(|kind| kind == "font");
+ let body = if font {
+ if query.contains_key("invalid") { b"\0\x01\0\0".to_vec() }
+ else { include_bytes!("../../../moli-layout/tests/fixtures/moli-ahem.ttf").to_vec() }
+ } else { body.into_bytes() };
+ let mime = if font { "font/ttf" } else { mime };
+ let status = query.get("status").map(String::as_str).unwrap_or("200");
+ let location = query.get("redirect").map(|url| format!("Location: {url}\r\n")).unwrap_or_default();
let origin = request.lines().find_map(|line| line.split_once(':').filter(|(name,_)| name.eq_ignore_ascii_case("Origin")).map(|(_,value)| value.trim())).unwrap_or("*");
- let response = format!("HTTP/1.1 200 OK\r\nContent-Type: {mime}\r\nCache-Control: {cache}\r\nAccess-Control-Allow-Origin: {origin}\r\nAccess-Control-Allow-Credentials: true\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len());
+ let cors = if query.get("cors").is_some_and(|value| value == "none") { String::new() }
+ else { format!("Access-Control-Allow-Origin: {origin}\r\nAccess-Control-Allow-Credentials: true\r\n") };
+ let policy = query.get("reportPolicy").map(|policy| format!("Content-Security-Policy-Report-Only: {policy}\r\n")).unwrap_or_default();
+ let response = format!("HTTP/1.1 {status} OK\r\nContent-Type: {mime}\r\nCache-Control: {cache}\r\n{cors}{location}{policy}Content-Length: {}\r\nConnection: close\r\n\r\n", body.len());
let _ = stream.write_all(response.as_bytes()).await;
+ let _ = stream.write_all(&body).await;
});
}
_ = connections.join_next(), if !connections.is_empty() => {}
diff --git a/moli-core/tests/web_apis.rs b/moli-core/tests/web_apis.rs
index 6c926a2529c..d6c31318f52 100644
--- a/moli-core/tests/web_apis.rs
+++ b/moli-core/tests/web_apis.rs
@@ -2369,7 +2369,9 @@ async fn window_css_exposes_escape_and_supports() -> Result<()> {
#[tokio::test]
async fn document_fonts_remove_event_listener_keeps_other_event_types_intact() -> Result<()> {
let server = FixtureServer::spawn().await?;
- let browser = Browser::new(AppConfig::default())?;
+ let mut config = AppConfig::default();
+ config.set_optional_resource_fetch_mask(moli_page_types::OptionalResourceFetchMask::ALL);
+ let browser = Browser::new(config)?;
let mut page = browser
.fetch(&server.url("/compat/document-fonts-events"))
@@ -2382,6 +2384,9 @@ async fn document_fonts_remove_event_listener_keeps_other_event_types_intact() -
)
.await?;
+ page.evaluate_runtime_expression_with_await_async("fontFixtureDone", true)
+ .await?;
+
assert!(
page.serialize_html_async()
.await
@@ -4067,7 +4072,9 @@ async fn chrome_media_query_list_add_and_remove_listener_cover_wpt_subset() -> R
#[tokio::test]
async fn chrome_fontfaceset_event_handlers_fire_in_loading_then_done_order_subset() -> Result<()> {
let server = FixtureServer::spawn().await?;
- let browser = Browser::new(AppConfig::default())?;
+ let mut config = AppConfig::default();
+ config.set_optional_resource_fetch_mask(moli_page_types::OptionalResourceFetchMask::ALL);
+ let browser = Browser::new(config)?;
let mut page = browser
.fetch(&server.url("/compat/chrome-fontfaceset-events-subset"))
@@ -4080,6 +4087,9 @@ async fn chrome_fontfaceset_event_handlers_fire_in_loading_then_done_order_subse
)
.await?;
+ page.evaluate_runtime_expression_with_await_async("fontFixtureDone", true)
+ .await?;
+
assert!(
page.serialize_html_async()
.await
@@ -4922,7 +4932,9 @@ async fn servo_fontfaceset_delete_and_clear_do_not_remove_css_connected_faces()
#[tokio::test]
async fn servo_fontfaceset_load_replaces_ready_and_rejects_css_wide_keywords() -> Result<()> {
let server = FixtureServer::spawn().await?;
- let browser = Browser::new(AppConfig::default())?;
+ let mut config = AppConfig::default();
+ config.set_optional_resource_fetch_mask(moli_page_types::OptionalResourceFetchMask::ALL);
+ let browser = Browser::new(config)?;
let mut page = browser
.fetch(&server.url("/compat/servo-fontfaceset-load-ready"))
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 0fd6d568eb7..708b48db04a 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
@@ -448,12 +448,8 @@ fn advance_sources<'s>(
let Some(url) = url else {
break;
};
- match crate::network_host::start_font_face_fetch(scope, face, request_context, &url) {
- Ok(crate::network_host::FontFaceFetchStart::Pending) => return,
- Ok(crate::network_host::FontFaceFetchStart::Local(bytes)) => {
- let _ = load.borrow_mut().accept_response(Some(&bytes));
- }
- Err(_) => {}
+ if crate::network_host::start_font_face_fetch(scope, face, request_context, &url).is_ok() {
+ return;
}
}
publish_font_face_load_changes(scope);
diff --git a/moli-renderer-v8/src/document_runtime.rs b/moli-renderer-v8/src/document_runtime.rs
index 0b527e246cc..f6590a0a930 100644
--- a/moli-renderer-v8/src/document_runtime.rs
+++ b/moli-renderer-v8/src/document_runtime.rs
@@ -92,8 +92,8 @@ pub(crate) use script_lifecycle::{
pub(crate) use security_policy::{
DocumentConnectPolicySnapshot, DocumentContentSecurityPolicyCheck,
DocumentContentSecurityPolicyViolation, DocumentNavigationEmbeddingContext,
- DocumentSubresourceCspKind, create_content_security_policy_violation_event,
- document_content_security_policy_error_message,
+ DocumentRequestPolicySnapshot, DocumentSubresourceCspKind,
+ create_content_security_policy_violation_event, document_content_security_policy_error_message,
};
pub(crate) use stylesheet_runtime::attribute_reprocesses_connected_stylesheet;
#[cfg(test)]
diff --git a/moli-renderer-v8/src/document_runtime/security_policy.rs b/moli-renderer-v8/src/document_runtime/security_policy.rs
index f3e4e6e6bac..f660b7dd20b 100644
--- a/moli-renderer-v8/src/document_runtime/security_policy.rs
+++ b/moli-renderer-v8/src/document_runtime/security_policy.rs
@@ -82,14 +82,17 @@ pub(crate) enum DocumentNavigationEmbeddingContext<'a> {
}
#[derive(Debug, Clone)]
-pub(crate) struct DocumentConnectPolicySnapshot {
+pub(crate) struct DocumentRequestPolicySnapshot {
+ resource_kind: ContentSecurityPolicyResourceKind,
policy_self_url: Option>,
enforce_policies: Vec,
report_only_policies: Vec,
reporting_endpoints: ContentSecurityPolicyReportingEndpoints,
}
-impl DocumentConnectPolicySnapshot {
+pub(crate) type DocumentConnectPolicySnapshot = DocumentRequestPolicySnapshot;
+
+impl DocumentRequestPolicySnapshot {
pub(crate) fn font_violation(
&self,
document_url: &Url,
@@ -120,12 +123,18 @@ impl DocumentConnectPolicySnapshot {
}
}
+ pub(crate) fn for_resource_kind(mut self, kind: ContentSecurityPolicyResourceKind) -> Self {
+ self.resource_kind = kind;
+ self
+ }
+
pub(crate) fn from_policies(
- enforce_policies: Vec,
+ enforce_policies: Vec,
report_only_policies: Vec,
reporting_endpoints: ContentSecurityPolicyReportingEndpoints,
) -> Self {
Self {
+ resource_kind: ContentSecurityPolicyResourceKind::DocumentConnect,
policy_self_url: None,
enforce_policies: document_response_content_security_policy_strings(
&enforce_policies,
@@ -165,22 +174,37 @@ impl DocumentConnectPolicySnapshot {
&self,
document_url: &Url,
request_url: &Url,
+ ) -> DocumentContentSecurityPolicyCheck {
+ self.check_url(
+ document_url,
+ request_url,
+ ContentSecurityPolicyRedirectStatus::FollowedRedirect,
+ )
+ }
+
+ pub(crate) fn check_url(
+ &self,
+ document_url: &Url,
+ request_url: &Url,
+ redirect_status: ContentSecurityPolicyRedirectStatus,
) -> DocumentContentSecurityPolicyCheck {
let policy_url = self.policy_self_url.as_deref().unwrap_or(document_url);
let mut result = DocumentContentSecurityPolicyCheck {
- report_only_violations: document_connect_policy_violations(
+ report_only_violations: document_url_policy_violations(
&self.report_only_policies,
&self.reporting_endpoints,
policy_url,
request_url,
- ContentSecurityPolicyRedirectStatus::FollowedRedirect,
+ self.resource_kind,
+ redirect_status,
ContentSecurityPolicyDisposition::Report,
),
- enforced_violations: document_connect_policy_violations_from_document_policies(
+ enforced_violations: document_url_policy_violations_from_document_policies(
self.enforce_policies.clone(),
policy_url,
request_url,
- ContentSecurityPolicyRedirectStatus::FollowedRedirect,
+ self.resource_kind,
+ redirect_status,
ContentSecurityPolicyDisposition::Enforce,
),
};
@@ -219,7 +243,7 @@ impl DocumentConnectPolicySnapshot {
self.enforce_policies.clone(),
self.policy_self_url.as_deref().unwrap_or(document_url),
request_url,
- ContentSecurityPolicyResourceKind::DocumentConnect,
+ self.resource_kind,
redirect_status,
ContentSecurityPolicyDisposition::Enforce,
)
@@ -238,11 +262,12 @@ impl DocumentConnectPolicySnapshot {
request_url: &Url,
redirect_status: ContentSecurityPolicyRedirectStatus,
) -> Option {
- document_connect_policy_violation(
+ document_url_policy_violation(
&self.report_only_policies,
&self.reporting_endpoints,
self.policy_self_url.as_deref().unwrap_or(document_url),
request_url,
+ self.resource_kind,
redirect_status,
ContentSecurityPolicyDisposition::Report,
)
@@ -1154,6 +1179,7 @@ pub(crate) fn set_response_content_security_report_only_policies(
);
}
DocumentConnectPolicySnapshot {
+ resource_kind: ContentSecurityPolicyResourceKind::DocumentConnect,
policy_self_url: policy
.content_security_policy_self_url
.clone()
@@ -2051,7 +2077,7 @@ pub(crate) fn set_response_content_security_report_only_policies(
)
}
- fn queue_content_security_policy_violation_event_for_target<'s>(
+ pub(crate) fn queue_content_security_policy_violation_event_for_target<'s>(
&mut self,
scope: &mut v8::PinScope<'s, '_>,
host_ptr: *mut JsContextHost,
@@ -2320,25 +2346,6 @@ fn content_security_policy_frame_ancestors_violations_with_disposition_and_repor
}).collect()
}
-fn document_connect_policy_violation(
- policies: &[ContentSecurityPolicy],
- reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
- document_url: &Url,
- request_url: &Url,
- redirect_status: ContentSecurityPolicyRedirectStatus,
- disposition: ContentSecurityPolicyDisposition,
-) -> Option {
- document_url_policy_violation(
- policies,
- reporting_endpoints,
- document_url,
- request_url,
- ContentSecurityPolicyResourceKind::DocumentConnect,
- redirect_status,
- disposition,
- )
-}
-
fn document_connect_policy_violations(
policies: &[ContentSecurityPolicy],
reporting_endpoints: &ContentSecurityPolicyReportingEndpoints,
diff --git a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs
index d70dd85266d..5c9069bbd66 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/resource_loading.rs
@@ -1255,7 +1255,7 @@ impl JsContextHost {
pub(crate) fn record_async_font_face_fetch(
&mut self,
context: v8::Global,
- face: v8::Global,
+ font: crate::types::PendingFontFaceFetch,
owner: OwnerDispatchScope,
cancel_handle: moli_fetch::FetchCancelHandle,
network_partition_key: Option,
@@ -1285,10 +1285,11 @@ impl JsContextHost {
request_mode: moli_fetch::RequestMode::Cors,
network_partition_key,
policy_context,
- continuation: PendingSubresourceContinuation::FontFace(face),
+ continuation: PendingSubresourceContinuation::FontFace(Box::new(font)),
request_origin,
redirect_headers: None,
deferred_request_started: false,
+ blob_url_entry: None,
},
);
self.note_subresource_activity();
@@ -1660,14 +1661,25 @@ impl JsContextHost {
.get(&internal_id)
.map(|state| &state.pending)
})?;
- let fetch = pending.continuation.window_fetch()?;
- if !fetch.connect_policy().has_policies() {
+ let (policy, redirect_state, report_context) =
+ if let Some(fetch) = pending.continuation.window_fetch() {
+ (
+ fetch.connect_policy(),
+ fetch.redirect_csp_state(),
+ fetch.csp_report_context(),
+ )
+ } else if let PendingSubresourceContinuation::FontFace(font) = &pending.continuation {
+ (&font.policy, &font.redirect_state, &font.report_context)
+ } else {
+ return None;
+ };
+ if !policy.has_policies() {
return None;
}
- let report_context = fetch.csp_report_context().clone();
+ let report_context = report_context.clone();
let completion_tx = self.resource_completion_sender();
- fetch.redirect_csp_state().redirect_check(
- fetch.connect_policy().clone(),
+ redirect_state.redirect_check(
+ policy.clone(),
pending.info.document_url.clone(),
pending.info.url.clone(),
move |violation| {
diff --git a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs
index 6e4b85190a4..6cf3ace2f80 100644
--- a/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs
+++ b/moli-renderer-v8/src/native_bridge/context_host/security_policy.rs
@@ -1288,8 +1288,24 @@ impl JsContextHost {
handle: DomHandle,
violation: &DocumentContentSecurityPolicyViolation,
) {
- if let Err(error) = self
- .dispatch_child_content_security_policy_violation_event(scope, handle, violation, false)
+ let Some(document) = self.child_browsing_context_document_handle(handle) else {
+ return;
+ };
+ let Some(owner) = self.current_child_document_task_owner(handle) else {
+ return;
+ };
+ let host_ptr: *mut JsContextHost = self;
+ // Preserve the source Document as the event target and enqueue the
+ // event on its lifecycle, just as for a top-level Document.
+ if let Err(error) = unsafe { &mut *self.runtime }
+ .queue_content_security_policy_violation_event_for_target(
+ scope,
+ host_ptr,
+ Some(document),
+ violation,
+ false,
+ Some(owner),
+ )
{
tracing::error!(
blocked_uri = violation.blocked_uri.as_str(),
diff --git a/moli-renderer-v8/src/network_host.rs b/moli-renderer-v8/src/network_host.rs
index 8eccd8d562b..e102af3cebf 100644
--- a/moli-renderer-v8/src/network_host.rs
+++ b/moli-renderer-v8/src/network_host.rs
@@ -26,7 +26,7 @@ mod url_helpers;
mod xhr;
pub(crate) use font_face::{
- FontFaceFetchStart, capture_font_face_request_context, resolve_font_face_sources,
+ capture_font_face_request_context, resolve_font_face_sources,
start_font_face_fetch,
};
use moli_fetch::{Request, Response, observe_cookie_access_report_for_request};
diff --git a/moli-renderer-v8/src/network_host/font_face.rs b/moli-renderer-v8/src/network_host/font_face.rs
index 9332d0f753b..5de068f8411 100644
--- a/moli-renderer-v8/src/network_host/font_face.rs
+++ b/moli-renderer-v8/src/network_host/font_face.rs
@@ -2,14 +2,9 @@ use super::subresource::{PreparedSubresourceFetch, SubresourceFetchOptions};
use super::*;
use crate::{
native_bridge::{JsContextHost, WindowExecutionContextIdentity},
- types::{SubresourceRequestInitiatorType, SubresourceResourceType},
+ types::{AsyncSubresourceFetchCompletion, PendingFontFaceFetch, SubresourceResourceType},
};
-use anyhow::{Context, Result, anyhow, ensure};
-
-pub(crate) enum FontFaceFetchStart {
- Local(Vec),
- Pending,
-}
+use anyhow::{Context, Result, anyhow};
/// Freeze the constructor's relevant Window, independently of an enclosing
/// child request callback. The identity contains no strong V8 handles.
@@ -57,7 +52,7 @@ pub(crate) fn start_font_face_fetch(
face: v8::Local<'_, v8::Object>,
request_context: Option,
source: &str,
-) -> Result {
+) -> Result<()> {
let host_ptr = crate::util::context_host_ptr_from_global_bridge(scope)
.context("FontFace URL loader is unavailable in this realm")?;
// SAFETY: the current live realm owns the bridge. No author callback runs
@@ -77,55 +72,102 @@ pub(crate) fn start_font_face_fetch(
.base_url
.join(source)
.context("failed to resolve FontFace source URL")?;
- ensure!(
- host.font_request_allowed_by_csp(
- scope,
- owner,
+ let policy = host
+ .document_connect_policy_snapshot_for_owner(owner)
+ .ok_or("FontFace policy owner is unavailable")?
+ .for_resource_kind(
+ crate::content_security_policy::ContentSecurityPolicyResourceKind::DocumentFont,
+ );
+ let report_context = capture_window_csp_report_request_context(scope, host, owner)
+ .ok_or("FontFace reporting owner is unavailable")?;
+ let (reports, enforced) = policy
+ .check_url(
&environment.document_url,
&request_url,
crate::content_security_policy::ContentSecurityPolicyRedirectStatus::NoRedirect,
- ),
- "Font request blocked by Content Security Policy"
- );
- if let Some(response) = local_url_response(&request_url) {
- let response: crate::types::NavigationResponse = response.into();
- let result = if (200..300).contains(&response.status) {
- Ok(FontFaceFetchStart::Local(response.body_bytes().to_vec()))
- } else {
- Err(anyhow!("Font request failed"))
- };
- host.record_get_subresource_network_result_with_initiator(
- environment.frame_id,
- environment.document_url,
- request_url,
- SubresourceResourceType::Font,
- SubresourceRequestInitiatorType::Script,
- &Ok(response),
+ )
+ .into_violations();
+ let blocked = !enforced.is_empty();
+ for violation in reports.into_iter().chain(enforced) {
+ send_content_security_policy_violation_report_from_window_context(
+ host,
+ &report_context,
+ &violation,
+ );
+ host.dispatch_document_connect_csp_violation_event_for_exact_owner_without_report_best_effort(
+ scope, host_ptr, report_context.identity(), &violation,
);
- return result;
}
+ if blocked {
+ return Err(anyhow!(
+ "FontFace request blocked by Content Security Policy"
+ ));
+ }
+ moli_fetch::FetchUrlList::new(&request_url, &[])
+ .validate_request_mode(moli_fetch::RequestMode::Cors, &environment.request_origin)
+ .map_err(anyhow::Error::msg)?;
+ if matches!(request_url.scheme(), "http" | "https")
+ && !resource_loader
+ .request_client()
+ .optional_resource_fetch_enabled(SubresourceResourceType::Font)
+ {
+ return Err(anyhow!(
+ "FontFace requests are disabled by the resource policy"
+ ));
+ }
+ let font = PendingFontFaceFetch {
+ face: v8::Global::new(scope, face),
+ redirect_state: FetchCspRedirectState::new(&policy),
+ policy,
+ report_context,
+ };
let prepared = PreparedSubresourceFetch::prepare(
scope,
host,
owner,
&resource_loader,
environment,
- request_url,
+ request_url.clone(),
SubresourceFetchOptions::FONT,
)?;
let internal_id = host.record_async_font_face_fetch(
v8::Global::new(scope, scope.get_current_context()),
- v8::Global::new(scope, face),
+ font,
owner,
prepared.cancel_handle.clone(),
prepared.network_partition_key.clone(),
prepared.network_context.policy_context,
prepared.pending_info.clone(),
);
+ // Local URL responses use the same resource completion task as network
+ // responses, preserving the observable loading state before settlement.
+ let blob = CapturedBlobUrl::capture(&request_url);
+ if let Some(response) =
+ local_url_response_with_blob_entry(&request_url, "GET", &[], blob.as_ref())
+ {
+ let result = response
+ .map(Into::into)
+ .map_err(|error| error.into_message());
+ let _ = host.resource_completion_sender().send_async_subresource(
+ AsyncSubresourceFetchCompletion {
+ internal_id,
+ request_url,
+ request_method: "GET".to_owned(),
+ request_headers: Default::default(),
+ request_body: None,
+ response_status_text: None,
+ skip_fetch_security_validation: false,
+ response_filter: None,
+ network_error_text: None,
+ result: result.into(),
+ },
+ );
+ return Ok(());
+ }
prepared.dispatch(
host,
internal_id,
"service worker font request dispatch failed",
);
- Ok(FontFaceFetchStart::Pending)
+ Ok(())
}
diff --git a/moli-renderer-v8/src/network_host/subresource.rs b/moli-renderer-v8/src/network_host/subresource.rs
index 9e3798300a4..09ae9892c4e 100644
--- a/moli-renderer-v8/src/network_host/subresource.rs
+++ b/moli-renderer-v8/src/network_host/subresource.rs
@@ -132,11 +132,15 @@ impl PreparedSubresourceFetch {
}
pub(super) fn dispatch(
- self,
+ mut self,
host: &mut JsContextHost,
internal_id: u64,
service_worker_failure: &str,
) {
+ let redirect_check = host.window_fetch_redirect_check(internal_id);
+ if let Some(check) = redirect_check.clone() {
+ self.request = self.request.with_redirect_check(check);
+ }
let loader = self.resource_loader.request_client().clone();
let task_runner = self.resource_loader.task_runner();
let info = self.pending_info;
@@ -147,7 +151,7 @@ impl PreparedSubresourceFetch {
.is_some()
{
let dispatch = ServiceWorkerFetchDispatch {
- redirect_check: None,
+ redirect_check,
internal_id,
request: host.service_worker_fetch_request(
client_id,
diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs
index 3957a7bed6a..f6bc2156148 100644
--- a/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs
+++ b/moli-renderer-v8/src/script_vm/subresource_fetch/fetch_dispatch.rs
@@ -517,11 +517,22 @@ impl ScriptVm {
let security_started = moli_trace::cdp_runtime_trace_enabled().then(Instant::now);
let mut opaque_response_blocked = false;
let result = result.and_then(|response| {
- if matches!(pending.continuation, PendingSubresourceContinuation::FontFace(_))
- && !response.redirect_chain.is_empty()
- && !context_host.borrow_mut().font_request_allowed_by_csp(scope, pending.execution_context.dispatch_scope(), &pending.info.document_url, &response.final_url, crate::content_security_policy::ContentSecurityPolicyRedirectStatus::FollowedRedirect) {
- return Err("Font redirect blocked by Content Security Policy".to_owned());
+ if let PendingSubresourceContinuation::FontFace(font) = &pending.continuation
+ && response.final_url != pending.info.url
+ && !font.redirect_state.was_checked(&response.final_url) {
+ let redirect_status = if response.redirect_chain.is_empty() {
+ ContentSecurityPolicyRedirectStatus::NoRedirect
+ } else { ContentSecurityPolicyRedirectStatus::FollowedRedirect };
+ let (reports, enforced) = font.policy.check_url(&pending.info.document_url, &response.final_url, redirect_status).into_violations();
+ let error = enforced.first().map(|violation| crate::document_runtime::document_content_security_policy_error_message(violation, "FontFace"));
+ for mut violation in reports.into_iter().chain(enforced) {
+ report_window_fetch_csp_redirect_violation(scope, &context_host, &font.report_context, &pending.info.url, &mut violation);
+ }
+ if let Some(error) = error {
+ return Err(error);
+ }
}
+
if !response.redirect_chain.is_empty()
&& let Some(message) = document_connect_csp_redirect_failure_message(
scope,
@@ -787,7 +798,7 @@ impl ScriptVm {
),
),
PendingSubresourceContinuation::FontFace(face) => {
- let face = v8::Local::new(scope, face);
+ let face = v8::Local::new(scope, &face.face);
let bytes = ((200..300).contains(&response_status) && !opaque_response_blocked)
.then(|| observable_response.body_bytes());
crate::context_bootstrap::finish_font_face_url_load(scope, face, bytes);
@@ -931,7 +942,7 @@ impl ScriptVm {
Err(error_text.clone()),
),
PendingSubresourceContinuation::FontFace(face) => {
- let face = v8::Local::new(scope, face);
+ let face = v8::Local::new(scope, &face.face);
crate::context_bootstrap::finish_font_face_url_load(scope, face, None);
}
PendingSubresourceContinuation::StylesheetSubresource {
diff --git a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs
index 5f8ded23dd4..3326120a157 100644
--- a/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs
+++ b/moli-renderer-v8/src/script_vm/subresource_fetch/streaming.rs
@@ -861,7 +861,7 @@ impl ScriptVm {
Err(error_text.clone()),
),
PendingSubresourceContinuation::FontFace(face) => {
- let face = v8::Local::new(scope, face);
+ let face = v8::Local::new(scope, &face.face);
crate::context_bootstrap::finish_font_face_url_load(scope, face, None);
}
PendingSubresourceContinuation::StylesheetSubresource { binding, .. } => {
@@ -1108,7 +1108,7 @@ impl ScriptVm {
Err("text-track response unexpectedly used streaming transport".to_owned()),
),
PendingSubresourceContinuation::FontFace(face) => {
- let face = v8::Local::new(scope, face);
+ let face = v8::Local::new(scope, &face.face);
crate::context_bootstrap::finish_font_face_url_load(scope, face, None);
}
PendingSubresourceContinuation::StylesheetSubresource { binding, .. } => {
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs
index 9feab96dfb2..e81a2cfcd6e 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc.rs
@@ -89,6 +89,35 @@ fn service_worker_csp_report_seen(
report_body_seen || report_record_seen
}
+async fn eval_font_loading_fixture(url: &str, script: &str) -> String {
+ use base64::Engine as _;
+ let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).unwrap();
+ let mut page =
+ crate::runtime::PageVmTaskExecutorTestHarness::new(url::Url::parse(url).unwrap(), &loader);
+ let source = format!(
+ "url(data:font/ttf;base64,{})",
+ base64::engine::general_purpose::STANDARD.encode(include_bytes!(
+ "../../../../../moli-layout/tests/fixtures/moli-ahem.ttf"
+ ))
+ );
+ page.eval(&format!(
+ "globalThis.fontFixtureSource = {};",
+ serde_json::to_string(&source).unwrap()
+ ))
+ .unwrap();
+ page.eval(&format!("({script}).then(value => globalThis.fontFixtureResult = value, error => globalThis.fontFixtureResult = String(error.stack || error))")).unwrap();
+ for _ in 0..64 {
+ let result = page.eval("String(globalThis.fontFixtureResult)").unwrap();
+ if result != "undefined" {
+ return result;
+ }
+ wait_for_one_selected_page_task_executor_test_turn(&mut page, &loader)
+ .await
+ .unwrap();
+ }
+ panic!("font loading fixture did not settle");
+}
+
async fn assert_popup_consecutive_history_back(from_popup: bool) {
let loader = ResourceRequestClient::new(&moli_fetch::FetchConfig::default()).expect("loader");
let mut vm =
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/fonts.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/fonts.rs
index f9fa23fbd65..5abc1a6219f 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/fonts.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/misc/extracted/fonts.rs
@@ -193,22 +193,13 @@ fn font_face_variation_settings_use_stylo_descriptor_serialization() {
r#"{"values":["\"wght\" 850","\"wdth\" 120.5","\"wdth\" 120.5"],"setterError":"SyntaxError","constructorStatus":"error","descriptor":["function",0,"function",1,true,true,false]}"#
);
}
-#[test]
-fn font_face_set_load_event_copies_and_freezes_fontfaces() {
- let mut vm = new_storage_test_vm("https://font-face-set-load-event.test/");
- vm.eval(&format!(
- "globalThis.fixtureFontSource = {:?}",
- format!(
- "url({:?})",
- crate::script_vm::tests::browser_api::fonts::fixture_font_url()
- )
- ))
- .unwrap();
-
- vm.eval(
+#[tokio::test]
+async fn font_face_set_load_event_copies_and_freezes_fontfaces() {
+ let result = eval_font_loading_fixture(
+ "https://font-face-set-load-event.test/",
r#"
-(() => {
- const face = new FontFace('Demo', fixtureFontSource);
+(async () => {
+ const face = new FontFace('Demo', fontFixtureSource);
const source = [face];
const empty = new FontFaceSetLoadEvent('loading');
const configured = new FontFaceSetLoadEvent('loadingdone', {
@@ -250,13 +241,15 @@ fn font_face_set_load_event_copies_and_freezes_fontfaces() {
Object.isFrozen(event.fontfaces)
].join(':');
});
- fonts.load('10px Demo');
+ const done = new Promise(resolve => fonts.addEventListener('loadingdone', resolve, {once: true}));
+ await fonts.load('10px Demo');
+ await done;
const descriptor = Object.getOwnPropertyDescriptor(
FontFaceSetLoadEvent.prototype,
'fontfaces'
);
- globalThis.__fontFaceSetEventProbe = {
+ return JSON.stringify({
surface: [
typeof FontFaceSetLoadEvent,
FontFaceSetLoadEvent.length,
@@ -293,17 +286,13 @@ fn font_face_set_load_event_copies_and_freezes_fontfaces() {
throwsTypeError(() => new FontFaceSetLoadEvent('loading', { fontfaces: [{}] })),
throwsTypeError(() => new FontFaceSetLoadEvent('loading', { fontfaces: null }))
],
- get dispatched() { return [loadingShape, doneShape]; }
- };
+ dispatched: [loadingShape, doneShape]
+ });
})()
"#,
)
- .expect("FontFaceSetLoadEvent FrozenArray semantics should evaluate");
+ .await;
- run_font_tasks(&mut vm);
- let result = vm
- .eval("JSON.stringify(globalThis.__fontFaceSetEventProbe)")
- .unwrap();
assert_eq!(
result,
r#"{"surface":["function",1,true,true,"[object FontFaceSetLoadEvent]"],"empty":[true,0,true,true],"configured":["loadingdone",true,true,true,1,true,true,true],"descriptor":["function","undefined","true","true","false"],"errors":[true,true,true,true],"dispatched":["true:true:true:0","true:true:true:1:true:true"]}"#
@@ -466,22 +455,13 @@ fn font_face_set_listener_uses_callback_realm_and_exact_window_lifetime() {
r#"{"facts":[[true,true,true,true]],"childDetached":true}"#
);
}
-#[test]
-fn font_face_load_updates_owner_sets_once_and_unlinks_removed_faces() {
- let mut vm = new_storage_test_vm("https://font-face-owner-sets.test/");
- vm.eval(&format!(
- "globalThis.fixtureFontSource = {:?}",
- format!(
- "url({:?})",
- crate::script_vm::tests::browser_api::fonts::fixture_font_url()
- )
- ))
- .unwrap();
-
- vm.eval(
+#[tokio::test]
+async fn font_face_load_updates_owner_sets_once_and_unlinks_removed_faces() {
+ let result = eval_font_loading_fixture(
+ "https://font-face-owner-sets.test/",
r#"
-(() => {
- const face = new FontFace('Demo', fixtureFontSource);
+(async () => {
+ const face = new FontFace('Demo', fontFixtureSource);
const documentFonts = document.fonts;
const secondary = document.implementation.createHTMLDocument('').fonts;
documentFonts.add(face);
@@ -509,13 +489,14 @@ fn font_face_load_updates_owner_sets_once_and_unlinks_removed_faces() {
const documentReadyBefore = documentFonts.ready;
const secondaryReadyBefore = secondary.ready;
+ const done = Promise.all([documentFonts, secondary].map(set => new Promise(resolve => set.addEventListener('loadingdone', resolve, {once: true}))));
const firstLoad = face.load();
const documentReadyAfter = documentFonts.ready;
const secondaryReadyAfter = secondary.ready;
const eventCountAfterFirstLoad = events.length;
const secondLoad = face.load();
- const removed = new FontFace('Removed', 'local("Missing Removed Font 1337")');
+ const removed = new FontFace('Removed', fontFixtureSource);
documentFonts.add(removed);
const removedDeleted = documentFonts.delete(removed);
const documentReadyBeforeRemovedLoad = documentFonts.ready;
@@ -523,14 +504,14 @@ fn font_face_load_updates_owner_sets_once_and_unlinks_removed_faces() {
removed.load();
const clearedSet = document.implementation.createHTMLDocument('').fonts;
- const cleared = new FontFace('Cleared', 'local("Missing Cleared Font 1337")');
+ const cleared = new FontFace('Cleared', fontFixtureSource);
clearedSet.add(cleared);
const clearedReadyBeforeLoad = clearedSet.ready;
clearedSet.clear();
const eventCountBeforeClearedLoad = events.length;
cleared.load();
- globalThis.__fontFaceOwnerProbe = {
+ const result = {
loads: [firstLoad === face.loaded, secondLoad === face.loaded],
ready: [
documentReadyBefore !== documentReadyAfter,
@@ -538,7 +519,7 @@ fn font_face_load_updates_owner_sets_once_and_unlinks_removed_faces() {
documentReadyAfter === documentFonts.ready,
secondaryReadyAfter === secondary.ready
],
- get status() { return [documentFonts.status, secondary.status]; },
+ during: [documentFonts.status, secondary.status],
events,
repeated: events.length === eventCountAfterFirstLoad,
removed: [
@@ -552,35 +533,24 @@ fn font_face_load_updates_owner_sets_once_and_unlinks_removed_faces() {
clearedSet.status === 'loaded'
]
};
+ await Promise.all([firstLoad, removed.loaded, cleared.loaded, done]);
+ result.status = [documentFonts.status, secondary.status];
+ return JSON.stringify(result);
})()
"#,
- )
- .expect("FontFace loads should update each current owner set once");
+ ).await;
- run_font_tasks(&mut vm);
- let result = vm
- .eval("JSON.stringify(globalThis.__fontFaceOwnerProbe)")
- .unwrap();
assert_eq!(
result,
- r#"{"loads":[true,true],"ready":[true,true,true,true],"status":["loaded","loaded"],"events":["document:loading:true:true:true:0:true:true","secondary:loading:true:true:true:0:true:true","document:loadingdone:true:true:true:1:true:true","secondary:loadingdone:true:true:true:1:true:true"],"repeated":true,"removed":[true,true,true],"cleared":[true,true,true]}"#
+ r#"{"loads":[true,true],"ready":[true,true,true,true],"during":["loading","loading"],"events":["document:loading:true:true:true:0:true:true","secondary:loading:true:true:true:0:true:true","document:loadingdone:true:true:true:1:true:true","secondary:loadingdone:true:true:true:1:true:true"],"repeated":true,"removed":[true,true,true],"cleared":[true,true,true],"status":["loaded","loaded"]}"#
);
}
-#[test]
-fn stylesheet_font_face_load_updates_document_font_set() {
- let mut vm = new_storage_test_vm("https://stylesheet-font-face-owner.test/");
- vm.eval(&format!(
- "globalThis.fixtureFontSource = {:?}",
- format!(
- "url({:?})",
- crate::script_vm::tests::browser_api::fonts::fixture_font_url()
- )
- ))
- .unwrap();
-
- vm.eval(
+#[tokio::test]
+async fn stylesheet_font_face_load_updates_document_font_set() {
+ let result = eval_font_loading_fixture(
+ "https://stylesheet-font-face-owner.test/",
r#"
-(() => {
+(async () => {
const observed = [];
let face;
for (const type of ['loading', 'loadingdone']) {
@@ -594,27 +564,25 @@ fn stylesheet_font_face_load_updates_document_font_set() {
});
}
const style = document.createElement('style');
- style.textContent = `@font-face { font-family: "StylesheetOwner"; src: ${fixtureFontSource}; }`;
+ style.textContent = '@font-face { font-family: "StylesheetOwner"; src: ' + fontFixtureSource + '; }';
(document.head || document.documentElement || document).appendChild(style);
face = [...document.fonts].find(face => face.family === 'StylesheetOwner');
const readyBefore = document.fonts.ready;
+ const done = new Promise(resolve => document.fonts.addEventListener('loadingdone', resolve, {once: true}));
const loaded = face.load();
- globalThis.__stylesheetFontFaceProbe = {
+ await loaded;
+ await done;
+ return JSON.stringify({
face: face instanceof FontFace,
loaded: loaded === face.loaded,
ready: readyBefore !== document.fonts.ready,
- get status() { return document.fonts.status; },
+ status: document.fonts.status,
observed
- };
+ });
})()
"#,
- )
- .expect("stylesheet FontFace loads should update document.fonts");
+ ).await;
- run_font_tasks(&mut vm);
- let result = vm
- .eval("JSON.stringify(globalThis.__stylesheetFontFaceProbe)")
- .unwrap();
assert_eq!(
result,
r#"{"face":true,"loaded":true,"ready":true,"status":"loaded","observed":["loading:0:true:true","loadingdone:1:true:true"]}"#
@@ -789,14 +757,14 @@ JSON.stringify({
r#"{"names":["ScreenOnly"],"beforeDescriptor":true,"descriptorChangedIdentity":true,"unrelatedInsertIdentity":true,"replaceChangedIdentity":true,"reinsertChangedIdentity":true,"unadoptedReinsertChangedIdentity":true}"#
);
}
-#[test]
-fn font_face_binary_source_union_rejects_invalid_font_data() {
- let mut vm = new_storage_test_vm("https://font-face-binary-source.test/");
-
- vm.eval(
+#[tokio::test]
+async fn font_face_binary_source_union_rejects_invalid_font_data() {
+ let result = eval_font_loading_fixture(
+ "https://font-face-binary-source.test/",
r#"
-(() => {
+(async () => {
const face = new FontFace('InvalidBinary', new ArrayBuffer(8));
+ await face.loaded.catch(() => {});
const fonts = document.implementation.createHTMLDocument('').fonts;
fonts.add(face);
const events = [];
@@ -820,18 +788,16 @@ fn font_face_binary_source_union_rejects_invalid_font_data() {
events,
rejection: 'pending'
};
- loaded.then(
+ await loaded.then(
() => { globalThis.__fontFaceBinarySourceProbe.rejection = 'resolved'; },
error => { globalThis.__fontFaceBinarySourceProbe.rejection = error.name; }
);
+ return JSON.stringify(globalThis.__fontFaceBinarySourceProbe);
})()
"#,
)
- .expect("invalid binary FontFace source should initialize");
+ .await;
- let result = vm
- .eval("JSON.stringify(globalThis.__fontFaceBinarySourceProbe)")
- .expect("invalid binary FontFace rejection should settle");
assert_eq!(
result,
r#"{"source":"","status":"error","samePromise":true,"readyChanged":false,"setStatus":"loaded","events":[],"rejection":"SyntaxError"}"#
@@ -1569,3 +1535,73 @@ async fn invalid_font_face_defers_loaded_rejection_until_promise_is_observed() {
"SyntaxError",
);
}
+
+#[tokio::test]
+async fn font_face_string_sources_follow_load_state_and_connected_style_use() {
+ let result = eval_font_loading_fixture(
+ "https://font-face-string-source-state.test/",
+ r#"
+(async () => {
+ const remote = new FontFace('RemoteFace', fontFixtureSource);
+ const remoteLoaded = remote.loaded;
+ const invalid = new FontFace('InvalidFace', 'not a font source');
+ const local = new FontFace(
+ 'MissingLocalFace',
+ 'local("definitely-missing-moli-font")'
+ );
+ document.fonts.add(local);
+
+ globalThis.__fontFaceStringSourceProbe = {
+ remote: {
+ before: remote.status,
+ stablePromise: remote.loaded === remoteLoaded,
+ loadReturnsLoaded: remote.load() === remoteLoaded,
+ after: remote.status,
+ settlement: 'pending'
+ },
+ invalid: {
+ status: invalid.status,
+ settlement: 'pending'
+ },
+ local: {
+ beforeStyle: local.status,
+ afterDetachedStyle: '',
+ afterConnection: '',
+ settlement: 'pending'
+ }
+ };
+ remoteLoaded.then(
+ value => {
+ globalThis.__fontFaceStringSourceProbe.remote.settlement =
+ value === remote ? 'resolved-self' : 'resolved-other';
+ },
+ error => {
+ globalThis.__fontFaceStringSourceProbe.remote.settlement = error.name;
+ }
+ );
+ invalid.loaded.then(
+ () => { globalThis.__fontFaceStringSourceProbe.invalid.settlement = 'resolved'; },
+ error => { globalThis.__fontFaceStringSourceProbe.invalid.settlement = error.name; }
+ );
+ local.loaded.then(
+ () => { globalThis.__fontFaceStringSourceProbe.local.settlement = 'resolved'; },
+ error => { globalThis.__fontFaceStringSourceProbe.local.settlement = error.name; }
+ );
+
+ const target = document.createElement('div');
+ target.style.fontFamily = 'MissingLocalFace';
+ globalThis.__fontFaceStringSourceProbe.local.afterDetachedStyle = local.status;
+ (document.body || document.documentElement || document).appendChild(target);
+ globalThis.__fontFaceStringSourceProbe.local.afterConnection = local.status;
+ await Promise.allSettled([remoteLoaded, invalid.loaded, local.loaded]);
+ return JSON.stringify(globalThis.__fontFaceStringSourceProbe);
+})()
+"#,
+ )
+ .await;
+
+ assert_eq!(
+ result,
+ r#"{"remote":{"before":"unloaded","stablePromise":true,"loadReturnsLoaded":true,"after":"loading","settlement":"resolved-self"},"invalid":{"status":"error","settlement":"SyntaxError"},"local":{"beforeStyle":"unloaded","afterDetachedStyle":"unloaded","afterConnection":"loading","settlement":"NetworkError"}}"#
+ );
+}
diff --git a/moli-renderer-v8/src/types.rs b/moli-renderer-v8/src/types.rs
index ff641ede288..1ae450c2982 100644
--- a/moli-renderer-v8/src/types.rs
+++ b/moli-renderer-v8/src/types.rs
@@ -80,6 +80,13 @@ pub use crate::protocol_types::{
WebSocketLifecycleEvent, WebSocketLifecycleKind, WebSocketNetworkEvent,
};
+pub(super) struct PendingFontFaceFetch {
+ pub(super) face: v8::Global,
+ pub(super) policy: crate::document_runtime::DocumentRequestPolicySnapshot,
+ pub(super) redirect_state: crate::network_host::FetchCspRedirectState,
+ pub(super) report_context: crate::network_host::WindowCspReportRequestContext,
+}
+
pub(super) enum PendingSubresourceContinuation {
Beacon,
CspReport {
@@ -87,6 +94,7 @@ pub(super) enum PendingSubresourceContinuation {
},
EventSource(v8::Global),
Fetch(PendingWindowFetchContinuation),
+ FontFace(Box),
Image {
image_handle: crate::document_runtime::DomHandle,
sequence: crate::native_bridge::ImageLoadEventId,
@@ -100,7 +108,6 @@ pub(super) enum PendingSubresourceContinuation {
track_handle: crate::document_runtime::DomHandle,
sequence: crate::native_bridge::TextTrackLoadSequenceId,
},
- FontFace(v8::Global),
StylesheetSubresource {
binding: crate::frame_owner_model::StylesheetSubresourceLoadDelayBinding,
target: crate::css_resource_urls::StylesheetSubresourceTarget,
@@ -176,7 +183,9 @@ impl PendingSubresourceContinuation {
..
} => *request_initiator_type,
Self::Media { .. } | Self::TextTrack { .. } => SubresourceRequestInitiatorType::Other,
- Self::StylesheetSubresource { .. } => SubresourceRequestInitiatorType::Css,
+ Self::StylesheetSubresource { .. } | Self::FontFace(_) => {
+ SubresourceRequestInitiatorType::Css
+ }
_ => SubresourceRequestInitiatorType::Script,
}
}
diff --git a/moli-test-support/src/routes_core.rs b/moli-test-support/src/routes_core.rs
index b12b6b0dfc7..413c1331851 100644
--- a/moli-test-support/src/routes_core.rs
+++ b/moli-test-support/src/routes_core.rs
@@ -1404,6 +1404,14 @@ pub(super) async fn servo_fontfaceset_load_ready_page() -> Html<&'static str> {
Html(SERVO_FONTFACESET_LOAD_READY_HTML)
}
+pub(super) async fn font_loading_fixture() -> Response {
+ (
+ [(CONTENT_TYPE, HeaderValue::from_static("font/ttf"))],
+ include_bytes!("../../moli-layout/tests/fixtures/moli-ahem.ttf").as_slice(),
+ )
+ .into_response()
+}
+
pub(super) async fn servo_fontfaceset_empty_family_load_page() -> Html<&'static str> {
Html(SERVO_FONTFACESET_EMPTY_FAMILY_LOAD_HTML)
}
diff --git a/moli-test-support/src/server_routes.rs b/moli-test-support/src/server_routes.rs
index c79ff1966ba..82b22e16d37 100644
--- a/moli-test-support/src/server_routes.rs
+++ b/moli-test-support/src/server_routes.rs
@@ -3,6 +3,7 @@ use super::*;
pub(super) fn build_router() -> Router {
routes_wait::add_wait_routes(Router::new())
.route("/static", get(static_page))
+ .route("/compat/font.ttf", get(font_loading_fixture))
.route("/compat/preload-count", get(preload_request_counter))
.route(
"/compat/child-dynamic-markup-document",
diff --git a/moli-wpt-compat/fixtures/wpt/ported/resources/font-fixture.js b/moli-wpt-compat/fixtures/wpt/ported/resources/font-fixture.js
new file mode 100644
index 00000000000..29268b96d2c
--- /dev/null
+++ b/moli-wpt-compat/fixtures/wpt/ported/resources/font-fixture.js
@@ -0,0 +1,3 @@
+// Valid TTF bytes from moli-layout/tests/fixtures/moli-ahem.ttf.
+// Use a data URL so these API tests do not depend on optional network resources.
+const fontFixtureSource = 'url("data:font/ttf;base64,AAEAAAAKAIAAAwAgT1MvMkgiSDMAAAEoAAAAYGNtYXABEgIlAAACUAAAAERnbHlmyb+UdAAAA1wAAAkYaGVhZFm5pQAAAACsAAAANmhoZWEFegGSAAAA5AAAACRobXR4AlgAAAAAAYgAAADGbG9jYXCMbkwAAAKUAAAAxm1heHAAZAAGAAABCAAAACBuYW1liiBnMwAADHQAAAGPcG9zdIMIFxAAAA4EAAAD5gABAAAAAQAAwGeQDl8PPPUAAwPoAAAAAHwlsIAAAAAAfCWwgAAAAAACWAMgAAAAAwACAAAAAAAAAAEAAAMg/zgAAAJYAAAAAAJYAAEAAAAAAAAAAAAAAAAAAAABAAEAAABiAAQAAQAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAwJYAZAABQAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAAAAAAAAAAAAAAAPz8/PwBAACAA3wMg/zgAAAMgAMgAAAAAAAAAAAMgAyAAAAAgAAACWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAADAAAAFAADAAEAAAAUAAQAMAAAAAgACAACAAAAfgCgAN///wAAACAAoADf////4f/A/4IAAQAAAAAAAAAAAAAADAAMABgAJAAwADwASABUAGAAbAB4AIQAkACcAKgAtADAAMwA2ADkAPAA/AEIARQBIAEsATgBRAFQAVwBaAF0AYABjAGYAaQBsAG8AcgB1AHgAewB+AIEAhACHAIoAjQCQAJMAlgCZAJwAnwCiAKUAqACrAK4AsQC0ALcAugC9AMAAwwDGAMkAzADPANIA1QDYANsA3gDhAOQA5wDqAO0A8ADzAPYA+QD8AP8BAgEFAQgBCwEOAREBFAEXARoBHQEgASMAAAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAQAAAAACWAMgAAMAADEhESECWP2oAyAAAAAMAJYAAQAAAAAAAQAJAAAAAQAAAAAAAgAHAAkAAQAAAAAAAwAVABAAAQAAAAAABAARACUAAQAAAAAABQANADYAAQAAAAAABgAQAEMAAwABBAkAAQASAFMAAwABBAkAAgAOAGUAAwABBAkAAwAqAHMAAwABBAkABAAiAJ0AAwABBAkABQAaAL8AAwABBAkABgAgANlNb2xpIEFoZW1SZWd1bGFyTW9saSBBaGVtIFJlZ3VsYXIgMS4wTW9saSBBaGVtIFJlZ3VsYXJWZXJzaW9uIDEuMDAwTW9saUFoZW0tUmVndWxhcgBNAG8AbABpACAAQQBoAGUAbQBSAGUAZwB1AGwAYQByAE0AbwBsAGkAIABBAGgAZQBtACAAUgBlAGcAdQBsAGEAcgAgADEALgAwAE0AbwBsAGkAIABBAGgAZQBtACAAUgBlAGcAdQBsAGEAcgBWAGUAcgBzAGkAbwBuACAAMQAuADAAMAAwAE0AbwBsAGkAQQBoAGUAbQAtAFIAZQBnAHUAbABhAHIAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYgAAAAMBAgEDAQQBBQEGAQcBCAEJAQoBCwEMAQ0BDgEPARABEQESARMBFAEVARYBFwEYARkBGgEbARwBHQEeAR8BIAEhASIBIwEkASUBJgEnASgBKQEqASsBLAEtAS4BLwEwATEBMgEzATQBNQE2ATcBOAE5AToBOwE8AT0BPgE/AUABQQFCAUMBRAFFAUYBRwFIAUkBSgFLAUwBTQFOAU8BUAFRAVIBUwFUAVUBVgFXAVgBWQFaAVsBXAFdAV4BXwFgAWEHdW5pMDAyMQd1bmkwMDIyB3VuaTAwMjMHdW5pMDAyNAd1bmkwMDI1B3VuaTAwMjYHdW5pMDAyNwd1bmkwMDI4B3VuaTAwMjkHdW5pMDAyQQd1bmkwMDJCB3VuaTAwMkMHdW5pMDAyRAd1bmkwMDJFB3VuaTAwMkYHdW5pMDAzMAd1bmkwMDMxB3VuaTAwMzIHdW5pMDAzMwd1bmkwMDM0B3VuaTAwMzUHdW5pMDAzNgd1bmkwMDM3B3VuaTAwMzgHdW5pMDAzOQd1bmkwMDNBB3VuaTAwM0IHdW5pMDAzQwd1bmkwMDNEB3VuaTAwM0UHdW5pMDAzRgd1bmkwMDQwB3VuaTAwNDEHdW5pMDA0Mgd1bmkwMDQzB3VuaTAwNDQHdW5pMDA0NQd1bmkwMDQ2B3VuaTAwNDcHdW5pMDA0OAd1bmkwMDQ5B3VuaTAwNEEHdW5pMDA0Qgd1bmkwMDRDB3VuaTAwNEQHdW5pMDA0RQd1bmkwMDRGB3VuaTAwNTAHdW5pMDA1MQd1bmkwMDUyB3VuaTAwNTMHdW5pMDA1NAd1bmkwMDU1B3VuaTAwNTYHdW5pMDA1Nwd1bmkwMDU4B3VuaTAwNTkHdW5pMDA1QQd1bmkwMDVCB3VuaTAwNUMHdW5pMDA1RAd1bmkwMDVFB3VuaTAwNUYHdW5pMDA2MAd1bmkwMDYxB3VuaTAwNjIHdW5pMDA2Mwd1bmkwMDY0B3VuaTAwNjUHdW5pMDA2Ngd1bmkwMDY3B3VuaTAwNjgHdW5pMDA2OQd1bmkwMDZBB3VuaTAwNkIHdW5pMDA2Qwd1bmkwMDZEB3VuaTAwNkUHdW5pMDA2Rgd1bmkwMDcwB3VuaTAwNzEHdW5pMDA3Mgd1bmkwMDczB3VuaTAwNzQHdW5pMDA3NQd1bmkwMDc2B3VuaTAwNzcHdW5pMDA3OAd1bmkwMDc5B3VuaTAwN0EHdW5pMDA3Qgd1bmkwMDdDB3VuaTAwN0QHdW5pMDA3RQd1bmkwMEEwB3VuaTAwREYAAA==")';