Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(renderer): preserve pending iframe navigation on reload

ldm0bdee83803bf6
diff --git a/moli-renderer-v8/src/context_bootstrap.rs b/moli-renderer-v8/src/context_bootstrap.rs
index d09cd375c..78e31ca25 100644
--- a/moli-renderer-v8/src/context_bootstrap.rs
+++ b/moli-renderer-v8/src/context_bootstrap.rs
@@ -55,6 +55,7 @@ mod navigation_history_pruning;
mod navigation_lifecycle;
mod navigation_mutation;
mod navigation_projection;
+mod navigation_reload;
mod navigation_restore;
mod navigation_result;
mod navigation_seed;
diff --git a/moli-renderer-v8/src/context_bootstrap/location_navigation.rs b/moli-renderer-v8/src/context_bootstrap/location_navigation.rs
index 5457c70cf..2cb92c0e0 100644
--- a/moli-renderer-v8/src/context_bootstrap/location_navigation.rs
+++ b/moli-renderer-v8/src/context_bootstrap/location_navigation.rs
@@ -26,6 +26,7 @@ use super::navigation_mutation::{
apply_local_window_location_navigation, apply_navigation_navigate_same_document,
sync_local_document_front_from_window, update_navigation_current_entry_for_same_document,
};
+use super::navigation_reload::{NavigationReloadAdmission, navigation_reload_admission};
use super::navigation_result::{
cancel_pending_same_document_navigation_finishes,
cancel_pending_same_document_navigation_finishes_including_reentrant, navigation_dom_exception,
@@ -262,6 +263,14 @@ fn navigate_location_object_with_source_element_and_child_navigate_event<'s>(
);
return;
}
+ if matches!(kind, LocationNavigationKind::Reload)
+ && matches!(
+ navigation_reload_admission(scope, owner),
+ NavigationReloadAdmission::NoCommittedHistoryItem
+ )
+ {
+ return;
+ }
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 }.navigate_lightweight_popup_window_to_url(
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_reload.rs b/moli-renderer-v8/src/context_bootstrap/navigation_reload.rs
new file mode 100644
index 000000000..340d6190f
--- /dev/null
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_reload.rs
@@ -0,0 +1,31 @@
+use super::navigation_window::child_browsing_context_handle_for_runtime_owner;
+use super::*;
+
+/// Whether the current Document owns a committed session-history item that
+/// can be used as the source of a reload.
+///
+/// An initial-empty child Document is installed synchronously before its first
+/// real navigation and deliberately has no committed history item. Reloading
+/// it must therefore leave any deferred iframe attribute navigation alone.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(super) enum NavigationReloadAdmission {
+ NoCommittedHistoryItem,
+ Admitted,
+}
+
+pub(super) fn navigation_reload_admission<'s>(
+ scope: &mut v8::PinScope<'s, '_>,
+ owner: v8::Local<'s, v8::Object>,
+) -> NavigationReloadAdmission {
+ let Some(handle) = child_browsing_context_handle_for_runtime_owner(scope, owner) else {
+ return NavigationReloadAdmission::Admitted;
+ };
+ let Some(host_ptr) = context_host_ptr_from_global_bridge(scope) else {
+ return NavigationReloadAdmission::Admitted;
+ };
+ if unsafe { &*host_ptr }.child_current_document_is_initial_empty(handle) {
+ NavigationReloadAdmission::NoCommittedHistoryItem
+ } else {
+ NavigationReloadAdmission::Admitted
+ }
+}
diff --git a/moli-renderer-v8/src/context_bootstrap/navigation_traversal.rs b/moli-renderer-v8/src/context_bootstrap/navigation_traversal.rs
index 27130626d..49e433396 100644
--- a/moli-renderer-v8/src/context_bootstrap/navigation_traversal.rs
+++ b/moli-renderer-v8/src/context_bootstrap/navigation_traversal.rs
@@ -24,6 +24,7 @@ use super::navigation_events::{
};
use super::navigation_lifecycle::finish_navigation_error_events;
use super::navigation_projection::visible_navigation_entries_len;
+use super::navigation_reload::{NavigationReloadAdmission, navigation_reload_admission};
use super::navigation_result::{
navigation_current_entry_result_with_pending_finished, navigation_dom_exception,
navigation_immediate_current_entry_result, navigation_pending_result,
@@ -218,6 +219,11 @@ pub(super) fn navigation_reload_callback<'s>(
return;
};
let options = args.get(0).to_object(scope);
+ let navigation_info = options.and_then(|options| {
+ options
+ .get(scope, v8str(scope, "info").into())
+ .filter(|value| !value.is_undefined())
+ });
let cloned_navigation_state = match clone_navigation_state_arg_for_result(scope, options) {
Ok(state) => state,
Err(error) => {
@@ -245,11 +251,15 @@ pub(super) fn navigation_reload_callback<'s>(
);
return;
}
- let navigation_info = options.and_then(|options| {
- options
- .get(scope, v8str(scope, "info").into())
- .filter(|value| !value.is_undefined())
- });
+ if matches!(
+ navigation_reload_admission(scope, owner),
+ NavigationReloadAdmission::NoCommittedHistoryItem
+ ) {
+ // Navigation API methods on an initial-empty Document return a
+ // correctly-shaped result whose promises intentionally never settle.
+ rv.set(navigation_pending_result(scope).into());
+ return;
+ }
if navigation_document_can_update_current_entry(scope, owner)
&& let Some(navigation) = window_navigation_for_holder(scope, owner)
{
diff --git a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs
index c20464ad6..ca2be6d8e 100644
--- a/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs
+++ b/moli-renderer-v8/src/script_vm/tests/dom_elements/dom_surface.rs
@@ -12900,6 +12900,252 @@ globalThis.__probeOneSidedDomainFrame = () => {
assert_eq!(server.finish_targets().await, vec!["/child.html"]);
}
+#[test]
+fn initial_empty_iframe_reload_uses_shared_no_history_admission() {
+ let mut vm = new_storage_test_vm("https://initial-empty-reload.test/page.html");
+
+ let setup = vm
+ .eval(
+ r#"
+(() => {
+ const frame = document.createElement('iframe');
+ (document.body || document.documentElement || document).appendChild(frame);
+ const child = frame.contentWindow;
+ const log = [];
+ const optionReads = [];
+ child.navigation.onnavigate = () => log.push('navigate');
+ child.navigation.onnavigatesuccess = () => log.push('navigatesuccess');
+ child.navigation.onnavigateerror = () => log.push('navigateerror');
+
+ const options = {};
+ Object.defineProperties(options, {
+ info: {
+ get() {
+ optionReads.push('info');
+ return 'initial-empty';
+ }
+ },
+ state: {
+ get() {
+ optionReads.push('state');
+ return { initialEmpty: true };
+ }
+ }
+ });
+ const result = child.navigation.reload(options);
+ result.committed.then(
+ () => log.push('committed:fulfilled'),
+ () => log.push('committed:rejected')
+ );
+ result.finished.then(
+ () => log.push('finished:fulfilled'),
+ () => log.push('finished:rejected')
+ );
+ child.location.reload();
+ child.history.go(0);
+ Promise.resolve().then(() => log.push('checkpoint'));
+ globalThis.__initialEmptyReloadFrame = frame;
+ globalThis.__initialEmptyReloadLog = log;
+
+ return JSON.stringify({
+ href: child.location.href,
+ resultRealm: Object.getPrototypeOf(result) === child.Object.prototype,
+ keys: Reflect.ownKeys(result),
+ committedPromise: result.committed instanceof child.Promise,
+ finishedPromise: result.finished instanceof child.Promise,
+ distinctPromises: result.committed !== result.finished,
+ optionReads,
+ log
+ });
+})()
+"#,
+ )
+ .expect("initial-empty reload setup should evaluate");
+
+ assert_eq!(
+ setup,
+ r#"{"href":"about:blank","resultRealm":true,"keys":["committed","finished"],"committedPromise":true,"finishedPromise":true,"distinctPromises":true,"optionReads":["info","state"],"log":[]}"#
+ );
+ assert_eq!(
+ vm.eval("globalThis.__initialEmptyReloadLog.join('|')")
+ .expect("initial-empty reload microtask log should evaluate"),
+ "checkpoint"
+ );
+ assert_eq!(
+ vm.eval("globalThis.__initialEmptyReloadFrame.contentWindow.location.href")
+ .expect("initial-empty reload location should evaluate"),
+ "about:blank"
+ );
+}
+
+#[test]
+fn non_initial_about_blank_iframe_remains_reloadable() {
+ let mut vm = new_storage_test_vm("https://non-initial-blank-reload.test/page.html");
+
+ vm.exec(
+ r#"
+const frame = document.createElement('iframe');
+frame.srcdoc = '<p>first committed document</p>';
+(document.body || document.documentElement || document).appendChild(frame);
+globalThis.__nonInitialBlankReloadFrame = frame;
+"#,
+ None,
+ )
+ .expect("committed child setup should evaluate");
+ vm.drain_pending_child_frame_work_for_test();
+
+ vm.exec(
+ r#"
+__nonInitialBlankReloadFrame.src = 'about:blank';
+"#,
+ None,
+ )
+ .expect("non-initial about:blank navigation should evaluate");
+ vm.drain_pending_child_frame_work_for_test();
+ assert_eq!(
+ vm.eval("__nonInitialBlankReloadFrame.contentWindow.location.href")
+ .expect("non-initial about:blank location should evaluate"),
+ "about:blank"
+ );
+
+ vm.exec(
+ r#"
+globalThis.__nonInitialBlankReloadLoads = 0;
+__nonInitialBlankReloadFrame.onload = () => {
+ globalThis.__nonInitialBlankReloadLoads += 1;
+};
+globalThis.__nonInitialBlankNavigationResult =
+ __nonInitialBlankReloadFrame.contentWindow.navigation.reload();
+"#,
+ None,
+ )
+ .expect("non-initial about:blank reload should evaluate");
+ assert!(
+ vm.has_pending_child_navigation_commit_for_test(),
+ "a committed about:blank Document must be admitted to the reload pipeline"
+ );
+
+ vm.drain_pending_child_frame_work_for_test();
+ assert_eq!(
+ vm.eval(
+ r#"[
+ __nonInitialBlankReloadFrame.contentWindow.location.href,
+ __nonInitialBlankReloadLoads
+].join('|')"#,
+ )
+ .expect("non-initial about:blank reload result should evaluate"),
+ "about:blank|1"
+ );
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn initial_empty_lazy_iframe_reload_preserves_pending_attribute_navigation() {
+ const PARENT_HOST: &str = "lazy-iframe-reload.test";
+
+ let server = StaticHttpServer::spawn(3).await;
+ let parent_url = server.url_for_host(PARENT_HOST, "/page.html");
+ let location_url = server.url_for_host(PARENT_HOST, "/location-child.html");
+ let navigation_url = server.url_for_host(PARENT_HOST, "/navigation-child.html");
+ let history_url = server.url_for_host(PARENT_HOST, "/history-child.html");
+ let loader = static_http_loader([server.resolve_entry(PARENT_HOST)]);
+ let mut vm = new_storage_page_task_executor_test_vm_with_loader(parent_url.as_str(), &loader);
+
+ vm.exec(
+ r#"
+globalThis.__lazyReloadLoads = { location: 0, navigation: 0, history: 0 };
+globalThis.__lazyNavigationReloadSettled = 'pending';
+globalThis.__lazyNavigationReloadOptionReads = [];
+
+const locationFrame = document.createElement('iframe');
+locationFrame.loading = 'lazy';
+locationFrame.hidden = true;
+locationFrame.src = '/location-child.html';
+locationFrame.onload = () => { globalThis.__lazyReloadLoads.location += 1; };
+(document.body || document.documentElement || document).appendChild(locationFrame);
+locationFrame.contentWindow.location.reload();
+locationFrame.hidden = false;
+globalThis.__lazyLocationReloadFrame = locationFrame;
+
+const navigationFrame = document.createElement('iframe');
+navigationFrame.loading = 'lazy';
+navigationFrame.hidden = true;
+navigationFrame.src = '/navigation-child.html';
+navigationFrame.onload = () => { globalThis.__lazyReloadLoads.navigation += 1; };
+(document.body || document.documentElement || document).appendChild(navigationFrame);
+const reloadOptions = {};
+Object.defineProperties(reloadOptions, {
+ state: {
+ get() {
+ globalThis.__lazyNavigationReloadOptionReads.push('state');
+ return { retained: true };
+ }
+ },
+ info: {
+ get() {
+ globalThis.__lazyNavigationReloadOptionReads.push('info');
+ return 'retained';
+ }
+ }
+});
+const reloadResult = navigationFrame.contentWindow.navigation.reload(reloadOptions);
+Promise.all([reloadResult.committed, reloadResult.finished]).then(
+ () => { globalThis.__lazyNavigationReloadSettled = 'fulfilled'; },
+ () => { globalThis.__lazyNavigationReloadSettled = 'rejected'; }
+);
+navigationFrame.hidden = false;
+globalThis.__lazyNavigationReloadFrame = navigationFrame;
+
+const historyFrame = document.createElement('iframe');
+historyFrame.loading = 'lazy';
+historyFrame.hidden = true;
+historyFrame.src = '/history-child.html';
+historyFrame.onload = () => { globalThis.__lazyReloadLoads.history += 1; };
+(document.body || document.documentElement || document).appendChild(historyFrame);
+historyFrame.contentWindow.history.go(0);
+historyFrame.hidden = false;
+globalThis.__lazyHistoryReloadFrame = historyFrame;
+"#,
+ None,
+ )
+ .expect("lazy iframe reload setup should evaluate");
+
+ advance_page_task_executor_until_eval_equals(
+ &mut vm,
+ &loader,
+ "String(__lazyReloadLoads.location === 1 && __lazyReloadLoads.navigation === 1 && __lazyReloadLoads.history === 1)",
+ "true",
+ "all reload entry points should preserve the pending attribute navigation",
+ )
+ .await;
+
+ assert_eq!(
+ vm.eval(
+ r#"[
+ __lazyLocationReloadFrame.contentWindow.location.href,
+ __lazyNavigationReloadFrame.contentWindow.location.href,
+ __lazyHistoryReloadFrame.contentWindow.location.href,
+ __lazyReloadLoads.location,
+ __lazyReloadLoads.navigation,
+ __lazyReloadLoads.history,
+ __lazyNavigationReloadSettled,
+ __lazyNavigationReloadOptionReads.join(',')
+].join('|')"#,
+ )
+ .expect("lazy iframe reload result should evaluate"),
+ format!("{location_url}|{navigation_url}|{history_url}|1|1|1|pending|info,state")
+ );
+ let mut request_targets = server.finish_targets().await;
+ request_targets.sort();
+ assert_eq!(
+ request_targets,
+ vec![
+ "/history-child.html",
+ "/location-child.html",
+ "/navigation-child.html"
+ ]
+ );
+}
+
#[tokio::test(flavor = "current_thread")]
async fn lazy_iframe_location_replace_cancels_pending_attribute_navigation() {
const PARENT_HOST: &str = "lazy-iframe-replace.test";