Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(events): release InputEvent live ranges after Node dispatch

ldm0e1876f39eb12
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index 370297033..2020d5a47 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -149,8 +149,8 @@ pub(crate) use self::css_runtime::{
css_supports_condition_text, install_css_runtime_state_for_document,
};
pub(crate) use self::events::{
- construct_original_event, construct_original_page_transition_event,
- construct_original_storage_event_utf16,
+ clear_input_event_target_ranges, construct_original_event,
+ construct_original_page_transition_event, construct_original_storage_event_utf16,
};
pub(crate) use crypto::{
CryptoKeyAlgorithmClonePayload, CryptoKeyClonePayload, WebCryptoRejection, WebCryptoTaskResult,
diff --git a/moli-renderer-v8/src/context_bootstrap/events.rs b/moli-renderer-v8/src/context_bootstrap/events.rs
index ee99e0079..bedb802ce 100644
--- a/moli-renderer-v8/src/context_bootstrap/events.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events.rs
@@ -12,6 +12,7 @@ pub(crate) use message::construct_original_message_event;
mod methods;
mod modifiers;
mod subclasses;
+pub(crate) use subclasses::clear_input_event_target_ranges;
pub(crate) use subclasses::initialize_native_security_policy_violation_event;
pub(in crate::context_bootstrap) use subclasses::input_event_get_target_ranges_callback;
mod submit;
diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs
index e4de24027..25a4ba9b9 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses.rs
@@ -31,4 +31,5 @@ pub(crate) use error::construct_original_error_event;
pub(in crate::context_bootstrap) use keyboard::keyboard_event_init_callback;
pub(crate) use security_policy::initialize_native_security_policy_violation_event;
+pub(crate) use input::clear_input_event_target_ranges;
pub(in crate::context_bootstrap) use input::input_event_get_target_ranges_callback;
diff --git a/moli-renderer-v8/src/context_bootstrap/events/subclasses/input.rs b/moli-renderer-v8/src/context_bootstrap/events/subclasses/input.rs
index b34cd1ded..62d95f9e6 100644
--- a/moli-renderer-v8/src/context_bootstrap/events/subclasses/input.rs
+++ b/moli-renderer-v8/src/context_bootstrap/events/subclasses/input.rs
@@ -7,6 +7,21 @@ use webidl::WebIdlDictionarySerialize;
const INPUT_EVENT_TARGET_RANGES_SLOT: &str = "__moliInputEventTargetRanges";
+pub(crate) fn clear_input_event_target_ranges<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ event: v8::Local<'s, v8::Object>,
+) {
+ let event = event_backing(scope, event);
+ if web_api_interfaces::InputEvent::is_instance(scope, event) {
+ crate::util::set_private_value(
+ scope,
+ event,
+ INPUT_EVENT_TARGET_RANGES_SLOT,
+ v8::undefined(scope).into(),
+ );
+ }
+}
+
#[derive(webidl::WebIdlDictionary)]
#[webidl(prefix = "InputEventInit", snapshot)]
pub(super) struct InputEventInit<'s> {
diff --git a/moli-renderer-v8/src/host/events.rs b/moli-renderer-v8/src/host/events.rs
index 9b4026f34..ec4105da4 100644
--- a/moli-renderer-v8/src/host/events.rs
+++ b/moli-renderer-v8/src/host/events.rs
@@ -1268,6 +1268,32 @@ pub(crate) fn dispatch_public_event_with_original_target<'s, 'i>(
original_target: EventTargetHandle,
propagation_path: &[EventTargetHandle],
event: v8::Local<'s, v8::Object>,
+) -> std::result::Result<PublicEventDispatchResult, String> {
+ let result = dispatch_public_event_with_original_target_impl(
+ registry,
+ scope,
+ host_ptr,
+ dispatch_target,
+ original_target,
+ propagation_path,
+ event,
+ );
+ // InputEvent's live ranges end with Node dispatch, including error exits.
+ // Direct Window and ordinary EventTarget dispatch retain them in Chromium.
+ if matches!(dispatch_target, EventTargetHandle::Node(_)) {
+ crate::context_bootstrap::clear_input_event_target_ranges(scope, event);
+ }
+ result
+}
+
+fn dispatch_public_event_with_original_target_impl<'s, 'i>(
+ registry: &mut HostEventTargetRegistry,
+ scope: &mut v8::PinScope<'s, 'i>,
+ host_ptr: *mut JsContextHost,
+ dispatch_target: EventTargetHandle,
+ original_target: EventTargetHandle,
+ propagation_path: &[EventTargetHandle],
+ event: v8::Local<'s, v8::Object>,
) -> std::result::Result<PublicEventDispatchResult, String> {
unsafe { &*host_ptr }.debug_assert_not_in_structural_mutation("public event dispatch");
let target_object = event_target_object(scope, host_ptr, dispatch_target)?;
diff --git a/moli-renderer-v8/src/script_vm/tests/browser_api/input_event_init.rs b/moli-renderer-v8/src/script_vm/tests/browser_api/input_event_init.rs
index 61e61e696..b60e81daa 100644
--- a/moli-renderer-v8/src/script_vm/tests/browser_api/input_event_init.rs
+++ b/moli-renderer-v8/src/script_vm/tests/browser_api/input_event_init.rs
@@ -1,5 +1,45 @@
use super::*;
+#[test]
+fn input_event_node_dispatch_releases_ranges_after_all_listeners() {
+ let mut vm = new_storage_html_test_vm("https://input-range-dispatch.test/");
+ assert_eq!(
+ vm.eval(include_str!(
+ "../../../../tests/fixtures/input-range-dispatch.js"
+ ))
+ .unwrap(),
+ "true"
+ );
+}
+
+#[test]
+fn retained_input_event_does_not_root_live_ranges_after_node_dispatch() {
+ let mut vm = new_storage_html_test_vm("https://input-range-gc.test/");
+ assert!(vm._context_host.borrow_mut().live_ranges_is_empty());
+ vm.eval(
+ r#"
+ const text=document.createTextNode('abc');document.body.append(text);
+ globalThis.retainedInputRangeEvent=new InputEvent('beforeinput',{targetRanges:[
+ new StaticRange({startContainer:text,startOffset:0,endContainer:text,endOffset:2})
+ ]});
+ globalThis.retainedInputRangeSnapshots=retainedInputRangeEvent.getTargetRanges();
+ "#,
+ )
+ .unwrap();
+ assert!(!vm._context_host.borrow_mut().live_ranges_is_empty());
+ vm.eval("document.body.dispatchEvent(retainedInputRangeEvent)")
+ .unwrap();
+ for _ in 0..2 {
+ vm.renderer_document_isolate
+ .with_renderer_document_isolate_mut(|isolate| isolate.low_memory_notification());
+ }
+ assert!(
+ vm._context_host.borrow_mut().live_ranges_is_empty(),
+ "retaining the event and static snapshots must not retain its internal live Range"
+ );
+ assert_eq!(vm.eval("retainedInputRangeEvent instanceof InputEvent && retainedInputRangeEvent.getTargetRanges().length===0 && retainedInputRangeSnapshots[0].endOffset===2").unwrap(), "true");
+}
+
#[test]
fn input_event_live_ranges_validate_and_normalize_native_boundaries() {
let mut vm = new_storage_html_test_vm("https://input-range-boundaries.test/");
diff --git a/moli-renderer-v8/tests/fixtures/input-range-dispatch.js b/moli-renderer-v8/tests/fixtures/input-range-dispatch.js
new file mode 100644
index 000000000..672996cf9
--- /dev/null
+++ b/moli-renderer-v8/tests/fixtures/input-range-dispatch.js
@@ -0,0 +1,48 @@
+(() => {
+ const assert=(value,label)=>{if(!value)throw Error(label);};
+ const host=document.createElement('div');document.body.append(host);
+ const shadowHost=document.createElement('div');host.append(shadowHost);
+ const shadow=shadowHost.attachShadow({mode:'open'});
+ const makeEvent=(text,type='range-lifecycle',init={})=>new InputEvent(type,{cancelable:true,targetRanges:[new StaticRange({startContainer:text,startOffset:0,endContainer:text,endOffset:2})],...init});
+ const targets=[['element',host,true],['document',document,true],['detached',document.createElement('div'),true],['fragment',document.createDocumentFragment(),true],['shadow',shadow,true],['window',window,false],['plain',new EventTarget(),false]];
+ for(const [name,target,clears] of targets){
+ const text=document.createTextNode('abc');host.append(text);
+ const event=makeEvent(text),snapshot=event.getTargetRanges()[0],seen=[];
+ const first=e=>{seen.push(e.getTargetRanges()[0].endOffset);text.deleteData(0,1);};
+ const second=e=>{seen.push(e.getTargetRanges()[0].endOffset);};
+ target.addEventListener(event.type,first);target.addEventListener(event.type,second);
+ try{assert(target.dispatchEvent(event)===true,name+' dispatch result');}finally{target.removeEventListener(event.type,first);target.removeEventListener(event.type,second);}
+ assert(seen.join()==='2,1',name+' ranges stay live throughout listeners');
+ assert(event.getTargetRanges().length===(clears?0:1),name+' dispatch lifetime boundary');
+ assert(snapshot.endOffset===2,name+' retained snapshots stay static');text.remove();
+ }
+ const text=document.createTextNode('abc');host.append(text);
+ const stopped=makeEvent(text);stopped.stopPropagation();let calls=0;
+ const count=()=>calls++;host.addEventListener(stopped.type,count);
+ host.dispatchEvent(stopped);host.removeEventListener(stopped.type,count);
+ assert(calls===0 && stopped.getTargetRanges().length===0,'pre-stopped dispatch still clears');
+ const canceled=makeEvent(text);canceled.preventDefault();
+ assert(host.dispatchEvent(canceled)===false && canceled.getTargetRanges().length===0,'canceled dispatch clears');
+ const reentrant=makeEvent(text);let nestedError;
+ const nested=event=>{
+ try{host.dispatchEvent(event);}catch(error){nestedError=error;}
+ assert(nestedError?.name==='InvalidStateError' && event.getTargetRanges().length===1,'failed reentrant dispatch must not clear outer ranges');
+ };
+ host.addEventListener(reentrant.type,nested,{once:true});host.dispatchEvent(reentrant);
+ assert(reentrant.getTargetRanges().length===0,'outer dispatch clears after reentrant failure');
+ let afterThrow=false;const failed=makeEvent(text,'range-throw');
+ const cancelError=event=>event.preventDefault();window.addEventListener('error',cancelError);
+ host.addEventListener(failed.type,()=>{throw Error('intentional listener exception');},{once:true});
+ host.addEventListener(failed.type,event=>{afterThrow=event.getTargetRanges().length===1;},{once:true});
+ try{host.dispatchEvent(failed);}finally{window.removeEventListener('error',cancelError);}
+ assert(afterThrow && failed.getTargetRanges().length===0,'throwing listener does not skip native cleanup');
+ assert(failed.eventPhase===Event.NONE && failed.currentTarget===null,'ordinary dispatch fields still clear');
+ host.dispatchEvent(failed);assert(failed.getTargetRanges().length===0,'redispatch never restores old ranges');
+ const frame=document.createElement('iframe');host.append(frame);const child=frame.contentWindow;
+ const childText=child.document.createTextNode('abc');child.document.body.append(childText);
+ const childEvent=new child.InputEvent('range-frame',{targetRanges:[new child.StaticRange({startContainer:childText,startOffset:0,endContainer:childText,endOffset:2})]});
+ child.document.body.addEventListener('range-frame',()=>frame.remove(),{once:true});
+ Node.prototype.dispatchEvent.call(child.document.body,childEvent);
+ assert(childEvent.getTargetRanges().length===0,'retired child owner does not retain dispatch ranges');
+ host.remove();return true;
+})()