mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
Expose secure MIDI requests, native receiver validation, port interface members, and live readonly maplike operations. Reuse shared WebIDL dictionary, sequence, callback and octet conversions. Device requests and port I/O reject explicitly until a platform MIDI backend is available.
695 lines
26 KiB
Rust
695 lines
26 KiB
Rust
use crate::callbacks::invoke_synchronous_webidl_callback_function;
|
|
use crate::interfaces as web_api_interfaces;
|
|
use anyhow::{Result, anyhow};
|
|
use moli_v8_util::{
|
|
get_private_object, get_private_value, materialize_hidden_function_template_prototype,
|
|
set_private_value, throw_type_error, v8str,
|
|
};
|
|
use moli_webapi_declare::{WebApiFunctionTemplate, WebApiObject, v8};
|
|
use moli_webidl as webidl;
|
|
|
|
const SNAPSHOT_ITERATOR_VALUES_SLOT: &str = "__moliWebIdlIteratorValues";
|
|
const SNAPSHOT_ITERATOR_INDEX_SLOT: &str = "__moliWebIdlIteratorIndex";
|
|
const NATIVE_COLLECTION_ITERATOR_SLOT: &str = "__moliWebIdlNativeCollectionIterator";
|
|
const NATIVE_COLLECTION_ITERATOR_NEXT_SLOT: &str = "__moliWebIdlNativeCollectionIteratorNext";
|
|
const NATIVE_SET_ENTRIES_INTRINSIC_SLOT: &str = "__moliSetEntriesIntrinsic";
|
|
const NATIVE_SET_KEYS_INTRINSIC_SLOT: &str = "__moliSetKeysIntrinsic";
|
|
const NATIVE_SET_VALUES_INTRINSIC_SLOT: &str = "__moliSetValuesIntrinsic";
|
|
const NATIVE_SET_ITERATOR_NEXT_INTRINSIC_SLOT: &str = "__moliSetIteratorNextIntrinsic";
|
|
const NATIVE_REFLECT_APPLY_INTRINSIC_SLOT: &str = "__moliReflectApplyIntrinsic";
|
|
const NATIVE_REFLECT_CONSTRUCT_INTRINSIC_SLOT: &str = "__moliReflectConstructIntrinsic";
|
|
const NATIVE_MAP_ENTRIES_INTRINSIC_SLOT: &str = "__moliMapEntriesIntrinsic";
|
|
const NATIVE_MAP_KEYS_INTRINSIC_SLOT: &str = "__moliMapKeysIntrinsic";
|
|
const NATIVE_MAP_VALUES_INTRINSIC_SLOT: &str = "__moliMapValuesIntrinsic";
|
|
const NATIVE_MAP_ITERATOR_NEXT_INTRINSIC_SLOT: &str = "__moliMapIteratorNextIntrinsic";
|
|
const STYLE_PROPERTY_MAP_ITERATOR_PROTOTYPE_SLOT: &str = "__moliStylePropertyMapIteratorPrototype";
|
|
const EVENT_COUNTS_ITERATOR_PROTOTYPE_SLOT: &str = "__moliEventCountsIteratorPrototype";
|
|
const FONT_FACE_SET_ITERATOR_PROTOTYPE_SLOT: &str = "__moliFontFaceSetIteratorPrototype";
|
|
const VIEW_TRANSITION_TYPE_SET_ITERATOR_PROTOTYPE_SLOT: &str =
|
|
"__moliViewTransitionTypeSetIteratorPrototype";
|
|
const CUSTOM_STATE_SET_ITERATOR_PROTOTYPE_SLOT: &str = "__moliCustomStateSetIteratorPrototype";
|
|
const CSS_FONT_FEATURE_VALUES_MAP_ITERATOR_PROTOTYPE_SLOT: &str =
|
|
"__moliCssFontFeatureValuesMapIteratorPrototype";
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum SnapshotWebIdlIteratorKind {
|
|
StylePropertyMapReadOnly,
|
|
EventCounts,
|
|
FontFaceSet,
|
|
CssFontFeatureValuesMap,
|
|
}
|
|
|
|
impl SnapshotWebIdlIteratorKind {
|
|
const fn interface(self) -> &'static str {
|
|
match self {
|
|
Self::StylePropertyMapReadOnly => "StylePropertyMapReadOnly Iterator",
|
|
Self::EventCounts => "EventCounts Iterator",
|
|
Self::FontFaceSet => "FontFaceSet Iterator",
|
|
Self::CssFontFeatureValuesMap => "CSSFontFeatureValuesMap Iterator",
|
|
}
|
|
}
|
|
|
|
const fn prototype_slot(self) -> &'static str {
|
|
match self {
|
|
Self::StylePropertyMapReadOnly => STYLE_PROPERTY_MAP_ITERATOR_PROTOTYPE_SLOT,
|
|
Self::EventCounts => EVENT_COUNTS_ITERATOR_PROTOTYPE_SLOT,
|
|
Self::FontFaceSet => FONT_FACE_SET_ITERATOR_PROTOTYPE_SLOT,
|
|
Self::CssFontFeatureValuesMap => CSS_FONT_FEATURE_VALUES_MAP_ITERATOR_PROTOTYPE_SLOT,
|
|
}
|
|
}
|
|
|
|
fn build_template<'s>(
|
|
self,
|
|
scope: &mut v8::PinScope<'s, '_, ()>,
|
|
) -> v8::Local<'s, v8::FunctionTemplate> {
|
|
match self {
|
|
Self::StylePropertyMapReadOnly => {
|
|
StylePropertyMapReadOnlyIteratorPrototypeDeclaration::build(scope)
|
|
}
|
|
Self::EventCounts => EventCountsIteratorPrototypeDeclaration::build(scope),
|
|
Self::FontFaceSet => FontFaceSetIteratorPrototypeDeclaration::build(scope),
|
|
Self::CssFontFeatureValuesMap => {
|
|
CssFontFeatureValuesMapIteratorPrototypeDeclaration::build(scope)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum SetlikeWebIdlIteratorKind {
|
|
ViewTransitionTypeSet,
|
|
CustomStateSet,
|
|
}
|
|
|
|
impl SetlikeWebIdlIteratorKind {
|
|
const fn interface(self) -> &'static str {
|
|
match self {
|
|
Self::ViewTransitionTypeSet => "ViewTransitionTypeSet Iterator",
|
|
Self::CustomStateSet => "CustomStateSet Iterator",
|
|
}
|
|
}
|
|
|
|
const fn prototype_slot(self) -> &'static str {
|
|
match self {
|
|
Self::ViewTransitionTypeSet => VIEW_TRANSITION_TYPE_SET_ITERATOR_PROTOTYPE_SLOT,
|
|
Self::CustomStateSet => CUSTOM_STATE_SET_ITERATOR_PROTOTYPE_SLOT,
|
|
}
|
|
}
|
|
|
|
fn build_template<'s>(
|
|
self,
|
|
scope: &mut v8::PinScope<'s, '_, ()>,
|
|
) -> v8::Local<'s, v8::FunctionTemplate> {
|
|
match self {
|
|
Self::ViewTransitionTypeSet => {
|
|
ViewTransitionTypeSetIteratorPrototypeDeclaration::build(scope)
|
|
}
|
|
Self::CustomStateSet => CustomStateSetIteratorPrototypeDeclaration::build(scope),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum SetlikeWebIdlIteratorMethod {
|
|
Entries,
|
|
Keys,
|
|
Values,
|
|
}
|
|
|
|
impl SetlikeWebIdlIteratorMethod {
|
|
const fn intrinsic_slot(self) -> &'static str {
|
|
match self {
|
|
Self::Entries => NATIVE_SET_ENTRIES_INTRINSIC_SLOT,
|
|
Self::Keys => NATIVE_SET_KEYS_INTRINSIC_SLOT,
|
|
Self::Values => NATIVE_SET_VALUES_INTRINSIC_SLOT,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum MaplikeWebIdlIteratorMethod {
|
|
Entries,
|
|
Keys,
|
|
Values,
|
|
}
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(plain)]
|
|
struct SnapshotWebIdlIteratorDeclaration<'s> {
|
|
#[webapi(slot = SNAPSHOT_ITERATOR_VALUES_SLOT)]
|
|
values: v8::Local<'s, v8::Array>,
|
|
#[webapi(slot = SNAPSHOT_ITERATOR_INDEX_SLOT)]
|
|
index: i32,
|
|
}
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(plain)]
|
|
struct NativeCollectionWebIdlIteratorDeclaration<'s> {
|
|
#[webapi(slot = NATIVE_COLLECTION_ITERATOR_SLOT)]
|
|
iterator: v8::Local<'s, v8::Object>,
|
|
#[webapi(slot = NATIVE_COLLECTION_ITERATOR_NEXT_SLOT)]
|
|
next: v8::Local<'s, v8::Function>,
|
|
}
|
|
|
|
#[derive(WebApiObject)]
|
|
#[webapi(plain, data_properties, enumerable)]
|
|
struct SnapshotWebIdlIteratorResultDeclaration<'s> {
|
|
value: v8::Local<'s, v8::Value>,
|
|
done: bool,
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(
|
|
interface = web_api_interfaces::StylePropertyMapReadOnlyIterator,
|
|
intrinsic_prototype_parent = v8::Intrinsic::IteratorPrototype,
|
|
prototype_to_string_tag = "StylePropertyMapReadOnly Iterator",
|
|
readonly_prototype,
|
|
enumerable
|
|
)]
|
|
struct StylePropertyMapReadOnlyIteratorPrototypeDeclaration {
|
|
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
|
|
next: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(
|
|
interface = web_api_interfaces::EventCountsIterator,
|
|
intrinsic_prototype_parent = v8::Intrinsic::MapIteratorPrototype,
|
|
prototype_to_string_tag = "EventCounts Iterator",
|
|
readonly_prototype,
|
|
enumerable
|
|
)]
|
|
struct EventCountsIteratorPrototypeDeclaration {
|
|
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
|
|
next: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(
|
|
interface = web_api_interfaces::FontFaceSetIterator,
|
|
intrinsic_prototype_parent = v8::Intrinsic::SetIteratorPrototype,
|
|
prototype_to_string_tag = "FontFaceSet Iterator",
|
|
readonly_prototype,
|
|
enumerable
|
|
)]
|
|
struct FontFaceSetIteratorPrototypeDeclaration {
|
|
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
|
|
next: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(
|
|
interface = web_api_interfaces::ViewTransitionTypeSetIterator,
|
|
intrinsic_prototype_parent = v8::Intrinsic::SetIteratorPrototype,
|
|
prototype_to_string_tag = "ViewTransitionTypeSet Iterator",
|
|
readonly_prototype,
|
|
enumerable
|
|
)]
|
|
struct ViewTransitionTypeSetIteratorPrototypeDeclaration {
|
|
#[webapi(
|
|
method,
|
|
length = 0,
|
|
callback = native_collection_webidl_iterator_next_callback
|
|
)]
|
|
next: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(
|
|
interface = web_api_interfaces::CustomStateSetIterator,
|
|
intrinsic_prototype_parent = v8::Intrinsic::SetIteratorPrototype,
|
|
prototype_to_string_tag = "CustomStateSet Iterator",
|
|
readonly_prototype,
|
|
enumerable
|
|
)]
|
|
struct CustomStateSetIteratorPrototypeDeclaration {
|
|
#[webapi(
|
|
method,
|
|
length = 0,
|
|
callback = native_collection_webidl_iterator_next_callback
|
|
)]
|
|
next: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(
|
|
interface = web_api_interfaces::CSSFontFeatureValuesMapIterator,
|
|
intrinsic_prototype_parent = v8::Intrinsic::MapIteratorPrototype,
|
|
prototype_to_string_tag = "CSSFontFeatureValuesMap Iterator",
|
|
readonly_prototype,
|
|
enumerable
|
|
)]
|
|
struct CssFontFeatureValuesMapIteratorPrototypeDeclaration {
|
|
#[webapi(method, length = 0, callback = snapshot_webidl_iterator_next_callback)]
|
|
next: (),
|
|
}
|
|
|
|
pub fn install_webidl_collection_iterator_intrinsics<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
global: v8::Local<'s, v8::Object>,
|
|
) -> Result<()> {
|
|
let set = v8::Set::new(scope);
|
|
let prototype = set
|
|
.get_prototype(scope)
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Set prototype"))?;
|
|
|
|
for (name, slot) in [
|
|
("entries", NATIVE_SET_ENTRIES_INTRINSIC_SLOT),
|
|
("keys", NATIVE_SET_KEYS_INTRINSIC_SLOT),
|
|
("values", NATIVE_SET_VALUES_INTRINSIC_SLOT),
|
|
] {
|
|
let function = prototype
|
|
.get(scope, v8str(scope, name).into())
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Set.prototype.{name}"))?;
|
|
set_private_value(scope, global, slot, function.into());
|
|
}
|
|
|
|
let values = native_collection_intrinsic(scope, NATIVE_SET_VALUES_INTRINSIC_SLOT)
|
|
.ok_or_else(|| anyhow!("missing captured intrinsic Set.prototype.values"))?;
|
|
let iterator = values
|
|
.call(scope, set.into(), &[])
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("failed to create intrinsic Set iterator"))?;
|
|
let iterator_prototype = iterator
|
|
.get_prototype(scope)
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Set iterator prototype"))?;
|
|
let next = iterator_prototype
|
|
.get(scope, v8str(scope, "next").into())
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Set iterator next"))?;
|
|
set_private_value(
|
|
scope,
|
|
global,
|
|
NATIVE_SET_ITERATOR_NEXT_INTRINSIC_SLOT,
|
|
next.into(),
|
|
);
|
|
|
|
let reflect = global
|
|
.get(scope, v8str(scope, "Reflect").into())
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Reflect object"))?;
|
|
for (name, slot) in [
|
|
("apply", NATIVE_REFLECT_APPLY_INTRINSIC_SLOT),
|
|
("construct", NATIVE_REFLECT_CONSTRUCT_INTRINSIC_SLOT),
|
|
] {
|
|
let function = reflect
|
|
.get(scope, v8str(scope, name).into())
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Reflect.{name}"))?;
|
|
set_private_value(scope, global, slot, function.into());
|
|
}
|
|
|
|
let map = v8::Map::new(scope);
|
|
let prototype = map
|
|
.get_prototype(scope)
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Map prototype"))?;
|
|
for (name, slot) in [
|
|
("entries", NATIVE_MAP_ENTRIES_INTRINSIC_SLOT),
|
|
("keys", NATIVE_MAP_KEYS_INTRINSIC_SLOT),
|
|
("values", NATIVE_MAP_VALUES_INTRINSIC_SLOT),
|
|
] {
|
|
let function = prototype
|
|
.get(scope, v8str(scope, name).into())
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Map.prototype.{name}"))?;
|
|
set_private_value(scope, global, slot, function.into());
|
|
}
|
|
let entries = native_collection_intrinsic(scope, NATIVE_MAP_ENTRIES_INTRINSIC_SLOT)
|
|
.ok_or_else(|| anyhow!("missing captured Map.prototype.entries"))?;
|
|
let iterator = entries
|
|
.call(scope, map.into(), &[])
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("failed to create intrinsic Map iterator"))?;
|
|
let next = iterator
|
|
.get(scope, v8str(scope, "next").into())
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
.ok_or_else(|| anyhow!("missing intrinsic Map iterator next"))?;
|
|
set_private_value(
|
|
scope,
|
|
global,
|
|
NATIVE_MAP_ITERATOR_NEXT_INTRINSIC_SLOT,
|
|
next.into(),
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn webidl_collection_reflect_apply_intrinsic<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
) -> Option<v8::Local<'s, v8::Function>> {
|
|
native_collection_intrinsic(scope, NATIVE_REFLECT_APPLY_INTRINSIC_SLOT)
|
|
}
|
|
|
|
pub fn reflect_construct_intrinsic<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
) -> Option<v8::Local<'s, v8::Function>> {
|
|
native_collection_intrinsic(scope, NATIVE_REFLECT_CONSTRUCT_INTRINSIC_SLOT)
|
|
}
|
|
|
|
pub fn new_snapshot_webidl_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
values: v8::Local<'s, v8::Array>,
|
|
kind: SnapshotWebIdlIteratorKind,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let iterator = SnapshotWebIdlIteratorDeclaration::new(values, 0)
|
|
.bind(scope)
|
|
.ok()?;
|
|
web_api_interfaces::initialize(scope, iterator, kind.interface()).ok()?;
|
|
let prototype = snapshot_webidl_iterator_prototype(scope, kind)?;
|
|
(iterator.set_prototype(scope, prototype.into()) == Some(true)).then_some(iterator)
|
|
}
|
|
|
|
pub fn new_setlike_webidl_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
set: v8::Local<'s, v8::Set>,
|
|
kind: SetlikeWebIdlIteratorKind,
|
|
method: SetlikeWebIdlIteratorMethod,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let (native_iterator, next) = new_native_set_iterator(scope, set, method)?;
|
|
let iterator = NativeCollectionWebIdlIteratorDeclaration::new(native_iterator, next)
|
|
.bind(scope)
|
|
.ok()?;
|
|
web_api_interfaces::initialize(scope, iterator, kind.interface()).ok()?;
|
|
let prototype = setlike_webidl_iterator_prototype(scope, kind)?;
|
|
(iterator.set_prototype(scope, prototype.into()) == Some(true)).then_some(iterator)
|
|
}
|
|
|
|
pub fn call_setlike_webidl_for_each<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
set: v8::Local<'s, v8::Set>,
|
|
owner: v8::Local<'s, v8::Object>,
|
|
callback: v8::Local<'s, v8::Value>,
|
|
this_arg: v8::Local<'s, v8::Value>,
|
|
operation: &'static str,
|
|
) -> Option<v8::Local<'s, v8::Value>> {
|
|
let callback = prepare_webidl_collection_for_each_callback(scope, callback, operation)?;
|
|
// A captured intrinsic Set iterator has the same live backing-list
|
|
// behavior as Set.prototype.forEach without manufacturing a second
|
|
// JavaScript callback to forward into the page callback.
|
|
let (iterator, next) =
|
|
new_native_set_iterator(scope, set, SetlikeWebIdlIteratorMethod::Values)?;
|
|
loop {
|
|
let value = match advance_native_collection_iterator(scope, iterator, next)? {
|
|
NativeCollectionIteratorStep::Done => break,
|
|
NativeCollectionIteratorStep::Value(value) => value,
|
|
};
|
|
invoke_webidl_collection_for_each_callback(
|
|
scope, &callback, this_arg, value, value, owner,
|
|
)?;
|
|
}
|
|
Some(v8::undefined(scope).into())
|
|
}
|
|
|
|
pub fn new_maplike_webidl_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
map: v8::Local<'s, v8::Map>,
|
|
method: MaplikeWebIdlIteratorMethod,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let entries = map.as_array(scope);
|
|
let mut values = Vec::with_capacity(map.size());
|
|
for index in 0..map.size().min(u32::MAX as usize) as u32 {
|
|
let key = entries.get_index(scope, index.saturating_mul(2))?;
|
|
let value = entries.get_index(scope, index.saturating_mul(2).saturating_add(1))?;
|
|
values.push(match method {
|
|
MaplikeWebIdlIteratorMethod::Entries => {
|
|
v8::Array::new_with_elements(scope, &[key, value]).into()
|
|
}
|
|
MaplikeWebIdlIteratorMethod::Keys => key,
|
|
MaplikeWebIdlIteratorMethod::Values => value,
|
|
});
|
|
}
|
|
let values = v8::Array::new_with_elements(scope, &values);
|
|
new_snapshot_webidl_iterator(
|
|
scope,
|
|
values,
|
|
SnapshotWebIdlIteratorKind::CssFontFeatureValuesMap,
|
|
)
|
|
}
|
|
|
|
/// Live maplike iteration for device collections. CSS's existing snapshot
|
|
/// iterator has a separate residence policy and is deliberately unchanged.
|
|
pub fn new_live_maplike_webidl_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
map: v8::Local<'s, v8::Map>,
|
|
method: MaplikeWebIdlIteratorMethod,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
// WebIDL maplike declarations use %MapIteratorPrototype% directly.
|
|
// Captured intrinsic methods create the correct live iterator in the
|
|
// callee realm without consulting the author's Map prototype methods.
|
|
new_native_map_iterator(scope, map, method).map(|(iterator, _)| iterator)
|
|
}
|
|
|
|
pub fn call_live_maplike_webidl_for_each<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
map: v8::Local<'s, v8::Map>,
|
|
owner: v8::Local<'s, v8::Object>,
|
|
callback: v8::Local<'s, v8::Value>,
|
|
this_arg: v8::Local<'s, v8::Value>,
|
|
operation: &'static str,
|
|
) -> Option<v8::Local<'s, v8::Value>> {
|
|
let callback = prepare_webidl_collection_for_each_callback(scope, callback, operation)?;
|
|
let (iterator, next) =
|
|
new_native_map_iterator(scope, map, MaplikeWebIdlIteratorMethod::Entries)?;
|
|
loop {
|
|
let entry = match advance_native_collection_iterator(scope, iterator, next)? {
|
|
NativeCollectionIteratorStep::Done => break,
|
|
NativeCollectionIteratorStep::Value(value) => {
|
|
v8::Local::<v8::Array>::try_from(value).ok()?
|
|
}
|
|
};
|
|
let key = entry.get_index(scope, 0)?;
|
|
let value = entry.get_index(scope, 1)?;
|
|
invoke_webidl_collection_for_each_callback(scope, &callback, this_arg, value, key, owner)?;
|
|
}
|
|
Some(v8::undefined(scope).into())
|
|
}
|
|
|
|
fn new_native_map_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
map: v8::Local<'s, v8::Map>,
|
|
method: MaplikeWebIdlIteratorMethod,
|
|
) -> Option<(v8::Local<'s, v8::Object>, v8::Local<'s, v8::Function>)> {
|
|
let slot = match method {
|
|
MaplikeWebIdlIteratorMethod::Entries => NATIVE_MAP_ENTRIES_INTRINSIC_SLOT,
|
|
MaplikeWebIdlIteratorMethod::Keys => NATIVE_MAP_KEYS_INTRINSIC_SLOT,
|
|
MaplikeWebIdlIteratorMethod::Values => NATIVE_MAP_VALUES_INTRINSIC_SLOT,
|
|
};
|
|
let intrinsic = native_collection_intrinsic(scope, slot)?;
|
|
let iterator = intrinsic
|
|
.call(scope, map.into(), &[])
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())?;
|
|
let next = native_collection_intrinsic(scope, NATIVE_MAP_ITERATOR_NEXT_INTRINSIC_SLOT)?;
|
|
Some((iterator, next))
|
|
}
|
|
|
|
pub fn call_maplike_webidl_for_each<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
map: v8::Local<'s, v8::Map>,
|
|
owner: v8::Local<'s, v8::Object>,
|
|
callback: v8::Local<'s, v8::Value>,
|
|
this_arg: v8::Local<'s, v8::Value>,
|
|
operation: &'static str,
|
|
) -> Option<v8::Local<'s, v8::Value>> {
|
|
let callback = prepare_webidl_collection_for_each_callback(scope, callback, operation)?;
|
|
// CSSFontFeatureValuesMap currently defines its iteration residence as
|
|
// this surface-owned snapshot. Callback migration must not silently turn
|
|
// that separate collection policy into a live iterator.
|
|
let entries = map.as_array(scope);
|
|
for index in 0..map.size().min(u32::MAX as usize) as u32 {
|
|
let key = entries.get_index(scope, index.saturating_mul(2))?;
|
|
let value = entries.get_index(scope, index.saturating_mul(2).saturating_add(1))?;
|
|
invoke_webidl_collection_for_each_callback(scope, &callback, this_arg, value, key, owner)?;
|
|
}
|
|
Some(v8::undefined(scope).into())
|
|
}
|
|
|
|
pub fn prepare_webidl_collection_for_each_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
callback: v8::Local<'s, v8::Value>,
|
|
operation: &'static str,
|
|
) -> Option<webidl::PreparedWebIdlCallbackFunction> {
|
|
// Generated maplike/setlike forEach is normatively IsCallable + Call,
|
|
// rather than an IDL Function argument. The strong callback-function
|
|
// value is an equivalent V8 ownership representation: it preserves
|
|
// callable proxies and context anchors, but owns no collection policy.
|
|
match webidl::convert::<webidl::WebIdlCallbackFunction>(
|
|
scope,
|
|
callback,
|
|
webidl::Context::argument(operation, 1),
|
|
) {
|
|
Ok(callback) => Some(callback.prepare(scope)),
|
|
Err(error) => {
|
|
webidl::throw_error(scope, &error);
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn invoke_webidl_collection_for_each_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
callback: &webidl::PreparedWebIdlCallbackFunction,
|
|
this_arg: v8::Local<'s, v8::Value>,
|
|
value: v8::Local<'s, v8::Value>,
|
|
key: v8::Local<'s, v8::Value>,
|
|
owner: v8::Local<'s, v8::Object>,
|
|
) -> Option<()> {
|
|
let _ = invoke_synchronous_webidl_callback_function(
|
|
scope,
|
|
callback,
|
|
this_arg,
|
|
&[value, key, owner.into()],
|
|
)?;
|
|
Some(())
|
|
}
|
|
|
|
fn new_native_set_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
set: v8::Local<'s, v8::Set>,
|
|
method: SetlikeWebIdlIteratorMethod,
|
|
) -> Option<(v8::Local<'s, v8::Object>, v8::Local<'s, v8::Function>)> {
|
|
let intrinsic = native_collection_intrinsic(scope, method.intrinsic_slot())?;
|
|
let iterator = intrinsic
|
|
.call(scope, set.into(), &[])
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())?;
|
|
let next = native_collection_intrinsic(scope, NATIVE_SET_ITERATOR_NEXT_INTRINSIC_SLOT)?;
|
|
Some((iterator, next))
|
|
}
|
|
|
|
enum NativeCollectionIteratorStep<'s> {
|
|
Value(v8::Local<'s, v8::Value>),
|
|
Done,
|
|
}
|
|
|
|
fn advance_native_collection_iterator<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
iterator: v8::Local<'s, v8::Object>,
|
|
next: v8::Local<'s, v8::Function>,
|
|
) -> Option<NativeCollectionIteratorStep<'s>> {
|
|
let result = next
|
|
.call(scope, iterator.into(), &[])
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())?;
|
|
if result
|
|
.get(scope, v8str(scope, "done").into())
|
|
.is_some_and(|value| value.boolean_value(scope))
|
|
{
|
|
return Some(NativeCollectionIteratorStep::Done);
|
|
}
|
|
result
|
|
.get(scope, v8str(scope, "value").into())
|
|
.map(NativeCollectionIteratorStep::Value)
|
|
}
|
|
|
|
fn snapshot_webidl_iterator_prototype<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
kind: SnapshotWebIdlIteratorKind,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let global = scope.get_current_context().global(scope);
|
|
if let Some(existing) = get_private_value(scope, global, kind.prototype_slot())
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
{
|
|
return Some(existing);
|
|
}
|
|
let template = kind.build_template(scope);
|
|
let prototype = materialize_hidden_function_template_prototype(scope, template)?;
|
|
set_private_value(scope, global, kind.prototype_slot(), prototype.into());
|
|
Some(prototype)
|
|
}
|
|
|
|
fn setlike_webidl_iterator_prototype<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
kind: SetlikeWebIdlIteratorKind,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let global = scope.get_current_context().global(scope);
|
|
if let Some(existing) = get_private_value(scope, global, kind.prototype_slot())
|
|
.and_then(|value| v8::Local::<v8::Object>::try_from(value).ok())
|
|
{
|
|
return Some(existing);
|
|
}
|
|
let template = kind.build_template(scope);
|
|
let prototype = materialize_hidden_function_template_prototype(scope, template)?;
|
|
set_private_value(scope, global, kind.prototype_slot(), prototype.into());
|
|
Some(prototype)
|
|
}
|
|
|
|
fn snapshot_webidl_iterator_next_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
let iterator = args.this();
|
|
let Some(values) = get_private_object(scope, iterator, SNAPSHOT_ITERATOR_VALUES_SLOT)
|
|
.and_then(|value| v8::Local::<v8::Array>::try_from(value).ok())
|
|
else {
|
|
throw_type_error(
|
|
scope,
|
|
"WebIDL iterator next called on an incompatible receiver.",
|
|
);
|
|
return;
|
|
};
|
|
let Some(index) = get_private_value(scope, iterator, SNAPSHOT_ITERATOR_INDEX_SLOT)
|
|
.and_then(|value| value.integer_value(scope))
|
|
.and_then(|value| u32::try_from(value).ok())
|
|
else {
|
|
throw_type_error(scope, "WebIDL iterator state is unavailable.");
|
|
return;
|
|
};
|
|
if index >= values.length() {
|
|
let result =
|
|
SnapshotWebIdlIteratorResultDeclaration::new(v8::undefined(scope).into(), true)
|
|
.bind(scope)
|
|
.expect("WebIDL iterator result declaration should bind");
|
|
rv.set(result.into());
|
|
return;
|
|
}
|
|
let value = values
|
|
.get_index(scope, index)
|
|
.unwrap_or_else(|| v8::undefined(scope).into());
|
|
set_private_value(
|
|
scope,
|
|
iterator,
|
|
SNAPSHOT_ITERATOR_INDEX_SLOT,
|
|
v8::Integer::new_from_unsigned(scope, index.saturating_add(1)).into(),
|
|
);
|
|
let result = SnapshotWebIdlIteratorResultDeclaration::new(value, false)
|
|
.bind(scope)
|
|
.expect("WebIDL iterator result declaration should bind");
|
|
rv.set(result.into());
|
|
}
|
|
|
|
fn native_collection_webidl_iterator_next_callback<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
args: v8::FunctionCallbackArguments<'s>,
|
|
mut rv: v8::ReturnValue<'_, v8::Value>,
|
|
) {
|
|
let Some(iterator) = get_private_object(scope, args.this(), NATIVE_COLLECTION_ITERATOR_SLOT)
|
|
else {
|
|
throw_type_error(
|
|
scope,
|
|
"WebIDL collection iterator next called on an incompatible receiver.",
|
|
);
|
|
return;
|
|
};
|
|
let Some(next) = get_private_value(scope, args.this(), NATIVE_COLLECTION_ITERATOR_NEXT_SLOT)
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
else {
|
|
throw_type_error(scope, "WebIDL collection iterator state is unavailable.");
|
|
return;
|
|
};
|
|
if let Some(result) = next.call(scope, iterator.into(), &[]) {
|
|
rv.set(result);
|
|
}
|
|
}
|
|
|
|
fn native_collection_intrinsic<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
slot: &'static str,
|
|
) -> Option<v8::Local<'s, v8::Function>> {
|
|
let global = scope.get_current_context().global(scope);
|
|
get_private_value(scope, global, slot)
|
|
.and_then(|value| v8::Local::<v8::Function>::try_from(value).ok())
|
|
}
|