Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(webapi): add native cross-origin member declarations

ldm0b4f9a9677fc2
diff --git a/moli-webapi-declare-derive/src/expand.rs b/moli-webapi-declare-derive/src/expand.rs
index e1b8060e9..1a2d0400c 100644
--- a/moli-webapi-declare-derive/src/expand.rs
+++ b/moli-webapi-declare-derive/src/expand.rs
@@ -15,6 +15,9 @@ struct DeclaredField {
attrs: FieldAttrs,
}
+mod cross_origin;
+pub(crate) use cross_origin::expand_webapi_cross_origin;
+
fn declared_fields(
data: &Data,
rename_all: RenameRule,
diff --git a/moli-webapi-declare-derive/src/expand/cross_origin.rs b/moli-webapi-declare-derive/src/expand/cross_origin.rs
new file mode 100644
index 000000000..c65d2a0f4
--- /dev/null
+++ b/moli-webapi-declare-derive/src/expand/cross_origin.rs
@@ -0,0 +1,234 @@
+use super::*;
+
+pub(crate) fn expand_webapi_cross_origin(
+ input: DeriveInput,
+) -> Result<proc_macro2::TokenStream, Error> {
+ let name = &input.ident;
+ if !input.generics.params.is_empty() {
+ return Err(Error::new_spanned(
+ &input.generics,
+ "cross-origin declarations cannot carry runtime state",
+ ));
+ }
+ let attrs = parse_object_attrs(&input.attrs)?;
+ if !matches!(attrs.role, None | Some(ObjectRole::Plain))
+ || attrs.prototype.is_some()
+ || attrs.own_to_string_tag.is_some()
+ || attrs.fallback_to_string_tag.is_some()
+ || attrs.scope_lifetime.is_some()
+ || attrs.default_data_properties
+ || attrs.default_enumerable
+ {
+ return Err(Error::new_spanned(
+ input,
+ "cross-origin declarations describe stateless property tables, not object initialization",
+ ));
+ }
+ let fields = declared_fields(
+ &input.data,
+ attrs.rename_all,
+ FieldDefaults {
+ receiver: attrs.receiver.as_ref(),
+ ..FieldDefaults::default()
+ },
+ )?;
+ let mut helpers = Vec::new();
+ let mut entries = Vec::new();
+ for DeclaredField { field, attrs } in fields {
+ if !type_is_unit(&field.ty)
+ || attrs.data.is_some()
+ || attrs.setter_data.is_some()
+ || attrs.returns_promise
+ || attrs.symbol.is_some()
+ || attrs.getter_value.is_some()
+ || attrs.value.is_some()
+ || attrs.init.is_some()
+ || attrs.enumerable
+ || attrs.dont_delete
+ {
+ return Err(Error::new_spanned(
+ field,
+ "cross-origin members must be stateless string-keyed methods or accessors",
+ ));
+ }
+ let property_name = match attrs.name.as_ref() {
+ Some(syn::Expr::Lit(syn::ExprLit {
+ lit: Lit::Str(name),
+ ..
+ })) => name.clone(),
+ _ => {
+ return Err(Error::new_spanned(
+ &field,
+ "cross-origin member names must be string literals",
+ ));
+ }
+ };
+ let ident = field.ident.as_ref().expect("named field");
+ let receiver_check = attrs.receiver.as_ref().map(|receiver| {
+ quote! {
+ if !#receiver(__moli_scope, __moli_receiver) {
+ ::moli_webapi_declare::__private::throw_illegal_invocation(__moli_scope);
+ return None;
+ }
+ }
+ });
+ let function = |suffix: &str,
+ callback: proc_macro2::TokenStream,
+ length: i32,
+ function_name: LitStr| {
+ let factory = format_ident!("__cross_origin_{}_{}_template", ident, suffix);
+ let helper = quote! {
+ fn #factory<'s>(
+ scope: &::moli_webapi_declare::v8::PinScope<'s, '_>,
+ ) -> ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::FunctionTemplate> {
+ let template = ::moli_webapi_declare::v8::FunctionTemplate::builder(#callback)
+ .length(#length)
+ .constructor_behavior(::moli_webapi_declare::v8::ConstructorBehavior::Throw)
+ .build(scope);
+ template.remove_prototype();
+ template.set_class_name(::moli_webapi_declare::__private::v8str(scope, #function_name));
+ template
+ }
+ };
+ (
+ helper,
+ quote!(::moli_webapi_declare::CrossOriginFunction { build: Self::#factory }),
+ )
+ };
+ match attrs.kind {
+ FieldKind::Method => {
+ let callback = attrs
+ .callback
+ .as_ref()
+ .ok_or_else(|| Error::new_spanned(&field, "method requires callback"))?;
+ let callback = expand_callback(callback, &attrs, false);
+ let (helper, function) = function(
+ "method",
+ callback,
+ attrs.length.unwrap_or(0),
+ property_name.clone(),
+ );
+ helpers.push(helper);
+ entries.push(quote! {
+ ::moli_webapi_declare::CrossOriginProperty::Method { name: #property_name, function: #function }
+ });
+ }
+ FieldKind::AccessorProperty => {
+ if attrs.getter.is_none() && attrs.setter.is_none() {
+ return Err(Error::new_spanned(
+ field,
+ "cross-origin accessor requires a getter or setter",
+ ));
+ }
+ let mut accessors = Vec::new();
+ for (suffix, callback, length) in [
+ ("get", attrs.getter.as_ref(), 0),
+ ("set", attrs.setter.as_ref(), 1),
+ ] {
+ let Some(callback) = callback else {
+ accessors.push(quote!(None));
+ continue;
+ };
+ let value_helper = format_ident!("__cross_origin_{}_{}", ident, suffix);
+ let callback_helper =
+ format_ident!("__cross_origin_{}_{}_callback", ident, suffix);
+ let function_name = LitStr::new(
+ &format!("{suffix} {}", property_name.value()),
+ property_name.span(),
+ );
+ let (helper, function) = function(
+ suffix,
+ quote!(Self::#callback_helper),
+ length,
+ function_name,
+ );
+ helpers.push(helper);
+ if length == 0 {
+ helpers.push(quote! {
+ fn #value_helper<'s>(
+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,
+ __moli_receiver: ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Object>,
+ ) -> Option<::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Value>> {
+ #receiver_check
+ #callback(__moli_scope, __moli_receiver)
+ }
+ fn #callback_helper<'s>(
+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,
+ args: ::moli_webapi_declare::v8::FunctionCallbackArguments<'s>,
+ mut rv: ::moli_webapi_declare::v8::ReturnValue<'s>,
+ ) {
+ if let Some(value) = Self::#value_helper(__moli_scope, args.this()) { rv.set(value); }
+ }
+ });
+ } else {
+ helpers.push(quote! {
+ fn #value_helper<'s>(
+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,
+ __moli_receiver: ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Object>,
+ value: ::moli_webapi_declare::v8::Local<'s, ::moli_webapi_declare::v8::Value>,
+ ) -> Option<()> {
+ #receiver_check
+ #callback(__moli_scope, __moli_receiver, value)
+ }
+ fn #callback_helper<'s>(
+ __moli_scope: &mut ::moli_webapi_declare::v8::PinScope<'s, '_>,
+ args: ::moli_webapi_declare::v8::FunctionCallbackArguments<'s>,
+ _rv: ::moli_webapi_declare::v8::ReturnValue<'s>,
+ ) {
+ let _ = Self::#value_helper(__moli_scope, args.this(), args.get(0));
+ }
+ });
+ }
+ accessors.push(quote!(Some((Self::#value_helper, #function))));
+ }
+ let getter = &accessors[0];
+ let setter = &accessors[1];
+ entries.push(quote! {
+ ::moli_webapi_declare::CrossOriginProperty::Accessor {
+ name: #property_name, getter: #getter, setter: #setter,
+ }
+ });
+ }
+ _ => {
+ return Err(Error::new_spanned(
+ &field,
+ "cross-origin declarations only support method and accessor_property",
+ ));
+ }
+ }
+ }
+ Ok(quote! {
+ impl #name { #(#helpers)* }
+ impl ::moli_webapi_declare::WebApiCrossOriginDeclaration for #name {
+ fn cross_origin_properties() -> &'static [::moli_webapi_declare::CrossOriginProperty] {
+ &[#(#entries),*]
+ }
+ }
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn rejects_declarations_that_would_capture_runtime_state() {
+ let invalid: [DeriveInput; 3] = [
+ syn::parse_quote! {
+ #[webapi(plain)]
+ struct Bad<T> { #[webapi(method, callback = callback)] operation: T }
+ },
+ syn::parse_quote! {
+ #[webapi(plain)]
+ struct Bad { #[webapi(method, callback = callback, data = self.state)] operation: (), state: usize }
+ },
+ syn::parse_quote! {
+ #[webapi(plain)]
+ struct Bad { #[webapi(method, name = runtime_name(), callback = callback)] operation: () }
+ },
+ ];
+ for input in invalid {
+ assert!(expand_webapi_cross_origin(input).is_err());
+ }
+ }
+}
diff --git a/moli-webapi-declare-derive/src/lib.rs b/moli-webapi-declare-derive/src/lib.rs
index 71f4e95a4..e1c401f15 100644
--- a/moli-webapi-declare-derive/src/lib.rs
+++ b/moli-webapi-declare-derive/src/lib.rs
@@ -4,6 +4,17 @@ mod expand;
use proc_macro::TokenStream;
use syn::{DeriveInput, parse_macro_input};
+/// Declares native cross-origin methods and accessors without an intermediate
+/// JavaScript object. Accessor callbacks return Option<Value> / Option<()> and
+/// are also adapted to realm-correct descriptor functions.
+#[proc_macro_derive(WebApiCrossOrigin, attributes(webapi))]
+pub fn derive_webapi_cross_origin(input: TokenStream) -> TokenStream {
+ match expand::expand_webapi_cross_origin(parse_macro_input!(input as DeriveInput)) {
+ Ok(tokens) => tokens.into(),
+ Err(error) => error.to_compile_error().into(),
+ }
+}
+
/// Derives a Web API function-template declaration binder.
///
/// The generated implementation creates a V8 `FunctionTemplate`, sets its class
diff --git a/moli-webapi-declare/src/cross_origin.rs b/moli-webapi-declare/src/cross_origin.rs
new file mode 100644
index 000000000..b0bbc0af9
--- /dev/null
+++ b/moli-webapi-declare/src/cross_origin.rs
@@ -0,0 +1,174 @@
+//! Native cross-origin member declarations. Templates contain callback metadata
+//! only; V8 owns each context's unique function instance and its lifetime.
+
+use std::collections::HashMap;
+
+use moli_v8_util::v8str;
+
+pub type CrossOriginGetter = for<'s, 'i> fn(
+ &mut v8::PinScope<'s, 'i>,
+ v8::Local<'s, v8::Object>,
+) -> Option<v8::Local<'s, v8::Value>>;
+pub type CrossOriginSetter = for<'s, 'i> fn(
+ &mut v8::PinScope<'s, 'i>,
+ v8::Local<'s, v8::Object>,
+ v8::Local<'s, v8::Value>,
+) -> Option<()>;
+
+pub struct CrossOriginFunction {
+ pub build: for<'s, 'i> fn(&v8::PinScope<'s, 'i>) -> v8::Local<'s, v8::FunctionTemplate>,
+}
+
+#[derive(Default)]
+struct FunctionTemplates(HashMap<usize, v8::Global<v8::FunctionTemplate>>);
+
+impl CrossOriginFunction {
+ pub fn get<'s>(
+ &'static self,
+ scope: &mut v8::PinScope<'s, '_>,
+ ) -> Option<v8::Local<'s, v8::Function>> {
+ // The key identifies an immutable declaration member, never a Window
+ // or a realm. No callback data can retain a target or an observer.
+ let key = self as *const Self as usize;
+ let cached = scope
+ .get_slot::<FunctionTemplates>()
+ .and_then(|templates| templates.0.get(&key))
+ .map(|template| v8::Local::new(scope, template));
+ let template = match cached {
+ Some(template) => template,
+ None => {
+ let template = (self.build)(scope);
+ let retained = v8::Global::new(scope, template);
+ if scope.get_slot::<FunctionTemplates>().is_none() {
+ scope.set_slot(FunctionTemplates::default());
+ }
+ scope
+ .get_slot_mut::<FunctionTemplates>()
+ .expect("template store was initialized")
+ .0
+ .insert(key, retained);
+ template
+ }
+ };
+ template.get_function(scope)
+ }
+}
+
+pub enum CrossOriginProperty {
+ Method {
+ name: &'static str,
+ function: CrossOriginFunction,
+ },
+ Accessor {
+ name: &'static str,
+ getter: Option<(CrossOriginGetter, CrossOriginFunction)>,
+ setter: Option<(CrossOriginSetter, CrossOriginFunction)>,
+ },
+}
+
+impl CrossOriginProperty {
+ pub const fn name(&self) -> &'static str {
+ match self {
+ Self::Method { name, .. } | Self::Accessor { name, .. } => name,
+ }
+ }
+
+ pub fn get<'s>(
+ &'static self,
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+ ) -> Option<v8::Local<'s, v8::Value>> {
+ match self {
+ Self::Method { function, .. } => function.get(scope).map(Into::into),
+ Self::Accessor {
+ getter: Some((getter, _)),
+ ..
+ } => getter(scope, receiver),
+ _ => None,
+ }
+ }
+
+ pub fn set<'s>(
+ &'static self,
+ scope: &mut v8::PinScope<'s, '_>,
+ receiver: v8::Local<'s, v8::Object>,
+ value: v8::Local<'s, v8::Value>,
+ ) -> Option<()> {
+ match self {
+ Self::Accessor {
+ setter: Some((setter, _)),
+ ..
+ } => setter(scope, receiver, value),
+ _ => None,
+ }
+ }
+
+ pub const fn has_getter(&self) -> bool {
+ matches!(
+ self,
+ Self::Method { .. }
+ | Self::Accessor {
+ getter: Some(_),
+ ..
+ }
+ )
+ }
+
+ pub const fn has_setter(&self) -> bool {
+ matches!(
+ self,
+ Self::Accessor {
+ setter: Some(_),
+ ..
+ }
+ )
+ }
+
+ pub fn descriptor<'s>(
+ &'static self,
+ scope: &mut v8::PinScope<'s, '_>,
+ ) -> Option<v8::Local<'s, v8::Object>> {
+ let descriptor = v8::Object::new(scope);
+ let fields: [(&str, v8::Local<v8::Value>); 2] = match self {
+ Self::Method { function, .. } => [
+ ("value", function.get(scope)?.into()),
+ ("writable", v8::Boolean::new(scope, false).into()),
+ ],
+ Self::Accessor { getter, setter, .. } => {
+ let get = match getter {
+ Some((_, function)) => function.get(scope)?.into(),
+ None => v8::undefined(scope).into(),
+ };
+ let set = match setter {
+ Some((_, function)) => function.get(scope)?.into(),
+ None => v8::undefined(scope).into(),
+ };
+ [("get", get), ("set", set)]
+ }
+ };
+ for (name, value) in fields.into_iter().chain([
+ ("enumerable", v8::Boolean::new(scope, false).into()),
+ ("configurable", v8::Boolean::new(scope, true).into()),
+ ]) {
+ descriptor
+ .define_own_property(
+ scope,
+ v8str(scope, name).into(),
+ value,
+ v8::PropertyAttribute::NONE,
+ )
+ .filter(|defined| *defined)?;
+ }
+ Some(descriptor)
+ }
+}
+
+pub trait WebApiCrossOriginDeclaration {
+ fn cross_origin_properties() -> &'static [CrossOriginProperty];
+
+ fn cross_origin_property(name: &str) -> Option<&'static CrossOriginProperty> {
+ Self::cross_origin_properties()
+ .iter()
+ .find(|property| property.name() == name)
+ }
+}
diff --git a/moli-webapi-declare/src/lib.rs b/moli-webapi-declare/src/lib.rs
index a1c8a09c3..0574a1ee7 100644
--- a/moli-webapi-declare/src/lib.rs
+++ b/moli-webapi-declare/src/lib.rs
@@ -5,6 +5,14 @@
//! `moli-webidl` and focuses on constructing V8 interface objects,
//! prototypes, and branded object instances.
//!
+//! `#[derive(WebApiCrossOrigin)]` describes a stateless cross-origin property
+//! table for native access-check handlers. Methods use ordinary V8 callbacks;
+//! accessors use native value callbacks returning `Option`, with receiver
+//! predicates checked before either invocation. Function templates are cached
+//! per isolate and produce a unique function in each accessing context. The
+//! table and templates never capture a target Window or an observer context.
+//! Runtime V8 failures propagate to the script execution boundary.
+//!
//! # Object declaration model
//!
//! A `#[derive(WebApiObject)]` struct describes the JavaScript surface that must
@@ -241,6 +249,7 @@ extern crate self as moli_webapi_declare;
mod brand;
mod callback;
+mod cross_origin;
mod declaration;
mod error;
mod interface;
@@ -251,7 +260,7 @@ mod value;
pub mod __private;
pub use interface::WebApiInterfaceDescriptor;
-pub use moli_webapi_declare_derive::{WebApiFunctionTemplate, WebApiObject};
+pub use moli_webapi_declare_derive::{WebApiCrossOrigin, WebApiFunctionTemplate, WebApiObject};
pub use v8;
/// Adapts a manual native constructor to the same identity initialization used
@@ -282,6 +291,10 @@ pub use brand::{
register_web_api_proxy, web_api_object_target, web_api_object_type,
};
+pub use cross_origin::{
+ CrossOriginFunction, CrossOriginGetter, CrossOriginProperty, CrossOriginSetter,
+ WebApiCrossOriginDeclaration,
+};
pub use declaration::{
DataPropertyDescriptorDeclaration, ObjectLiteralDeclaration, WebApiFunctionTemplateDeclaration,
WebApiObjectDeclaration,
diff --git a/moli-webapi-declare/tests/cross_origin.rs b/moli-webapi-declare/tests/cross_origin.rs
new file mode 100644
index 000000000..595d69603
--- /dev/null
+++ b/moli-webapi-declare/tests/cross_origin.rs
@@ -0,0 +1,182 @@
+use std::pin::pin;
+
+use moli_v8_test_util::ensure_v8;
+use moli_v8_util::{get_private_value, set_private_value, v8str};
+use moli_webapi_declare::{WebApiCrossOrigin, WebApiCrossOriginDeclaration};
+
+const VALUE: &str = "__crossOriginTestValue";
+
+fn receiver<'s>(scope: &mut v8::PinScope<'s, '_>, object: v8::Local<'s, v8::Object>) -> bool {
+ get_private_value(scope, object, VALUE).is_some()
+}
+
+fn get<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ object: v8::Local<'s, v8::Object>,
+) -> Option<v8::Local<'s, v8::Value>> {
+ get_private_value(scope, object, VALUE)
+}
+
+fn set<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ object: v8::Local<'s, v8::Object>,
+ value: v8::Local<'s, v8::Value>,
+) -> Option<()> {
+ let value = value.to_string(scope)?;
+ set_private_value(scope, object, VALUE, value.into());
+ Some(())
+}
+
+fn method<'s>(
+ _scope: &mut v8::PinScope<'s, '_>,
+ args: v8::FunctionCallbackArguments<'s>,
+ mut rv: v8::ReturnValue<'s>,
+) {
+ rv.set(args.this().into());
+}
+
+// Fields are declaration metadata; no runtime object carries this state.
+#[allow(dead_code)]
+#[derive(WebApiCrossOrigin)]
+#[webapi(plain, receiver = receiver)]
+struct Members {
+ #[webapi(method, length = 1, callback = method)]
+ operation: (),
+ #[webapi(accessor_property, getter = get, setter = set)]
+ value: (),
+ #[webapi(accessor_property, setter = set)]
+ write_only: (),
+}
+
+fn eval<'s>(scope: &mut v8::PinScope<'s, '_>, source: &str) -> v8::Local<'s, v8::Value> {
+ let source = v8::String::new(scope, source).unwrap();
+ v8::Script::compile(scope, source, None)
+ .unwrap()
+ .run(scope)
+ .unwrap()
+}
+
+#[test]
+fn native_members_share_templates_but_keep_functions_in_the_accessing_context() {
+ ensure_v8();
+ let mut isolate = v8::Isolate::new(Default::default());
+ let scope = pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let a = v8::Context::new(scope, Default::default());
+ let b = v8::Context::new(scope, Default::default());
+ let member = Members::cross_origin_property("operation").unwrap();
+ let function_a = {
+ let scope = &mut v8::ContextScope::new(scope, a);
+ let object = v8::Object::new(scope);
+ let value = v8str(scope, "initial");
+ set_private_value(scope, object, VALUE, value.into());
+ let function = member.get(scope, object).unwrap();
+ assert!(function.strict_equals(member.get(scope, object).unwrap()));
+ let global = a.global(scope);
+ global
+ .set(scope, v8str(scope, "object").into(), object.into())
+ .unwrap();
+ for (name, value) in [
+ ("method", function),
+ ("methodDescriptor", member.descriptor(scope).unwrap().into()),
+ (
+ "descriptor",
+ Members::cross_origin_property("value")
+ .unwrap()
+ .descriptor(scope)
+ .unwrap()
+ .into(),
+ ),
+ (
+ "writeOnly",
+ Members::cross_origin_property("writeOnly")
+ .unwrap()
+ .descriptor(scope)
+ .unwrap()
+ .into(),
+ ),
+ ] {
+ global.set(scope, v8str(scope, name).into(), value).unwrap();
+ }
+ assert!(eval(scope, r#"
+ (() => {
+ function throwsTypeError(callback) { try { callback(); } catch (e) { return e instanceof TypeError; } return false; }
+ if (Object.getPrototypeOf(method) !== Function.prototype || method.name !== 'operation' || method.length !== 1 || Object.hasOwn(method, 'prototype')) return false;
+ if (method.call(object) !== object || !throwsTypeError(() => method.call({})) || !throwsTypeError(() => new method())) return false;
+ if (methodDescriptor.writable || methodDescriptor.enumerable || !methodDescriptor.configurable) return false;
+ if (descriptor.get.name !== 'get value' || descriptor.get.length !== 0 || descriptor.set.name !== 'set value' || descriptor.set.length !== 1 || descriptor.enumerable || !descriptor.configurable) return false;
+ if (descriptor.get.call(object) !== 'initial' || !throwsTypeError(() => descriptor.get.call({}))) return false;
+ let conversions = 0;
+ if (!throwsTypeError(() => descriptor.set.call({}, {toString() { conversions++; return 'bad'; }})) || conversions !== 0) return false;
+ const exception = new Error('conversion');
+ try { descriptor.set.call(object, {toString() { throw exception; }}); return false; } catch (e) { if (e !== exception) return false; }
+ descriptor.set.call(object, 'updated');
+ return descriptor.get.call(object) === 'updated' && writeOnly.get === undefined && writeOnly.set.name === 'set writeOnly';
+ })()
+ "#).is_true());
+ v8::Global::new(scope, function)
+ };
+ let scope = &mut v8::ContextScope::new(scope, b);
+ let object = v8::Object::new(scope);
+ let function_b = member.get(scope, object).unwrap();
+ let function_a = v8::Local::new(scope, &function_a);
+ assert!(!function_a.strict_equals(function_b));
+ let function_b = v8::Local::<v8::Object>::try_from(function_b).unwrap();
+ assert!(
+ function_b
+ .get_prototype(scope)
+ .unwrap()
+ .strict_equals(eval(scope, "Function.prototype"))
+ );
+}
+
+#[test]
+fn native_member_failure_propagates_script_termination() {
+ ensure_v8();
+ let mut isolate = v8::Isolate::new(Default::default());
+ let scope = pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let context = v8::Context::new(scope, Default::default());
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let member = Members::cross_origin_property("value").unwrap();
+ let object = v8::Object::new(scope);
+ let value = v8str(scope, "initial");
+ set_private_value(scope, object, VALUE, value.into());
+ let input = v8::Object::new(scope);
+ {
+ v8::tc_scope!(let scope, scope);
+ scope.terminate_execution();
+ assert!(member.set(scope, object, input.into()).is_none());
+ assert!(
+ scope.has_terminated(),
+ "termination must reach the execution boundary"
+ );
+ assert!(!scope.can_continue());
+ scope.cancel_terminate_execution();
+ }
+ assert!(member.set(scope, object, input.into()).is_some());
+}
+
+#[test]
+fn isolate_template_cache_does_not_retain_an_accessing_context() {
+ ensure_v8();
+ let mut isolate = v8::Isolate::new(Default::default());
+ let weak = {
+ let scope = pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ let context = v8::Context::new(scope, Default::default());
+ let scope = &mut v8::ContextScope::new(scope, context);
+ let object = v8::Object::new(scope);
+ assert!(
+ Members::cross_origin_property("operation")
+ .unwrap()
+ .get(scope, object)
+ .is_some()
+ );
+ v8::Weak::new(scope, context)
+ };
+ isolate.low_memory_notification();
+ let scope = pin!(v8::HandleScope::new(&mut isolate));
+ let scope = &mut scope.init();
+ assert!(weak.to_local(scope).is_none());
+}