beforeunload event not triggering on open()'ed windows

[flumm]

Describe the Bug

When opening a window (e.g. a popup) with open_with_url_and_target_and_features, it's beforeunload event is not triggering in the parent window

Steps to Reproduce

have the following code:

let foo: Window = window()                                     
    .unwrap()                                                  
    .open_with_url_and_target_and_features(                    
        "http://localhost:8080/",                              
        "_blank",                                              
        "{popup:true}",                                        
    )                                                          
    .unwrap()                                                  
    .unwrap();                                                 
                                                               
let closure: Closure<dyn Fn(BeforeUnloadEvent)> =              
    Closure::new(|event: BeforeUnloadEvent| {                  
        event.prevent_default();                               
        log::error!("closed?");                                
    });                                                        
foo.set_onbeforeunload(Some(closure.as_ref().unchecked_ref()));
foo.add_event_listener_with_callback(                          
    "beforeunload",                                            
    closure.as_ref().unchecked_ref(),                          
)                                                              
.unwrap();
closure.forget()

neither the set_onbeforeunload not the add_event_listener trigger the closure
(side note here: the features part of the api should probably an object, not a str ?)

Expected Behavior

it should trigger

Additional Context

in contrast the following simple javascript snippet works as intended for this

let foo = window.open("https://localhost:8080/", "_blank", { popup: true });
foo.onbeforeunload = (event) => { event.preventDefault(); console.log("closed?") };

Am I doing anything wrong here?

[daxpedda]

I'm unfortunately not particularly familiar with the APIs in use here, but if it works in JS then it should work in Wasm as well unless there is race condition. See Bugzilla, which I don't actually think applies here.

Maybe try to more exactly replicate JS, e.g. use Window.onbeforeunload instead of addEventListener(), or see if you can reproduce it the other way around.

(side note here: the features part of the api should probably an object, not a str ?)

According to the MDN documentation you can use popup=true here.

[flumm]

as i wrote in the issue, i tried with addEventListener() as well as with set_onbeforeunload() already, that did not make a difference. also what i didn't mention is that other events trigger, e.g. pagehide but they seem to trigger too often (i get one when the window opens and one when the window is closed)

also not sure what i'd have to do in javascript to try to reproduce the rust behavior?

EDIT: debugged a bit and it seems to be indeed a race condition, not sure where though and how to reproduce it in javascript..

in the restulting wasm/js glue code i set the breakpoint here:

    imports.wbg.__wbg_open_65aa8845e00f96ee = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
        const ret = getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), getStringFromWasm0(arg5, arg6));
        return isLikeNone(ret) ? 0 : addHeapObject(ret);
    }, arguments) };

on the return isLikeNone... line. If i do that and press F8 to continue basically immediatlely, the beforeunload callback triggers reliably, if i take away the breakpoint it does not trigger ever

not sure what to make of it though, maybe you have an idea?

[flumm]

ok I found out what the issue is, one has to wait for the page to load before one can set the beforeunload event.

if i do it in javascript all at once (so not by hand like previously) it also does not work, what i have to do is to wait for the load event to finish:

let foo: Window = window()                                  
    .unwrap()                                               
    .open_with_url_and_target_and_features(                 
        "http://localhost:8080/",                           
        "_blank",                                           
        "popup=true",                                       
    )                                                       
    .unwrap()                                               
    .unwrap();                                              
                                                            
let foo2: Window = foo.clone();                             
                                                            
let load_closure: Closure<dyn Fn()> = Closure::new(move || {
    let close_closure: Closure<dyn Fn(BeforeUnloadEvent)> = 
        Closure::new(|event: BeforeUnloadEvent| {           
            event.prevent_default();                        
            log::error!("closed?");                         
        });                                                 
    foo2.set_onbeforeunload(Some(                           
        close_closure.as_ref().unchecked_ref(),             
    ));                                                     
    close_closure.forget();                                 
});                                                         
                                                            
foo.set_onload(Some(load_closure.as_ref().unchecked_ref()));
load_closure.forget();                                      

sorry for the noise!