Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

feat(media): expose native time range snapshots

ldm079e383340aa1
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index 0d5e163d5..2fd695ee3 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -27,6 +27,7 @@ mod form_data_runtime;
mod geometry_runtime;
mod history_mutation;
mod history_runtime;
+mod time_ranges;
pub(crate) mod web_mcp;
pub(crate) use history_runtime::state::bind_isolated_window_history_owner;
mod idle_detection;
@@ -449,6 +450,7 @@ pub(crate) use self::streams::{
prepare_readable_stream_transfer, prepare_transform_stream_transfer,
prepare_writable_stream_transfer,
};
+pub(crate) use self::time_ranges::new_time_ranges_value;
#[cfg(test)]
pub(crate) use self::trusted_types::trusted_types_lazy_state_materialized;
pub(crate) use self::trusted_types::{
diff --git a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs
index af68cc657..13d15b5f7 100644
--- a/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs
+++ b/moli-renderer-v8/src/context_bootstrap/assets/prototype_bindings.rs
@@ -50,6 +50,7 @@ use super::super::{
streams::install_stream_template_bindings,
style_font_template::install_style_font_template_bindings,
svg_runtime::install_svg_template_bindings,
+ time_ranges::install_time_ranges_template_bindings,
touch_runtime::install_touch_template_bindings,
view_transition_runtime::install_view_transition_template_bindings,
web_audio_runtime::{
@@ -409,6 +410,7 @@ pub(super) fn install_constructor_template_bindings<'s>(
install_abort_template_bindings(scope, template, spec.interface.name());
install_attr_template_bindings(scope, template, spec.interface.name());
install_dom_rect_template_bindings(scope, template, spec.interface.name());
+ install_time_ranges_template_bindings(scope, template, spec.interface.name());
install_dom_exception_template_bindings(scope, template, spec.interface.name());
install_dom_implementation_template_bindings(scope, template, spec.interface.name());
install_custom_element_registry_template_bindings(scope, template, spec.interface.name());
diff --git a/moli-renderer-v8/src/context_bootstrap/time_ranges.rs b/moli-renderer-v8/src/context_bootstrap/time_ranges.rs
new file mode 100644
index 000000000..830110d9f
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/time_ranges.rs
@@ -0,0 +1,140 @@
+//! Immutable time-range snapshots, independent of a media decoder.
+
+use crate::{util::get_private_value, web_api_interfaces, webidl};
+use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject};
+
+const RANGES_SLOT: &str = "__moliTimeRanges";
+
+#[derive(WebApiObject)]
+#[webapi(interface = web_api_interfaces::TimeRanges, require_prototype)]
+struct TimeRangesObjectDeclaration<'scope> {
+ #[webapi(slot = RANGES_SLOT)]
+ ranges: v8::Local<'scope, v8::Array>,
+}
+
+#[derive(WebApiFunctionTemplate)]
+#[webapi(interface = web_api_interfaces::TimeRanges, enumerable, receiver)]
+struct TimeRangesPrototypeDeclaration {
+ #[webapi(accessor_property, getter = length_getter)]
+ length: (),
+ #[webapi(method, length = 1, callback = start_callback)]
+ start: (),
+ #[webapi(method, length = 1, callback = end_callback)]
+ end: (),
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "TimeRanges.start")]
+struct StartArgs {
+ #[webidl(required)]
+ index: u32,
+}
+
+#[derive(webidl::WebIdlArgs)]
+#[webidl(prefix = "TimeRanges.end")]
+struct EndArgs {
+ #[webidl(required)]
+ index: u32,
+}
+
+/// Copies native, normalized intervals into a new snapshot in the current realm.
+/// Adjacent/overlapping intervals must be merged by the producing media backend.
+pub(crate) fn new_time_ranges_value<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ ranges: &[(f64, f64)],
+) -> v8::Local<'s, v8::Object> {
+ debug_assert!(ranges.iter().all(|(start, end)| start <= end));
+ debug_assert!(ranges.windows(2).all(|pair| pair[0].1 < pair[1].0));
+ let values: Vec<v8::Local<'s, v8::Value>> = ranges
+ .iter()
+ .flat_map(|&(start, end)| {
+ [
+ v8::Number::new(scope, start).into(),
+ v8::Number::new(scope, end).into(),
+ ]
+ })
+ .collect();
+ let values = v8::Array::new_with_elements(scope, &values);
+ TimeRangesObjectDeclaration::new(values)
+ .bind(scope)
+ .expect("TimeRanges snapshot binds")
+}
+
+pub(in crate::context_bootstrap) fn install_time_ranges_template_bindings<'s>(
+ scope: &mut v8::PinScope<'s, '_, ()>,
+ template: v8::Local<'s, v8::FunctionTemplate>,
+ interface_name: &str,
+) {
+ if interface_name == "TimeRanges" {
+ TimeRangesPrototypeDeclaration::initialize_prototype_template(
+ scope,
+ template.prototype_template(scope),
+ );
+ }
+}
+
+fn native_ranges<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+) -> v8::Local<'s, v8::Array> {
+ let target = moli_webapi_declare::web_api_object_target(scope, receiver)
+ .expect("validated TimeRanges receiver");
+ v8::Local::<v8::Array>::try_from(
+ get_private_value(scope, target, RANGES_SLOT).expect("TimeRanges snapshot slot"),
+ )
+ .expect("TimeRanges native interval array")
+}
+
+fn length_getter<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ rv.set_uint32(native_ranges(scope, args.this()).length() / 2);
+}
+
+fn start_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ let Some(parsed) = webidl::parse_args::<StartArgs>(scope, &args) else {
+ return;
+ };
+ endpoint(scope, args.this(), parsed.index, 0, rv);
+}
+
+fn end_callback<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ let Some(parsed) = webidl::parse_args::<EndArgs>(scope, &args) else {
+ return;
+ };
+ endpoint(scope, args.this(), parsed.index, 1, rv);
+}
+
+fn endpoint<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+ index: u32,
+ offset: u32,
+ mut rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ let ranges = native_ranges(scope, receiver);
+ if index >= ranges.length() / 2 {
+ super::constructors::throw_dom_exception_value(
+ scope,
+ "The index is outside the time ranges.",
+ "IndexSizeError",
+ );
+ return;
+ }
+ // Check the native size before multiplying, including for wrapped uint32 indices.
+ rv.set(
+ ranges
+ .get_index(scope, index * 2 + offset)
+ .expect("native endpoint"),
+ );
+}
diff --git a/moli-renderer-v8/src/native_bridge/element.rs b/moli-renderer-v8/src/native_bridge/element.rs
index 29effdfae..c1957e8b3 100644
--- a/moli-renderer-v8/src/native_bridge/element.rs
+++ b/moli-renderer-v8/src/native_bridge/element.rs
@@ -547,8 +547,8 @@ pub(crate) use media::{
};
pub(super) use media::{
apply_default_text_track_modes_for_media, media_add_text_track_callback,
- media_autoplay_getter_function, media_autoplay_setter_function, media_can_play_type_callback,
- media_controls_getter_function, media_controls_setter_function,
+ media_autoplay_getter_function, media_autoplay_setter_function, media_buffered_getter_function,
+ media_can_play_type_callback, media_controls_getter_function, media_controls_setter_function,
media_cross_origin_getter_function, media_cross_origin_setter_function,
media_current_time_getter_function, media_current_time_setter_function,
media_default_muted_getter_function, media_default_muted_setter_function,
@@ -558,9 +558,10 @@ pub(super) use media::{
media_loop_setter_function, media_muted_getter_function, media_muted_setter_function,
media_network_state_getter_function, media_pause_callback, media_paused_getter_function,
media_play_callback, media_playback_rate_getter_function, media_playback_rate_setter_function,
- media_plays_inline_getter_function, media_plays_inline_setter_function,
- media_poster_getter_function, media_poster_setter_function, media_preload_getter_function,
- media_preload_setter_function, media_ready_state_getter_function,
+ media_played_getter_function, media_plays_inline_getter_function,
+ media_plays_inline_setter_function, media_poster_getter_function, media_poster_setter_function,
+ media_preload_getter_function, media_preload_setter_function,
+ media_ready_state_getter_function, media_seekable_getter_function,
media_seeking_getter_function, media_src_getter_function, media_src_setter_function,
media_text_tracks_getter_function, media_video_height_getter_function,
media_video_width_getter_function, media_volume_getter_function, media_volume_setter_function,
diff --git a/moli-renderer-v8/src/native_bridge/element/media.rs b/moli-renderer-v8/src/native_bridge/element/media.rs
index b1b6aa1eb..7938443b2 100644
--- a/moli-renderer-v8/src/native_bridge/element/media.rs
+++ b/moli-renderer-v8/src/native_bridge/element/media.rs
@@ -2,6 +2,7 @@ mod attributes;
mod methods;
mod state;
mod text_tracks;
+mod time_ranges;
mod video;
pub(crate) use attributes::{
@@ -44,6 +45,9 @@ pub(in crate::native_bridge) use text_tracks::{
refresh_media_active_text_track_cues, track_ready_state_for_handle,
track_text_track_getter_function,
};
+pub(in crate::native_bridge) use time_ranges::{
+ media_buffered_getter_function, media_played_getter_function, media_seekable_getter_function,
+};
pub(in crate::native_bridge) use video::{
media_height_getter_function, media_height_setter_function, media_poster_getter_function,
media_poster_setter_function, media_video_height_getter_function,
diff --git a/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs b/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs
new file mode 100644
index 000000000..a375cb868
--- /dev/null
+++ b/moli-renderer-v8/src/native_bridge/element/media/time_ranges.rs
@@ -0,0 +1,40 @@
+use super::super::html_media_element_getter_receiver;
+
+pub(in crate::native_bridge) fn media_buffered_getter_function<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ media_ranges_getter(scope, args.this(), "buffered", rv);
+}
+
+pub(in crate::native_bridge) fn media_played_getter_function<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ media_ranges_getter(scope, args.this(), "played", rv);
+}
+
+pub(in crate::native_bridge) fn media_seekable_getter_function<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ media_ranges_getter(scope, args.this(), "seekable", rv);
+}
+
+fn media_ranges_getter<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+ member: &'static str,
+ mut rv: v8::ReturnValue<'_, v8::Value>,
+) {
+ if html_media_element_getter_receiver(scope, receiver, member).is_none() {
+ return;
+ }
+ // The current media backend does not decode/buffer media or advance a
+ // playback timeline. Do not invent loaded or played ranges from currentTime.
+ // Each read still returns an independent native snapshot.
+ rv.set(crate::context_bootstrap::new_time_ranges_value(scope, &[]).into());
+}
diff --git a/moli-renderer-v8/src/native_bridge/element/media_elements.rs b/moli-renderer-v8/src/native_bridge/element/media_elements.rs
index 8eb0b4b0d..268bbffbd 100644
--- a/moli-renderer-v8/src/native_bridge/element/media_elements.rs
+++ b/moli-renderer-v8/src/native_bridge/element/media_elements.rs
@@ -13,8 +13,14 @@ pub(super) struct HtmlHtmlElementPrototypeDeclaration {
}
#[derive(WebApiFunctionTemplate)]
-#[webapi(interface = web_api_interfaces::HTMLMediaElement, enumerable)]
+#[webapi(interface = web_api_interfaces::HTMLMediaElement, enumerable, receiver)]
pub(super) struct HtmlMediaElementPrototypeDeclaration {
+ #[webapi(accessor_property, getter = media_buffered_getter_function)]
+ buffered: (),
+ #[webapi(accessor_property, getter = media_played_getter_function)]
+ played: (),
+ #[webapi(accessor_property, getter = media_seekable_getter_function)]
+ seekable: (),
#[webapi(accessor_property, getter = media_error_getter_function)]
error: (),
#[webapi(
diff --git a/moli-renderer-v8/src/script_vm/tests/mod.rs b/moli-renderer-v8/src/script_vm/tests/mod.rs
index a4d677c23..47566f449 100644
--- a/moli-renderer-v8/src/script_vm/tests/mod.rs
+++ b/moli-renderer-v8/src/script_vm/tests/mod.rs
@@ -2171,6 +2171,7 @@ mod svg_filter_interfaces;
mod svg_number_validation;
mod svg_root_factory_receivers;
mod svg_switch_mpath_interfaces;
+mod time_ranges;
mod url_components;
mod webgl_interfaces;
mod webidl_collections;
diff --git a/moli-renderer-v8/src/script_vm/tests/time_ranges.js b/moli-renderer-v8/src/script_vm/tests/time_ranges.js
new file mode 100644
index 000000000..f55d47bab
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/time_ranges.js
@@ -0,0 +1,139 @@
+(() => {
+ const checks = [];
+ const equal = (actual, expected) => {
+ if (!Object.is(actual, expected)) throw Error(`expected ${String(expected)}, got ${String(actual)}`);
+ };
+ const throws = (realm, name, run) => {
+ let error;
+ try { run(); } catch (caught) { error = caught; }
+ const C = name === 'TypeError' ? realm.TypeError : realm.DOMException;
+ if (!error || error.name !== name || !(error instanceof C)) throw Error(`expected ${name} in callee realm, got ${error}`);
+ return error;
+ };
+ const realms = [globalThis, document.getElementById('child').contentWindow];
+ for (const [index, realm] of realms.entries()) {
+ const C = realm.TimeRanges, prototype = C.prototype;
+ const getLength = Object.getOwnPropertyDescriptor(prototype, 'length')?.get;
+ const test = (name, run) => {
+ try { run(); checks.push({realm: index, name, passed: true}); }
+ catch (error) { checks.push({realm: index, name, passed: false, error: String(error), stack: error.stack}); }
+ };
+ test('interface metadata and illegal constructor', () => {
+ equal(C.name, 'TimeRanges'); equal(C.length, 0); equal(prototype.constructor, C);
+ equal(Object.getPrototypeOf(C), realm.Function.prototype);
+ equal(Object.getPrototypeOf(prototype), realm.Object.prototype);
+ const tag = Object.getOwnPropertyDescriptor(prototype, Symbol.toStringTag);
+ equal(tag.value, 'TimeRanges'); equal(tag.writable, false); equal(tag.enumerable, false); equal(tag.configurable, true);
+ for (const run of [() => C(), () => new C(), () => Reflect.construct(C, [], function Other() {})]) throws(realm, 'TypeError', run);
+ });
+ test('length descriptor', () => {
+ const d = Object.getOwnPropertyDescriptor(prototype, 'length');
+ equal(d.enumerable, true); equal(d.configurable, true); equal(d.set, undefined);
+ equal(d.get.name, 'get length'); equal(d.get.length, 0); equal(Object.getPrototypeOf(d.get), realm.Function.prototype);
+ });
+ for (const name of ['start', 'end']) test(`${name} descriptor`, () => {
+ const d = Object.getOwnPropertyDescriptor(prototype, name);
+ equal(d.enumerable, true); equal(d.configurable, true); equal(d.writable, true);
+ equal(d.value.name, name); equal(d.value.length, 1); equal(Object.getPrototypeOf(d.value), realm.Function.prototype);
+ });
+ const factories = [
+ ['video', () => realm.document.createElement('video')],
+ ['audio', () => realm.document.createElement('audio')],
+ ['Audio', () => new realm.Audio()],
+ ['windowless video', () => realm.document.implementation.createHTMLDocument('').createElement('video')],
+ ];
+ for (const property of ['buffered', 'played', 'seekable']) {
+ const get = Object.getOwnPropertyDescriptor(realm.HTMLMediaElement.prototype, property)?.get;
+ test(`${property} descriptor`, () => {
+ const d = Object.getOwnPropertyDescriptor(realm.HTMLMediaElement.prototype, property);
+ equal(d.enumerable, true); equal(d.configurable, true); equal(d.set, undefined);
+ equal(get.name, `get ${property}`); equal(get.length, 0); equal(Object.getPrototypeOf(get), realm.Function.prototype);
+ });
+ for (const [label, factory] of factories) test(`${property} fresh empty snapshots from ${label}`, () => {
+ const media = factory(), a = get.call(media), b = get.call(media);
+ equal(a === b, false); equal(a.length, 0); equal(b.length, 0);
+ equal(Object.getPrototypeOf(a), prototype); equal(Object.prototype.toString.call(a), '[object TimeRanges]');
+ equal(a.constructor, C); equal(Object.keys(a).length, 0); equal(Array.isArray(a), false);
+ equal(0 in a, false); equal(a[Symbol.iterator], undefined); equal(Reflect.set(a, 'length', 9), false);
+ a.extra = 'author'; equal(b.extra, undefined); equal(getLength.call(a), 0);
+ });
+ test(`${property} accepts foreign native media in callee realm`, () => {
+ const foreign = realms[1 - index].document.createElement('video'), ranges = get.call(foreign);
+ equal(Object.getPrototypeOf(ranges), prototype); equal(getLength.call(ranges), 0);
+ });
+ test(`${property} rejects forged and proxy media without author traps`, () => {
+ let traps = 0;
+ const media = realm.document.createElement('video');
+ const revoked = Proxy.revocable(media, {}); revoked.revoke();
+ const receivers = [{}, Object.create(realm.HTMLMediaElement.prototype), Object.create(media),
+ realm.document.createElement('div'), new Proxy(media, {get() {traps++;}, getPrototypeOf() {traps++;}}), revoked.proxy];
+ for (const receiver of receivers) throws(realm, 'TypeError', () => get.call(receiver));
+ equal(traps, 0);
+ });
+ }
+ for (const name of ['start', 'end']) {
+ const method = prototype[name];
+ const values = [['undefined', undefined], ['null', null], ['false', false], ['true', true], ['zero', 0],
+ ['negative zero', -0], ['one', 1], ['fraction', 0.9], ['negative fraction', -0.9], ['negative', -1],
+ ['nan', NaN], ['positive infinity', Infinity], ['negative infinity', -Infinity],
+ ['uint32 wrap', 2 ** 32], ['wrapped negative', -(2 ** 32)], ['maximum', 2 ** 32 - 1], ['numeric string', '0']];
+ for (const [label, value] of values) test(`${name} empty index ${label}`, () => {
+ const ranges = realm.document.createElement('video').buffered;
+ const error = throws(realm, 'IndexSizeError', () => method.call(ranges, value)); equal(error.code, 1);
+ });
+ test(`${name} requires an argument before bounds`, () => throws(realm, 'TypeError', () => method.call(realm.document.createElement('video').buffered)));
+ for (const [label, value] of [['symbol', Symbol()], ['bigint', 0n]]) test(`${name} rejects ${label} indices`, () =>
+ throws(realm, 'TypeError', () => method.call(realm.document.createElement('video').buffered, value)));
+ test(`${name} converts exactly once and propagates author exceptions`, () => {
+ let conversions = 0; const ranges = realm.document.createElement('video').buffered;
+ throws(realm, 'IndexSizeError', () => method.call(ranges, {[Symbol.toPrimitive](hint) {equal(hint, 'number'); conversions++; return 0;}}));
+ equal(conversions, 1);
+ const marker = {}; let caught;
+ try { method.call(ranges, {valueOf() {throw marker;}}); } catch (error) {caught = error;}
+ equal(caught, marker);
+ });
+ test(`${name} receiver validation precedes conversion and proxy traps`, () => {
+ let calls = 0; const ranges = realm.document.createElement('video').buffered;
+ const input = {valueOf() {calls++; return 0;}};
+ const revoked = Proxy.revocable({}, {}); revoked.revoke();
+ for (const receiver of [{}, Object.create(prototype), Object.create(ranges), new Proxy(ranges, {get() {calls++;}}), revoked.proxy])
+ throws(realm, 'TypeError', () => method.call(receiver, input));
+ equal(calls, 0);
+ });
+ test(`${name} accepts foreign snapshots and throws callee DOMException`, () => {
+ const ranges = realms[1 - index].document.createElement('audio').seekable;
+ throws(realm, 'IndexSizeError', () => method.call(ranges, 0));
+ });
+ }
+ test('length receiver checks reject author proxies and forged prototypes', () => {
+ const ranges = realm.document.createElement('video').buffered; let traps = 0;
+ const revoked = Proxy.revocable(ranges, {}); revoked.revoke();
+ for (const receiver of [{}, Object.create(prototype), Object.create(ranges), new Proxy(ranges, {get() {traps++;}}), revoked.proxy])
+ throws(realm, 'TypeError', () => getLength.call(receiver));
+ equal(traps, 0);
+ });
+ test('public properties do not change native length or bounds', () => {
+ const ranges = realm.document.createElement('video').played;
+ Object.defineProperty(ranges, 'length', {get() {throw Error('author length');}});
+ ranges.__moliTimeRanges = [1, 2]; ranges[0] = 10;
+ equal(getLength.call(ranges), 0); throws(realm, 'IndexSizeError', () => prototype.start.call(ranges, 0));
+ Object.setPrototypeOf(ranges, null); equal(getLength.call(ranges), 0);
+ Object.freeze(ranges); throws(realm, 'IndexSizeError', () => prototype.end.call(ranges, 0));
+ });
+ test('cloning rejects nested TimeRanges without public getter evaluation', () => {
+ const ranges = realm.document.createElement('video').buffered; let gets = 0;
+ Object.defineProperty(ranges, 'extra', {enumerable: true, get() {gets++; throw Error('author getter');}});
+ throws(realm, 'DataCloneError', () => realm.structuredClone({ranges})); equal(gets, 0);
+ });
+ test('fresh media snapshots survive global constructor overrides', () => {
+ const descriptor = Object.getOwnPropertyDescriptor(realm, 'TimeRanges');
+ try {
+ Object.defineProperty(realm, 'TimeRanges', {value: function() {throw Error('author constructor');}, configurable: true});
+ const ranges = realm.document.createElement('video').buffered;
+ equal(Object.getPrototypeOf(ranges), prototype); equal(getLength.call(ranges), 0);
+ } finally {Object.defineProperty(realm, 'TimeRanges', descriptor);}
+ });
+ }
+ globalThis.__uiEventResults = {complete: true, checks};
+ return true;
+})()
diff --git a/moli-renderer-v8/src/script_vm/tests/time_ranges.rs b/moli-renderer-v8/src/script_vm/tests/time_ranges.rs
new file mode 100644
index 000000000..c0952254c
--- /dev/null
+++ b/moli-renderer-v8/src/script_vm/tests/time_ranges.rs
@@ -0,0 +1,75 @@
+use super::*;
+
+#[test]
+fn time_ranges_snapshots_preserve_native_brands_conversion_and_realms() {
+ let mut vm = new_storage_page_task_executor_test_vm("https://time-ranges.test/");
+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")
+ .unwrap();
+ vm.eval(include_str!("time_ranges.js")).unwrap();
+ assert_eq!(vm.eval("__uiEventResults.complete").unwrap(), "true");
+ assert_eq!(
+ vm.eval("JSON.stringify(__uiEventResults.checks.filter(row => !row.passed))")
+ .unwrap(),
+ "[]"
+ );
+}
+
+#[test]
+fn time_ranges_nonempty_native_snapshots_preserve_endpoints_and_uint32_conversion() {
+ let mut vm = new_storage_page_task_executor_test_vm("https://time-ranges-native.test/");
+ vm.eval("document.body.innerHTML = '<iframe id=child></iframe>'")
+ .unwrap();
+ let context_ptr = &vm.page_default_context as *const _;
+ vm.with_context_scope_by_ptr_and_checkpoint_for_test(context_ptr, |scope, _| {
+ let intervals = [(-3.5, -1.0), (0.0, 0.0), (0.25, 1.75), (4.0, f64::INFINITY)];
+ let ranges = crate::context_bootstrap::new_time_ranges_value(scope, &intervals);
+ let global = scope.get_current_context().global(scope);
+ let key = crate::util::v8str(scope, "nativeRanges");
+ assert_eq!(
+ global.create_data_property(scope, key.into(), ranges.into()),
+ Some(true)
+ );
+ // The endpoint backing array is inaccessible to author code. Register a
+ // native Proxy to exercise the shared identity path independently.
+ let handler = crate::util::new_null_prototype_object(scope);
+ let proxy = v8::Proxy::new(scope, ranges, handler).unwrap();
+ moli_webapi_declare::register_web_api_proxy(scope, proxy).unwrap();
+ let key = crate::util::v8str(scope, "nativeRangesProxy");
+ assert_eq!(
+ global.create_data_property(scope, key.into(), proxy.into()),
+ Some(true)
+ );
+ Ok(())
+ })
+ .unwrap();
+ assert_eq!(vm.eval(r#"(() => {
+ const snapshots = [nativeRanges, nativeRangesProxy];
+ const realms = [globalThis, document.getElementById('child').contentWindow];
+ const starts = [-3.5, 0, 0.25, 4], ends = [-1, 0, 1.75, Infinity];
+ const equal = (a, b) => {if (!Object.is(a, b)) throw Error(`expected ${b}, got ${a}`);};
+ const error = (realm, name, run) => {
+ let caught; try {run();} catch(e) {caught = e;}
+ if (!caught || caught.name !== name || !(caught instanceof (name === 'TypeError' ? realm.TypeError : realm.DOMException))) throw Error('wrong exception');
+ };
+ for (const realm of realms) for (const ranges of snapshots) {
+ const p = realm.TimeRanges.prototype;
+ equal(Object.getOwnPropertyDescriptor(p, 'length').get.call(ranges), 4);
+ for (let i = 0; i < 4; i++) {equal(p.start.call(ranges, i), starts[i]); equal(p.end.call(ranges, i), ends[i]);}
+ for (const [input, index] of [[NaN, 0], [Infinity, 0], [-Infinity, 0], [2**32, 0], [-(2**32), 0],
+ [null, 0], [undefined, 0], ['2', 2], [1.9, 1], [-0.9, 0], [true, 1], [2**32 + 2, 2]]) {
+ equal(p.start.call(ranges, input), starts[index]); equal(p.end.call(ranges, input), ends[index]);
+ }
+ for (const input of [-1, 4, 2**32 - 1]) for (const name of ['start', 'end']) error(realm, 'IndexSizeError', () => p[name].call(ranges, input));
+ for (const input of [Symbol(), 0n]) for (const name of ['start', 'end']) error(realm, 'TypeError', () => p[name].call(ranges, input));
+ let reads = 0;
+ equal(p.start.call(ranges, {valueOf() {reads++; return 2;}}), 0.25); equal(reads, 1);
+ const authorProxy = new Proxy(ranges, {get() {reads++;}});
+ error(realm, 'TypeError', () => p.start.call(authorProxy, {valueOf() {reads++; return 0;}})); equal(reads, 1);
+ }
+ Object.defineProperty(nativeRanges, 'length', {value: 900}); nativeRanges.__moliTimeRanges = [100, 200];
+ Object.setPrototypeOf(nativeRanges, null); Object.freeze(nativeRanges);
+ equal(TimeRanges.prototype.start.call(nativeRanges, 2), 0.25);
+ equal(TimeRanges.prototype.end.call(nativeRanges, 3), Infinity);
+ return true;
+ })()"#).unwrap(), "true");
+}