Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust
Rust ai-agentsai-toolsbrowserbrowser-automationcloud-browserheadlessheadless-browserkitesurfplaywrightpuppeteerrustservoweb-crawlerweb-crawlingweb-scraperweb-scraping
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.rsindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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";