diff --git a/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs index a020fcea976..b2a179d394c 100644 --- a/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs +++ b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation.rs @@ -5,6 +5,8 @@ use std::sync::{ }; use std::time::Duration; +mod history_traversal; + struct ResponseGate { requests: AtomicUsize, responses: AtomicUsize, diff --git a/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/history_traversal.rs b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/history_traversal.rs new file mode 100644 index 00000000000..d4121f4d0a4 --- /dev/null +++ b/moli-protocol/src/domains/page/tests/same_document_history/popup_network_navigation/history_traversal.rs @@ -0,0 +1,362 @@ +use super::*; + +async fn traversal_page(response: &'static str) -> (SameDocumentPage, Arc) { + let gate = Arc::new(ResponseGate { + requests: AtomicUsize::new(0), + responses: AtomicUsize::new(0), + release: tokio::sync::Semaphore::new(0), + }); + let observed = gate.clone(); + let routes = axum::Router::new().route( + "/traversal.html", + axum::routing::get(move || { + let gate = observed.clone(); + async move { + use axum::response::IntoResponse; + let visit = gate.requests.fetch_add(1, Ordering::SeqCst) + 1; + if visit > 1 { + gate.release.acquire().await.unwrap().forget(); + } + gate.responses.fetch_add(1, Ordering::SeqCst); + if visit > 1 { + match response { + "204" => return axum::http::StatusCode::NO_CONTENT.into_response(), + "205" => return axum::http::StatusCode::RESET_CONTENT.into_response(), + _ => {} + } + } + let mut result = ( + [(axum::http::header::CONTENT_TYPE, "text/html")], + r#"Traversal target"#, + ) + .into_response(); + if visit > 1 && response == "attachment" { + result.headers_mut().insert( + axum::http::header::CONTENT_DISPOSITION, + axum::http::HeaderValue::from_static("attachment; filename=traversal.txt"), + ); + } + result + } + }), + ); + (SameDocumentPage::with_routes(routes).await, gate) +} + +const SETUP_TRAVERSAL: &str = r#"(async () => { + globalThis.shown = []; + globalThis.traversalPageShown = persisted => shown.push(persisted); + globalThis.popup = open('traversal.html', 'history-traversal'); + await new Promise(resolve => popup.addEventListener('load', resolve, {once:true})); + await new Promise(resolve => setTimeout(resolve, 0)); + if (shown.length !== 1 || shown[0] !== false) throw new Error('missing initial pageshow'); + popup.navigation.updateCurrentEntry({state: {original: true}}); + const entry = popup.navigation.currentEntry; + globalThis.destination = {url: entry.url, key: entry.key, id: entry.id}; + const firstDocument = popup.document; + popup.addEventListener('unload', () => {}); + popup.location.href = 'history.html?second-popup'; + for (let i = 0; popup.document === firstDocument && i < 500; ++i) + await new Promise(resolve => setTimeout(resolve, 10)); + if (popup.document === firstDocument) throw new Error('second Document never committed'); + await new Promise(resolve => setTimeout(resolve, 0)); + globalThis.popupDocument = popup.document; + globalThis.popupNavigation = popup.navigation; + globalThis.PopupDOMException = popup.DOMException; + globalThis.events = []; + globalThis.signals = []; + globalThis.reasons = []; + globalThis.states = {}; + globalThis.details = []; + globalThis.info = {token: 42}; + for (const type of ['beforeunload', 'pagehide', 'unload']) + popup.addEventListener(type, () => { + events.push(type); + if (type === 'pagehide' && ACTION === 'close-pagehide') popup.close(); + }); + popupNavigation.addEventListener('navigate', event => { + events.push('navigate'); + signals.push(event.signal); + event.signal.addEventListener('abort', () => events.push('abort')); + const detail = { + type: event.navigationType, cancelable: event.cancelable, + canIntercept: event.canIntercept, userInitiated: event.userInitiated, + hashChange: event.hashChange, sameDocument: event.destination.sameDocument, + urlMatches: event.destination.url === destination.url, + keyMatches: event.destination.key === destination.key, + idMatches: event.destination.id === destination.id, + index: event.destination.index, state: event.destination.getState(), + infoMatches: event.info === (METHOD === 'history-back' ? undefined : info), + formData: event.formData, downloadRequest: event.downloadRequest, + sourceElement: event.sourceElement, + }; + details.push(detail); + if (ACTION === 'prevent') { + event.preventDefault(); + detail.prevented = event.defaultPrevented; + } + if (ACTION === 'intercept') { + try { event.intercept(); detail.intercept = 'allowed'; } + catch (error) { detail.intercept = error.name; } + } + if (ACTION === 'stop-dispatch') popup.stop(); + if (ACTION === 'close-dispatch') popup.close(); + }); + popupNavigation.addEventListener('navigateerror', event => { + events.push('error:' + event.error.name); reasons.push(event.error); + }); + popupNavigation.addEventListener('navigatesuccess', () => events.push('success')); + globalThis.traversalSnapshot = () => ({ + closed: popup.closed, sameDocument: popup.document === popupDocument, + href: popup.location.href, events: [...events], details: [...details], + index: popup.closed ? null : popup.navigation.currentEntry.index, + length: popup.closed ? null : popup.history.length, + states: {...states}, aborted: signals.map(signal => signal.aborted), + errorIdentity: reasons.every(error => error === signals[0].reason && error instanceof PopupDOMException), + reasons: reasons.length, shown: [...shown], + }); + globalThis.beginTraversal = () => { + let result; + if (METHOD === 'history-back') popup.history.back(); + else if (METHOD === 'back') result = popupNavigation.back({info}); + else result = popupNavigation.traverseTo(destination.key, {info}); + if (result) for (const key of ['committed', 'finished']) result[key].then( + () => states[key] = 'fulfilled', + error => { states[key] = error.name; reasons.push(error); } + ); + return traversalSnapshot(); + }; + return traversalSnapshot(); +})()"#; + +async fn setup_traversal( + page: &mut SameDocumentPage, + method: &str, + action: &str, +) -> serde_json::Value { + page.evaluate( + &SETUP_TRAVERSAL + .replace("METHOD", &json!(method).to_string()) + .replace("ACTION", &json!(action).to_string()), + ) + .await +} + +fn assert_traverse_event(snapshot: &serde_json::Value, action: &str) { + let mut expected = json!({ + "type": "traverse", "cancelable": false, "canIntercept": false, + "userInitiated": false, "hashChange": false, "sameDocument": false, + "urlMatches": true, "keyMatches": true, "idMatches": true, + "index": 0, "state": {"original": true}, "infoMatches": true, + "formData": null, "downloadRequest": null, "sourceElement": null, + }); + if action == "prevent" { + expected["prevented"] = json!(false); + } + if action == "intercept" { + expected["intercept"] = json!("SecurityError"); + } + assert_eq!(snapshot["details"], json!([expected]), "{snapshot}"); +} + +#[tokio::test(flavor = "multi_thread")] +async fn popup_cross_document_history_traversal_events_and_cancellation() { + for method in ["back", "traverseTo", "history-back"] { + for action in [ + "none", + "prevent", + "intercept", + "stop-dispatch", + "stop-pending", + "close-pending", + ] { + let (mut page, gate) = traversal_page("html").await; + let initial = setup_traversal(&mut page, method, action).await; + let started = page.evaluate("beginTraversal()").await; + assert_eq!(started["events"], json!([]), "{method}/{action}: {started}"); + assert_eq!(started["index"], 1); + ResponseGate::wait_for(&gate.requests, 2).await; + let pending = page.evaluate("traversalSnapshot()").await; + assert_traverse_event(&pending, action); + assert_eq!(pending["sameDocument"], true, "{pending}"); + assert_eq!(pending["href"], initial["href"]); + assert_eq!(pending["index"], 1); + assert_eq!(pending["length"], 2); + if action != "stop-dispatch" { + assert_eq!(pending["events"], json!(["beforeunload", "navigate"])); + assert_eq!(pending["states"], json!({})); + assert_eq!(pending["aborted"], json!([false])); + } + match action { + "stop-pending" => { + page.evaluate("popup.stop(); void 0").await; + } + "close-pending" => { + page.evaluate("popup.close(); void 0").await; + } + _ => {} + } + gate.release.add_permits(1); + ResponseGate::wait_for(&gate.responses, 2).await; + let snapshot = if action == "close-pending" { + page.evaluate( + "new Promise(r => setTimeout(r, 100)).then(() => traversalSnapshot())", + ) + .await + } else { + page.evaluate( + r#"(async () => { + for (let i = 0; shown.length < 2 && i < 500; ++i) + await new Promise(resolve => setTimeout(resolve, 10)); + return traversalSnapshot(); + })()"#, + ) + .await + }; + let aborted = action.starts_with("stop") || action.starts_with("close"); + let mut events = vec!["beforeunload", "navigate"]; + if action == "close-pending" { + events.push("beforeunload"); + } + if aborted { + events.extend(["abort", "error:AbortError"]); + } + events.extend(["pagehide", "unload"]); + assert_eq!( + snapshot["events"], + json!(events), + "{method}/{action}: {snapshot}" + ); + assert_eq!(snapshot["aborted"], json!([aborted]), "{snapshot}"); + assert_eq!(snapshot["errorIdentity"], true, "{snapshot}"); + let states = if aborted && method != "history-back" { + json!({"committed": "AbortError", "finished": "AbortError"}) + } else { + json!({}) + }; + assert_eq!(snapshot["states"], states, "{snapshot}"); + assert_eq!( + snapshot["reasons"], + if aborted { + if method == "history-back" { 1 } else { 3 } + } else { + 0 + } + ); + if action == "close-pending" { + assert_eq!(snapshot["closed"], true); + assert_eq!(snapshot["shown"], json!([false]), "{snapshot}"); + } else { + assert_eq!(snapshot["closed"], false); + assert_eq!(snapshot["sameDocument"], false, "{snapshot}"); + assert_eq!(snapshot["index"], 0); + assert_eq!(snapshot["length"], 2); + assert_eq!(snapshot["shown"], json!([false, false])); + let entry = page.evaluate("({key: popup.navigation.currentEntry.key === destination.key, state: popup.navigation.currentEntry.getState()})").await; + assert_eq!(entry, json!({"key": true, "state": {"original": true}})); + page.evaluate("popup.close(); void 0").await; + } + page.assert_history(&[""], 0).await; + } + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn popup_cross_document_history_traversal_ignored_responses_remain_pending() { + for response in ["204", "205", "attachment"] { + let (mut page, gate) = traversal_page(response).await; + page.allow_downloads().await; + let initial = setup_traversal(&mut page, "back", "none").await; + page.evaluate("beginTraversal()").await; + ResponseGate::wait_for(&gate.requests, 2).await; + gate.release.add_permits(1); + ResponseGate::wait_for(&gate.responses, 2).await; + let pending = page + .evaluate("new Promise(r => setTimeout(r, 100)).then(() => traversalSnapshot())") + .await; + assert_traverse_event(&pending, "none"); + assert_eq!( + pending["events"], + json!(["beforeunload", "navigate"]), + "{response}: {pending}" + ); + assert_eq!(pending["states"], json!({})); + assert_eq!(pending["aborted"], json!([false])); + assert_eq!(pending["sameDocument"], true); + assert_eq!(pending["href"], initial["href"]); + assert_eq!(pending["index"], 1); + assert_eq!(pending["shown"], json!([false])); + let stopped = page + .evaluate("popup.stop(); Promise.resolve().then(() => traversalSnapshot())") + .await; + assert_eq!( + stopped["states"], + json!({"committed": "AbortError", "finished": "AbortError"}), + "{stopped}" + ); + assert_eq!(stopped["aborted"], json!([true])); + assert_eq!(stopped["errorIdentity"], true); + page.evaluate("popup.close(); void 0").await; + page.assert_history(&[""], 0).await; + } +} + +#[tokio::test(flavor = "multi_thread")] +async fn popup_cross_document_history_traversal_close_during_callbacks() { + for action in ["close-dispatch", "close-pagehide"] { + let (mut page, gate) = traversal_page("html").await; + setup_traversal(&mut page, "back", action).await; + page.evaluate("beginTraversal()").await; + if action == "close-pagehide" { + ResponseGate::wait_for(&gate.requests, 2).await; + gate.release.add_permits(1); + ResponseGate::wait_for(&gate.responses, 2).await; + } + let snapshot = page + .evaluate("new Promise(r => setTimeout(r, 100)).then(() => traversalSnapshot())") + .await; + assert_eq!(snapshot["closed"], true, "{action}: {snapshot}"); + assert_traverse_event(&snapshot, action); + if action == "close-dispatch" { + assert_eq!( + snapshot["events"], + json!([ + "beforeunload", + "navigate", + "beforeunload", + "abort", + "error:AbortError", + "pagehide", + "unload" + ]), + "{snapshot}" + ); + assert_eq!(snapshot["aborted"], json!([true])); + assert_eq!( + snapshot["states"], + json!({"committed": "AbortError", "finished": "AbortError"}) + ); + assert_eq!(snapshot["errorIdentity"], true); + assert_eq!(snapshot["reasons"], 3); + assert_eq!(gate.requests.load(Ordering::SeqCst), 1); + } else { + assert_eq!( + snapshot["events"], + json!([ + "beforeunload", + "navigate", + "pagehide", + "beforeunload", + "unload" + ]), + "{snapshot}" + ); + assert_eq!(snapshot["aborted"], json!([false])); + assert_eq!(snapshot["states"], json!({})); + assert_eq!(snapshot["reasons"], 0); + } + page.assert_history(&[""], 0).await; + } +} diff --git a/moli-renderer-v8/src/context_bootstrap/history_runtime.rs b/moli-renderer-v8/src/context_bootstrap/history_runtime.rs index d6c46fca90f..37d818b4744 100644 --- a/moli-renderer-v8/src/context_bootstrap/history_runtime.rs +++ b/moli-renderer-v8/src/context_bootstrap/history_runtime.rs @@ -8,7 +8,8 @@ pub(super) mod traversal; pub(super) use self::admission::require_fully_active_history_owner; pub(super) use self::traversal::{ apply_pending_history_traversal, cancel_active_history_traversal_intercept_settlement, - pending_history_traversal_target_index, route_history_traversal_task, + history_traversal_target_window, pending_history_traversal_target_index, + route_history_traversal_task, }; pub(super) use super::navigation_traversal_coordinator::cancel_pending as cancel_pending_precommit_history_traversal; diff --git a/moli-renderer-v8/src/context_bootstrap/history_runtime/traversal.rs b/moli-renderer-v8/src/context_bootstrap/history_runtime/traversal.rs index cf5de0e4163..aba74e4fbe3 100644 --- a/moli-renderer-v8/src/context_bootstrap/history_runtime/traversal.rs +++ b/moli-renderer-v8/src/context_bootstrap/history_runtime/traversal.rs @@ -140,7 +140,7 @@ pub(in crate::context_bootstrap) fn route_history_traversal_task( crate::native_bridge::PendingHistoryTraversalAction::SameDocument(traversal) => { traversal.results.as_slice() } - crate::native_bridge::PendingHistoryTraversalAction::ChildCrossDocument(traversal) => { + crate::native_bridge::PendingHistoryTraversalAction::CrossDocument(traversal) => { traversal.results.as_slice() } }; @@ -305,7 +305,7 @@ pub(in crate::context_bootstrap) fn finish_history_participant<'s>( } } -fn history_traversal_target_window<'s>( +pub(in crate::context_bootstrap) fn history_traversal_target_window<'s>( scope: &mut v8::PinScope<'s, '_>, host: &mut PageScriptHost, target: crate::native_bridge::WindowTaskTarget, diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_cancellation.rs b/moli-renderer-v8/src/context_bootstrap/navigation_cancellation.rs index 7605da587dc..438909fe74e 100644 --- a/moli-renderer-v8/src/context_bootstrap/navigation_cancellation.rs +++ b/moli-renderer-v8/src/context_bootstrap/navigation_cancellation.rs @@ -168,13 +168,6 @@ fn stop_navigation_for_window<'s>( if navigation_unload_event_active(scope, window) { return; } - if let Some(OwnerDispatchScope::LightweightPopup(popup_id)) = - runtime_window_dispatch_scope(scope, window) - && let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) - && unsafe { &*host_ptr }.lightweight_popup_has_pending_history_traversal(popup_id) - { - return; - } inform_about_canceled_navigation_for_window( scope, window, @@ -216,7 +209,23 @@ pub(super) fn clear_pending_cross_document_navigation_for_window<'s>( return; }; let host = unsafe { &mut *host_ptr }; - match runtime_window_dispatch_scope(scope, window) { + let dispatch_scope = runtime_window_dispatch_scope(scope, window); + if window_navigation_is_stopping(scope, window) + && match dispatch_scope { + Some(OwnerDispatchScope::Child(handle)) => { + host.child_browsing_context_has_pending_cross_document_traversal(handle) + } + Some(OwnerDispatchScope::LightweightPopup(popup_id)) => { + host.lightweight_popup_has_pending_cross_document_traversal(popup_id) + } + _ => false, + } + { + // stop() still aborts the Navigation API signal and method promises, + // but cannot cancel the physical cross-document history traversal. + return; + } + match dispatch_scope { Some(crate::native_bridge::OwnerDispatchScope::Top) => { host.clear_pending_location_navigation(); } diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_events.rs b/moli-renderer-v8/src/context_bootstrap/navigation_events.rs index bacea4a6e62..7c04a5f51cb 100644 --- a/moli-renderer-v8/src/context_bootstrap/navigation_events.rs +++ b/moli-renderer-v8/src/context_bootstrap/navigation_events.rs @@ -582,6 +582,7 @@ fn dispatch_unload_lifecycle_event_for_runtime_owner<'s>( event_type: &str, event: v8::Local<'s, v8::Object>, ) { + let previous_unload = super::navigation_window::navigation_unload_event_active(scope, owner); let _document_unload = context_host_ptr_from_global_bridge(scope).and_then(|host_ptr| { let host = unsafe { &*host_ptr }; super::window_accessors::window_document_handle(scope, owner, host) @@ -609,8 +610,14 @@ fn dispatch_unload_lifecycle_event_for_runtime_owner<'s>( event, matches!(event_type, "pagehide" | "unload"), ); + } else if let Some(popup_id) = + crate::native_bridge::lightweight_popup_id_from_window(scope, owner) + && let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) + { + unsafe { &mut *host_ptr } + .dispatch_lightweight_popup_window_event(scope, popup_id, event_type, event); } - set_navigation_unload_event_active(scope, owner, false); + set_navigation_unload_event_active(scope, owner, previous_unload); } pub(super) fn queue_hash_change_for_runtime_owner<'s>( @@ -1105,12 +1112,14 @@ pub(super) fn dispatch_navigation_traverse_event_with_outcome<'s>( let current_href = window_location_for_holder(scope, owner) .and_then(|location| location_href_slot(scope, location)) .unwrap_or_default(); - let hash_change = should_dispatch_hash_change(¤t_href, &target_href); let destination_same_document = navigation_destination_same_document_value(scope, destination); + let hash_change = + destination_same_document && should_dispatch_hash_change(¤t_href, &target_href); let Some(signal) = create_navigation_abort_signal(scope) else { return NavigationDispatchOutcome::proceed(); }; - let cancelable = runtime_window_is_global(scope, owner); + let cancelable = destination_same_document + && child_browsing_context_handle_for_runtime_owner(scope, owner).is_none(); let Some(event) = construct_native_navigate_event( scope, "traverse", diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_result.rs b/moli-renderer-v8/src/context_bootstrap/navigation_result.rs index a12332a117b..60c5a25df17 100644 --- a/moli-renderer-v8/src/context_bootstrap/navigation_result.rs +++ b/moli-renderer-v8/src/context_bootstrap/navigation_result.rs @@ -22,6 +22,8 @@ const CROSS_DOCUMENT_PENDING_COMMITTED_REJECT_SLOT: &str = "__lmCrossDocumentPendingCommittedReject"; const CROSS_DOCUMENT_PENDING_FINISHED_REJECT_SLOT: &str = "__lmCrossDocumentPendingFinishedReject"; const CROSS_DOCUMENT_PENDING_HREF_SLOT: &str = "__lmCrossDocumentPendingHref"; +const CROSS_DOCUMENT_PENDING_TRAVERSAL_RESULTS_SLOT: &str = + "__lmCrossDocumentPendingTraversalResults"; const NAVIGATION_ACTIVE_CROSS_DOCUMENT_PENDING_SLOT: &str = "__lmNavigationActiveCrossDocumentPending"; @@ -185,6 +187,33 @@ pub(super) fn track_cross_document_location_navigation<'s>( set_navigation_active_cross_document_pending(scope, navigation, data); } +pub(super) fn track_cross_document_traversal_navigation<'s>( + scope: &mut v8::PinScope<'s, '_>, + navigation: v8::Local<'s, v8::Object>, + signal: Option>, + href: &str, + results: &[crate::native_bridge::PendingNavigationResult], +) { + track_cross_document_location_navigation(scope, navigation, signal, href); + let data = navigation_active_cross_document_pending(scope, navigation) + .expect("new traversal must retain its pending navigation"); + let mut resolvers = Vec::with_capacity(results.len() * 2); + for result in results { + let committed = v8::Local::new(scope, &result.committed_resolver); + let finished = v8::Local::new(scope, &result.finished_resolver); + resolvers.push(committed.into()); + resolvers.push(finished.into()); + suppress_unhandled_rejection(scope, finished.get_promise(scope)); + } + let resolvers = v8::Array::new_with_elements(scope, &resolvers); + set_private_value( + scope, + data, + CROSS_DOCUMENT_PENDING_TRAVERSAL_RESULTS_SLOT, + resolvers.into(), + ); +} + pub(super) fn navigation_immediate_current_entry_result<'s>( scope: &mut v8::PinScope<'s, '_>, owner: v8::Local<'s, v8::Object>, @@ -387,6 +416,21 @@ pub(super) fn cancel_active_cross_document_navigation<'s>( { let _ = reject.call(scope, receiver, &[error]); } + if let Some(resolvers) = + get_private_value(scope, data, CROSS_DOCUMENT_PENDING_TRAVERSAL_RESULTS_SLOT) + .and_then(|value| v8::Local::::try_from(value).ok()) + { + for index in 0..resolvers.length() { + if let Some(resolver) = resolvers + .get_index(scope, index) + .and_then(|value| v8::Local::::try_from(value).ok()) + // Only native PromiseResolvers are stored in this private array. + .map(|object| unsafe { v8::Local::::cast_unchecked(object) }) + { + let _ = resolver.reject(scope, error); + } + } + } true } diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_traversal_coordinator.rs b/moli-renderer-v8/src/context_bootstrap/navigation_traversal_coordinator.rs index 511f9dac526..2a919da77f2 100644 --- a/moli-renderer-v8/src/context_bootstrap/navigation_traversal_coordinator.rs +++ b/moli-renderer-v8/src/context_bootstrap/navigation_traversal_coordinator.rs @@ -551,6 +551,7 @@ fn commit(scope: &mut v8::PinScope<'_, '_>, admission: &PendingHistoryTraversalA participant.handle, participant.url.as_str(), participant.seed.clone(), + None, ) { for queued in &cross_document { host.cancel_joint_child_history_navigation(queued.handle, step); diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_traversal_execution.rs b/moli-renderer-v8/src/context_bootstrap/navigation_traversal_execution.rs index 3dc266a3f57..41f15166f01 100644 --- a/moli-renderer-v8/src/context_bootstrap/navigation_traversal_execution.rs +++ b/moli-renderer-v8/src/context_bootstrap/navigation_traversal_execution.rs @@ -1,16 +1,23 @@ -use super::history_runtime::route_history_traversal_task; +use super::history_runtime::{ + history_traversal_target_window, reject_pending_navigation_results, + route_history_traversal_task, +}; use super::navigation_entry::history_entries; +use super::navigation_events::{ + NavigationDispatchOutcome, dispatch_beforeunload_for_runtime_owner, + dispatch_navigation_traverse_event_with_outcome, +}; use super::navigation_result::{ - navigation_pending_result, navigation_rejected_dom_exception_result, + cancel_active_cross_document_navigation, navigation_dom_exception, navigation_pending_result, + navigation_rejected_dom_exception_result, track_cross_document_traversal_navigation, }; use super::navigation_seed::history_entry_seed_for_traversal; +use super::navigation_window::{navigation_document_is_active, window_navigation_for_holder}; use super::navigation_window::{ - child_browsing_context_handle_for_runtime_owner, runtime_window_is_global, - window_task_target_for_runtime_owner, + runtime_window_is_global, window_history_for_holder, window_task_target_for_runtime_owner, }; use super::*; -use crate::document_runtime::DomHandle; -use crate::native_bridge::PendingHistoryTraversalAction; +use crate::native_bridge::{PendingCrossDocumentTraversal, PendingHistoryTraversalAction}; use moli_history::HistoryEntryRef; pub(super) struct TraversalTarget<'s> { @@ -30,7 +37,6 @@ pub(super) fn queue_navigation_traversal_with_result<'s>( traversal_target_entry(scope, &target) .and_then(|entry| super::session_history::step_for_entry(scope, target.owner, &entry)) }); - let child_handle = child_browsing_context_handle_for_traversal(scope, target.owner); let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { return Some(navigation_rejected_dom_exception_result( scope, @@ -58,20 +64,6 @@ pub(super) fn queue_navigation_traversal_with_result<'s>( host.record_pending_location_navigation(target_url, Some(seed.clone())); return Some(navigation_pending_result(scope)); } - if let Some(popup_id) = - crate::native_bridge::lightweight_popup_id_from_window(scope, target.owner) - { - host.queue_lightweight_popup_cross_document_traversal( - scope, - popup_id, - target_url.as_str(), - seed, - ); - return Some(navigation_pending_result(scope)); - } - if child_handle.is_none() { - return Some(navigation_pending_result(scope)); - }; let target_key = traversal_target_entry(scope, &target) .map(|entry| entry.borrow().key.as_str().to_owned()); let receiver_context = target @@ -79,7 +71,7 @@ pub(super) fn queue_navigation_traversal_with_result<'s>( .get_creation_context(scope) .unwrap_or_else(|| scope.get_current_context()); let receiver_scope = &mut v8::ContextScope::new(scope, receiver_context); - let (result, producer) = host.queue_child_cross_document_traversal_with_result( + let (result, producer) = host.queue_cross_document_history_traversal_with_result( receiver_scope, exact_target, target.target_index, @@ -126,7 +118,6 @@ pub(super) fn queue_history_traversal_without_result<'s>( traversal_target_entry(scope, &target) .and_then(|entry| super::session_history::step_for_entry(scope, target.owner, &entry)) }); - let child_handle = child_browsing_context_handle_for_traversal(scope, target.owner); let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else { return; }; @@ -134,7 +125,7 @@ pub(super) fn queue_history_traversal_without_result<'s>( let Some(exact_target) = window_task_target_for_runtime_owner(scope, host, target.owner) else { return; }; - if let Some((target_url, mut seed)) = history_entry_seed_for_traversal( + if let Some((_target_url, mut seed)) = history_entry_seed_for_traversal( scope, target.owner, target.current_index, @@ -153,34 +144,21 @@ pub(super) fn queue_history_traversal_without_result<'s>( host.record_pending_top_level_history_traversal(delta); return; } - if let Some(popup_id) = - crate::native_bridge::lightweight_popup_id_from_window(scope, target.owner) - { - host.queue_lightweight_popup_cross_document_traversal( - scope, - popup_id, - target_url.as_str(), - seed, - ); - return; - } - if child_handle.is_some() { - let target_key = traversal_target_entry(scope, &target) - .map(|entry| entry.borrow().key.as_str().to_owned()); - let receiver_context = target - .history - .get_creation_context(scope) - .unwrap_or_else(|| scope.get_current_context()); - let receiver_scope = &mut v8::ContextScope::new(scope, receiver_context); - if let Some(producer) = host.queue_child_cross_document_traversal( - receiver_scope, - exact_target, - target.target_index, - target_key, - seed, - ) { - route_history_traversal_task(receiver_scope, host, producer); - } + let target_key = traversal_target_entry(scope, &target) + .map(|entry| entry.borrow().key.as_str().to_owned()); + let receiver_context = target + .history + .get_creation_context(scope) + .unwrap_or_else(|| scope.get_current_context()); + let receiver_scope = &mut v8::ContextScope::new(scope, receiver_context); + if let Some(producer) = host.queue_cross_document_history_traversal( + receiver_scope, + exact_target, + target.target_index, + target_key, + seed, + ) { + route_history_traversal_task(receiver_scope, host, producer); } return; } @@ -226,6 +204,160 @@ fn traversal_target_entry_still_available<'s>( .is_some_and(|entry| std::rc::Rc::ptr_eq(&entry, expected_entry)) } +fn traversal_target_key_still_available<'s>( + scope: &mut v8::PinScope<'s, '_>, + history: v8::Local<'s, v8::Object>, + target_index: u32, + expected_key: Option<&str>, +) -> bool { + let Some(expected_key) = expected_key else { + return true; + }; + history_entries(scope, history).is_some_and(|entries| { + entries + .get(target_index as usize) + .is_some_and(|entry| entry.borrow().key.as_str() == expected_key) + }) +} + +pub(in crate::context_bootstrap) fn apply_pending_cross_document_traversal<'s, 'i>( + scope: &mut v8::PinScope<'s, 'i>, + host: &mut PageScriptHost, + traversal: PendingCrossDocumentTraversal, +) { + if matches!( + traversal.target.dispatch_scope(), + crate::native_bridge::OwnerDispatchScope::Child(_) + ) { + super::history_runtime::apply_pending_history_traversal( + scope, + host, + crate::native_bridge::PendingHistoryTraversal { + joint_step: traversal.seed.session_history.target_step, + target: traversal.target, + target_index: traversal.target_index, + target_key: traversal.target_key, + info: traversal.info, + results: traversal.results, + }, + ); + return; + } + let Some(target_url) = traversal + .seed + .entries + .iter() + .find(|entry| entry.history_index == traversal.seed.current_index) + .map(|entry| entry.url.clone()) + else { + reject_cross_document_traversal(scope, &traversal); + return; + }; + let Some(owner) = history_traversal_target_window(scope, host, traversal.target) else { + reject_cross_document_traversal(scope, &traversal); + return; + }; + let Some(history) = window_history_for_holder(scope, owner) else { + reject_cross_document_traversal(scope, &traversal); + return; + }; + if !traversal_target_key_still_available( + scope, + history, + traversal.target_index, + traversal.target_key.as_deref(), + ) { + reject_cross_document_traversal(scope, &traversal); + return; + } + let info = traversal + .info + .as_ref() + .map(|info| v8::Local::new(scope, info)); + let dispatch_scope = traversal.target.dispatch_scope(); + let retiring_document = + host.current_window_document_task_target_for_dispatch_scope(dispatch_scope); + let is_current = |scope: &mut v8::PinScope<'s, 'i>, host: &PageScriptHost| { + retiring_document.is_some() + && host.current_window_document_task_target_for_dispatch_scope(dispatch_scope) + == retiring_document + && window_task_target_for_runtime_owner(scope, host, owner) == Some(traversal.target) + && navigation_document_is_active(scope, owner) + }; + dispatch_beforeunload_for_runtime_owner(scope, owner); + if !is_current(scope, host) { + reject_cross_document_traversal(scope, &traversal); + return; + } + let navigation = window_navigation_for_holder(scope, owner); + if let Some(navigation) = navigation { + cancel_active_cross_document_navigation(scope, navigation, None); + } + if !is_current(scope, host) { + reject_cross_document_traversal(scope, &traversal); + return; + } + let outcome = navigation.map_or_else(NavigationDispatchOutcome::proceed, |navigation| { + dispatch_navigation_traverse_event_with_outcome( + scope, + navigation, + history, + traversal.target_index, + info, + ) + }); + if let Some(error) = outcome.abort_error { + // stop() aborts the API method and signal even though a cross-document + // history traversal itself cannot be canceled by script. + reject_pending_navigation_results(scope, &traversal.results, error); + } + // close() queues retirement of this exact Window. Keep its dispatched + // event and API results alive until the close task aborts them together. + let closing_popup = matches!(dispatch_scope, + crate::native_bridge::OwnerDispatchScope::LightweightPopup(popup_id) + if host.lightweight_popup_is_closing(popup_id)) + && host.current_window_document_task_target_for_dispatch_scope(dispatch_scope) + == retiring_document; + if outcome.proceed + && outcome.abort_error.is_none() + && (is_current(scope, host) || closing_popup) + && let Some(navigation) = navigation + { + track_cross_document_traversal_navigation( + scope, + navigation, + outcome.signal, + &target_url, + &traversal.results, + ); + } + if !outcome.proceed || !is_current(scope, host) { + if !closing_popup { + reject_cross_document_traversal(scope, &traversal); + } + return; + } + match dispatch_scope { + crate::native_bridge::OwnerDispatchScope::Child(_) => { + unreachable!("child traversal uses the coordinator") + } + crate::native_bridge::OwnerDispatchScope::LightweightPopup(popup_id) => { + if !host.queue_lightweight_popup_cross_document_traversal( + scope, + popup_id, + &target_url, + traversal.seed, + ) && let Some(navigation) = navigation + { + cancel_active_cross_document_navigation(scope, navigation, None); + } + } + crate::native_bridge::OwnerDispatchScope::Top => { + unreachable!("top-level traversals are handed off to the browser") + } + } +} + pub(crate) fn apply_authorized_history_traversal_task( scope: &mut v8::PinScope<'_, '_>, host: &mut PageScriptHost, @@ -235,30 +367,19 @@ pub(crate) fn apply_authorized_history_traversal_task( PendingHistoryTraversalAction::SameDocument(traversal) => { super::history_runtime::apply_pending_history_traversal(scope, host, traversal); } - PendingHistoryTraversalAction::ChildCrossDocument(traversal) => { - super::history_runtime::apply_pending_history_traversal( - scope, - host, - crate::native_bridge::PendingHistoryTraversal { - joint_step: traversal.seed.session_history.target_step, - target: traversal.target, - target_index: traversal.target_index, - target_key: traversal.target_key, - info: traversal.info, - results: traversal.results, - }, - ); + PendingHistoryTraversalAction::CrossDocument(traversal) => { + apply_pending_cross_document_traversal(scope, host, *traversal); } } } -fn child_browsing_context_handle_for_traversal<'s>( - scope: &mut v8::PinScope<'s, '_>, - owner: v8::Local<'s, v8::Object>, -) -> Option { - if runtime_window_is_global(scope, owner) { - None - } else { - child_browsing_context_handle_for_runtime_owner(scope, owner) +fn reject_cross_document_traversal( + scope: &mut v8::PinScope<'_, '_>, + traversal: &PendingCrossDocumentTraversal, +) { + if traversal.results.is_empty() { + return; } + let error = navigation_dom_exception(scope, "Navigation was canceled", "AbortError"); + reject_pending_navigation_results(scope, &traversal.results, error); } diff --git a/moli-renderer-v8/src/native_bridge/context_host/popups.rs b/moli-renderer-v8/src/native_bridge/context_host/popups.rs index d8214f296ab..d6a0ec6f566 100644 --- a/moli-renderer-v8/src/native_bridge/context_host/popups.rs +++ b/moli-renderer-v8/src/native_bridge/context_host/popups.rs @@ -7,7 +7,9 @@ use crate::{ context_bootstrap::{ SIMPLE_EVENT_TARGET_LISTENERS_SLOT, SharedWebStorageStore, WINDOW_NAME_SLOT, apply_local_window_location_navigation, clear_simple_window_event_handler_values, - deep_clone_shared_web_storage_store, dispatch_simple_event_target_event, + construct_original_page_transition_event, deep_clone_shared_web_storage_store, + dispatch_beforeunload_for_runtime_owner, dispatch_pagehide_for_runtime_owner, + dispatch_simple_event_target_event, dispatch_unload_for_runtime_owner, finish_cross_document_navigation_for_window, history_entry_seed_for_cross_document_location, initialize_simple_event_target, install_navigation_bootstrap_entry_for_holder, install_simple_window_event_handlers, @@ -424,6 +426,7 @@ struct LightweightPopupDocumentRecord { pending_load_event: Option, queued_load_event: Option, load_event_dispatched: bool, + unload_events_dispatched: bool, // Location replacement remains in effect while load callbacks run, and // document.open() does not make a previously loaded Document incomplete. completely_loaded: bool, @@ -1087,6 +1090,7 @@ impl PageScriptHost { pending_load_event: None, queued_load_event: None, load_event_dispatched: false, + unload_events_dispatched: false, completely_loaded: true, }, session_storage_store, @@ -2047,6 +2051,13 @@ impl PageScriptHost { .unwrap_or_else(|| target_url.clone()); let document_referrer = navigation_state.policy_container.document_referrer.clone(); if moli_url::is_about_blank(&target_url) { + if matches!(history, PendingLightweightPopupHistory::Traversal(_)) { + finish_cross_document_navigation_for_window(scope, window, target_url.as_str()); + self.dispatch_lightweight_popup_document_unload(scope, popup_id); + if !self.lightweight_popup_navigation_attempt_is_current(navigation_task) { + return false; + } + } navigation_state.reset_for_empty_document(target_url.clone()); if !self.commit_lightweight_popup_document( scope, @@ -2271,6 +2282,7 @@ impl PageScriptHost { pending_load_event: None, queued_load_event: None, load_event_dispatched: false, + unload_events_dispatched: false, completely_loaded: false, }, ); @@ -2874,6 +2886,20 @@ impl PageScriptHost { return PopupDocumentLoadApplication::Applied { body_activity }; } Ok(PopupDocumentLoadOutcome::Loaded(loaded)) => { + if matches!( + pending.history, + PendingLightweightPopupHistory::Traversal(_) + ) { + finish_cross_document_navigation_for_window( + scope, + window, + pending.target_url.as_str(), + ); + self.dispatch_lightweight_popup_document_unload(scope, popup_id); + if !self.lightweight_popup_navigation_attempt_is_current(task) { + return PopupDocumentLoadApplication::NotApplied; + } + } let mut loaded = *loaded; let opener_sandbox = self .lightweight_popup_record(popup_id) @@ -3282,6 +3308,30 @@ impl PageScriptHost { } } + pub(crate) fn dispatch_lightweight_popup_document_unload( + &mut self, + scope: &mut v8::PinScope<'_, '_>, + popup_id: u64, + ) { + let Some(document) = self.lightweight_popup_document_record_mut(popup_id) else { + return; + }; + if document.unload_events_dispatched { + return; + } + // Mark before entering author callbacks: pagehide can call close(), + // whose queued destruction must not unload this Document a second time. + document.unload_events_dispatched = true; + let owner = document.owner; + let Some(window) = self.lightweight_popup_window(scope, popup_id) else { + return; + }; + dispatch_pagehide_for_runtime_owner(scope, window); + if self.lightweight_popup_document_owner_is_current(owner) { + dispatch_unload_for_runtime_owner(scope, window); + } + } + pub(crate) fn dispatch_lightweight_popup_load_event( &mut self, scope: &mut v8::PinScope<'_, '_>, @@ -3290,9 +3340,22 @@ impl PageScriptHost { let window = self .lightweight_popup_window(scope, popup_id) .expect("authorized popup load event must retain its WindowProxy"); + let document_owner = self.current_lightweight_popup_document_owner(popup_id); let event = lightweight_popup_event(scope, window, "load") .expect("authorized popup load event must materialize its Event"); self.dispatch_lightweight_popup_window_event(scope, popup_id, "load", event); + if !self.lightweight_popup_is_open(popup_id) + || self.current_lightweight_popup_document_owner(popup_id) != document_owner + { + return; + } + let context = window + .get_creation_context(scope) + .unwrap_or_else(|| scope.get_current_context()); + let scope = &mut v8::ContextScope::new(scope, context); + if let Some(event) = construct_original_page_transition_event(scope, "pageshow", false) { + self.dispatch_lightweight_popup_window_event(scope, popup_id, "pageshow", event); + } } fn install_lightweight_popup_document_projection<'s>( @@ -4933,6 +4996,7 @@ fn lightweight_popup_close_callback<'s>( if !host.begin_lightweight_popup_close(popup_id) { return; } + dispatch_beforeunload_for_runtime_owner(scope, window); set_object_slot( scope, window, diff --git a/moli-renderer-v8/src/native_bridge/history_queue.rs b/moli-renderer-v8/src/native_bridge/history_queue.rs index 6bffa1131c4..032c5ec8e28 100644 --- a/moli-renderer-v8/src/native_bridge/history_queue.rs +++ b/moli-renderer-v8/src/native_bridge/history_queue.rs @@ -62,7 +62,7 @@ pub(crate) struct PendingHistoryTraversal { pub(crate) results: Vec, } -pub(crate) struct PendingChildCrossDocumentTraversal { +pub(crate) struct PendingCrossDocumentTraversal { pub(crate) target: WindowTaskTarget, pub(crate) target_index: u32, pub(crate) target_key: Option, @@ -73,7 +73,7 @@ pub(crate) struct PendingChildCrossDocumentTraversal { pub(crate) enum PendingHistoryTraversalAction { SameDocument(PendingHistoryTraversal), - ChildCrossDocument(Box), + CrossDocument(Box), } pub(crate) struct QueuedHistoryTraversalTask { @@ -117,7 +117,7 @@ impl HistoryQueueState { Some(pending.target_index) } PendingHistoryTraversalAction::SameDocument(_) - | PendingHistoryTraversalAction::ChildCrossDocument(_) => None, + | PendingHistoryTraversalAction::CrossDocument(_) => None, }) } @@ -150,7 +150,7 @@ impl HistoryQueueState { Some(pending) } PendingHistoryTraversalAction::SameDocument(_) - | PendingHistoryTraversalAction::ChildCrossDocument(_) => None, + | PendingHistoryTraversalAction::CrossDocument(_) => None, }) { if let Some(result) = result { @@ -180,11 +180,11 @@ impl HistoryQueueState { Some(task_id) } - fn queue_child_cross_document_traversal( + fn queue_cross_document_history_traversal( &mut self, execution_context: WindowExecutionContextIdentity, relevant_context: WindowExecutionContextBinding, - traversal: PendingChildCrossDocumentTraversal, + traversal: PendingCrossDocumentTraversal, ) -> RendererPageHistoryTraversalTaskId { let task_id = self.next_history_traversal_task_id; self.next_history_traversal_task_id = task_id @@ -195,7 +195,7 @@ impl HistoryQueueState { task_id, execution_context, relevant_context, - action: PendingHistoryTraversalAction::ChildCrossDocument(Box::new(traversal)), + action: PendingHistoryTraversalAction::CrossDocument(Box::new(traversal)), }); task_id } @@ -398,7 +398,7 @@ impl PageScriptHost { .find_map(|queued| { let step = match &queued.action { PendingHistoryTraversalAction::SameDocument(pending) => pending.joint_step, - PendingHistoryTraversalAction::ChildCrossDocument(pending) => { + PendingHistoryTraversalAction::CrossDocument(pending) => { pending.seed.session_history.target_step } }?; @@ -541,7 +541,7 @@ impl PageScriptHost { pending.results.first() } PendingHistoryTraversalAction::SameDocument(_) - | PendingHistoryTraversalAction::ChildCrossDocument(_) => None, + | PendingHistoryTraversalAction::CrossDocument(_) => None, }) { // Repeated requests share the original tracker, including its @@ -591,7 +591,7 @@ impl PageScriptHost { Some((result, producer)) } - pub(crate) fn queue_child_cross_document_traversal<'s>( + pub(crate) fn queue_cross_document_history_traversal<'s>( &mut self, scope: &mut v8::PinScope<'s, '_>, target: WindowTaskTarget, @@ -602,10 +602,10 @@ impl PageScriptHost { let execution_context = self.current_runtime_window_execution_context_identity(scope)?; let relevant_context = self.current_runtime_window_execution_context_binding(scope)?; let sender = self.page_history_traversal_sender(); - let task_id = self.history_queue.queue_child_cross_document_traversal( + let task_id = self.history_queue.queue_cross_document_history_traversal( execution_context, relevant_context, - PendingChildCrossDocumentTraversal { + PendingCrossDocumentTraversal { target, target_index, target_key, @@ -618,12 +618,12 @@ impl PageScriptHost { execution_context, target, task_id, - RendererPageHistoryTraversalTaskKind::ChildCrossDocument, + RendererPageHistoryTraversalTaskKind::CrossDocument, )) } #[allow(clippy::too_many_arguments)] - pub(crate) fn queue_child_cross_document_traversal_with_result<'s>( + pub(crate) fn queue_cross_document_history_traversal_with_result<'s>( &mut self, scope: &mut v8::PinScope<'s, '_>, target: WindowTaskTarget, @@ -644,10 +644,10 @@ impl PageScriptHost { let execution_context = self.current_runtime_window_execution_context_identity(scope)?; let relevant_context = self.current_runtime_window_execution_context_binding(scope)?; let sender = self.page_history_traversal_sender(); - let task_id = self.history_queue.queue_child_cross_document_traversal( + let task_id = self.history_queue.queue_cross_document_history_traversal( execution_context, relevant_context, - PendingChildCrossDocumentTraversal { + PendingCrossDocumentTraversal { target, target_index, target_key, @@ -665,7 +665,7 @@ impl PageScriptHost { execution_context, target, task_id, - RendererPageHistoryTraversalTaskKind::ChildCrossDocument, + RendererPageHistoryTraversalTaskKind::CrossDocument, ), )) } @@ -687,9 +687,9 @@ impl PageScriptHost { pending.target, RendererPageHistoryTraversalTaskKind::SameDocument, ), - PendingHistoryTraversalAction::ChildCrossDocument(pending) => ( + PendingHistoryTraversalAction::CrossDocument(pending) => ( pending.target, - RendererPageHistoryTraversalTaskKind::ChildCrossDocument, + RendererPageHistoryTraversalTaskKind::CrossDocument, ), }; if self.current_window_execution_context_owner(target.dispatch_scope()) @@ -713,9 +713,9 @@ impl PageScriptHost { pending.target, RendererPageHistoryTraversalTaskKind::SameDocument, ), - PendingHistoryTraversalAction::ChildCrossDocument(pending) => ( + PendingHistoryTraversalAction::CrossDocument(pending) => ( pending.target, - RendererPageHistoryTraversalTaskKind::ChildCrossDocument, + RendererPageHistoryTraversalTaskKind::CrossDocument, ), }; if queued.execution_context != execution_context diff --git a/moli-renderer-v8/src/native_bridge/mod.rs b/moli-renderer-v8/src/native_bridge/mod.rs index f64cd191ce7..db24f0ce614 100644 --- a/moli-renderer-v8/src/native_bridge/mod.rs +++ b/moli-renderer-v8/src/native_bridge/mod.rs @@ -40,8 +40,9 @@ use super::{ use bindings::NativeBridgeBindings; pub(crate) use history_queue::{ - NavigationAttemptId, PendingHistoryTraversal, PendingHistoryTraversalAction, - PendingNavigationApiTaskAction, PendingNavigationFinishedResult, PendingNavigationResult, + NavigationAttemptId, PendingCrossDocumentTraversal, PendingHistoryTraversal, + PendingHistoryTraversalAction, PendingNavigationApiTaskAction, PendingNavigationFinishedResult, + PendingNavigationResult, }; use identity::{BridgeHandle, BridgeIdentityStore, DomTokenListKind, ReflectorId}; use identity::{CollectionKind, LiveCollectionDescriptor, LiveCollectionQueryKind}; diff --git a/moli-renderer-v8/src/page_task_queue/history_traversal.rs b/moli-renderer-v8/src/page_task_queue/history_traversal.rs index 5a2ed4fd2f5..eca70d3484a 100644 --- a/moli-renderer-v8/src/page_task_queue/history_traversal.rs +++ b/moli-renderer-v8/src/page_task_queue/history_traversal.rs @@ -40,7 +40,7 @@ impl RendererPageHistoryTraversalTaskId { #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub(crate) enum RendererPageHistoryTraversalTaskKind { SameDocument, - ChildCrossDocument, + CrossDocument, } /// Exact authority captured when a history traversal becomes pending. diff --git a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs index f0655abbf47..82d14ed934e 100644 --- a/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs +++ b/moli-renderer-v8/src/page_task_queue/owner_sources/conformance_tests.rs @@ -1072,7 +1072,7 @@ impl HistoryTraversalLane { sequence: u64, ) -> bool { let kind = if sequence.is_multiple_of(2) { - RendererPageHistoryTraversalTaskKind::ChildCrossDocument + RendererPageHistoryTraversalTaskKind::CrossDocument } else { RendererPageHistoryTraversalTaskKind::SameDocument }; @@ -1911,7 +1911,7 @@ fn navigation_and_traversal_source_preserves_cross_kind_fifo_and_one_readiness_e execution_context, target, RendererPageHistoryTraversalTaskId::from_raw(3), - RendererPageHistoryTraversalTaskKind::ChildCrossDocument, + RendererPageHistoryTraversalTaskKind::CrossDocument, ) .send() .expect("second traversal should enqueue third"); diff --git a/moli-renderer-v8/src/script_vm/popup_close.rs b/moli-renderer-v8/src/script_vm/popup_close.rs index 351b566a4a7..1b5cdb317da 100644 --- a/moli-renderer-v8/src/script_vm/popup_close.rs +++ b/moli-renderer-v8/src/script_vm/popup_close.rs @@ -46,6 +46,8 @@ impl ScriptVm { binding.with_current_scope(scope, host_ptr, |scope, _| { let window = v8::Local::new(scope, &window); inform_about_canceled_navigation_for_window(scope, window); + unsafe { &mut *host_ptr } + .dispatch_lightweight_popup_document_unload(scope, popup_id); }); } assert!(