Skip to content

armgit / moli

Public Imported from GitHub
0

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

refactor(protocol): type renderer owner turn outcomes

ldm0ca64a8a1a30e
diff --git a/moli-protocol/src/conn.rs b/moli-protocol/src/conn.rs
index 338aa358a..464b0c233 100644
--- a/moli-protocol/src/conn.rs
+++ b/moli-protocol/src/conn.rs
@@ -512,7 +512,7 @@ pub(crate) use runtime_load::{
};
use scheduler_hooks::CdpSchedulerHooks;
use scheduler_state::CdpConnectionSchedulerState;
-pub use scheduler_state::{CdpSchedulerEvent, CdpTurnOutcome};
+pub use scheduler_state::{CdpRendererOwnerTurnOutcome, CdpSchedulerEvent, CdpTurnOutcome};
#[cfg(test)]
pub(crate) use site_data_manager_surface::{
BrowserContextReservedSiteDataOwnerState, BrowserContextSiteDataManagerOwnerState,
@@ -2248,7 +2248,7 @@ impl CdpConnection {
pub async fn drain_background_navigation_completion_turn_async(
&mut self,
completion: crate::domains::page::BackgroundNavigationCompletion,
- ) -> CdpTurnOutcome {
+ ) -> CdpRendererOwnerTurnOutcome {
let mut command_context = CommandDispatchContext::default();
let protocol_events = self
.drain_background_navigation_completion_events_with_context(
diff --git a/moli-protocol/src/conn/browser_context/runtime_owner.rs b/moli-protocol/src/conn/browser_context/runtime_owner.rs
index d29878bc4..918aa92b9 100644
--- a/moli-protocol/src/conn/browser_context/runtime_owner.rs
+++ b/moli-protocol/src/conn/browser_context/runtime_owner.rs
@@ -1,6 +1,6 @@
use super::target_session_owner::{TargetSessionOwnerMut, TargetSessionStateMut};
use super::*;
-use crate::CdpTurnOutcome;
+use crate::CdpRendererOwnerTurnOutcome;
use moli_core::page::V8InspectorSessionState;
use serde_json::json;
@@ -158,7 +158,7 @@ impl CdpConnection {
pub async fn enable_runtime_listener_for_target(
&mut self,
target_id: &str,
- ) -> Option<CdpTurnOutcome> {
+ ) -> Option<CdpRendererOwnerTurnOutcome> {
let route = self.target_session_route_for_target_id(target_id)?;
if matches!(route, CdpSessionRoute::ServiceWorkerTarget { .. }) {
let session_id =
@@ -216,7 +216,7 @@ impl CdpConnection {
pub async fn disable_runtime_listener_for_target(
&mut self,
target_id: &str,
- ) -> Option<CdpTurnOutcome> {
+ ) -> Option<CdpRendererOwnerTurnOutcome> {
let route = self.target_session_route_for_target_id(target_id)?;
if matches!(route, CdpSessionRoute::ServiceWorkerTarget { .. }) {
let session_id = self.service_worker_runtime_listener_session_for_route(&route)?;
diff --git a/moli-protocol/src/conn/dispatch.rs b/moli-protocol/src/conn/dispatch.rs
index e9d4ddeed..28e1aa45c 100644
--- a/moli-protocol/src/conn/dispatch.rs
+++ b/moli-protocol/src/conn/dispatch.rs
@@ -19,7 +19,7 @@ pub struct CompletedCdpCommandDispatch {
pub enum CdpCommandTaskStep {
Pending(Box<PendingCdpCommandDispatch>),
- Complete(CdpTurnOutcome),
+ Complete(CdpRendererOwnerTurnOutcome),
}
impl CdpCommandTaskStep {
@@ -1295,7 +1295,10 @@ impl CdpConnection {
)
}
- pub async fn process_message_with_turn_outcome_async(&mut self, raw: &str) -> CdpTurnOutcome {
+ pub async fn process_message_with_turn_outcome_async(
+ &mut self,
+ raw: &str,
+ ) -> CdpRendererOwnerTurnOutcome {
let outcome = self
.process_message_through_command_dispatch_async(raw)
.await;
@@ -1306,7 +1309,7 @@ impl CdpConnection {
post_response_events,
mut scheduler_events,
renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
scheduler_events.extend(self.take_scheduler_events());
CdpTurnOutcome::new_with_protocol_and_post_response_events(
protocol_events,
@@ -1335,7 +1338,7 @@ impl CdpConnection {
async fn process_message_through_command_dispatch_async(
&mut self,
raw: &str,
- ) -> CdpTurnOutcome {
+ ) -> CdpRendererOwnerTurnOutcome {
let command = ParsedCdpCommand::parse_str(raw.to_owned());
let output_session_id = command
.as_ref()
@@ -1372,7 +1375,7 @@ impl CdpConnection {
mut complete_post_response_events,
mut complete_events,
complete_renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
assert!(
renderer_output_boundary.is_none(),
"one direct command cannot complete multiple renderer insertion boundaries"
diff --git a/moli-protocol/src/conn/dispatch_tests.rs b/moli-protocol/src/conn/dispatch_tests.rs
index 690d2fc5a..554fc4d76 100644
--- a/moli-protocol/src/conn/dispatch_tests.rs
+++ b/moli-protocol/src/conn/dispatch_tests.rs
@@ -7320,16 +7320,18 @@ fn command_dispatch_completes_dom_sync_and_error_commands_without_legacy_fallbac
#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_page_preload_without_legacy_fallback() {
- let mut conn = CdpConnection::new();
+ let mut ctx = crate::testing::TestContext::new();
let mut browser_context = BrowserContext::new("BID-page-preload-live".to_owned());
browser_context.set_active_target_id("TID-page-preload-live".to_owned());
browser_context.attach_active_session("SID-page-preload-live");
- conn.browser_context = Some(browser_context);
- let page = conn
+ ctx.conn.browser_context = Some(browser_context);
+ let page = ctx
+ .conn
.load_page_via_runtime_async("data:text/html,<p>preload</p>")
.await
.expect("page should load");
- conn.browser_context
+ ctx.conn
+ .browser_context
.as_mut()
.expect("browser context")
.active_target
@@ -7346,16 +7348,17 @@ async fn command_dispatch_completes_live_page_preload_without_legacy_fallback()
}
}))
.unwrap();
- let add_pending = match conn.start_command_dispatch(&add_raw) {
+ let add_pending = match ctx.conn.start_command_dispatch(&add_raw) {
CdpCommandTaskStep::Pending(pending) => pending,
CdpCommandTaskStep::Complete(_) => {
panic!("live Page.addScriptToEvaluateOnNewDocument should update the live page")
}
};
- let add_step = conn
+ let add_step = ctx
+ .conn
.complete_pending_command_dispatch(add_pending.wait().await)
.await;
- let add_messages = complete_messages(add_step);
+ let (add_messages, _) = ctx.complete_command_task_step_for_test(add_step).await;
assert_eq!(add_messages.len(), 1);
assert_eq!(add_messages[0]["id"], json!(42));
assert_eq!(add_messages[0]["sessionId"], json!("SID-page-preload-live"));
@@ -7364,7 +7367,8 @@ async fn command_dispatch_completes_live_page_preload_without_legacy_fallback()
.expect("preload identifier")
.to_owned();
assert!(
- conn.browser_context
+ ctx.conn
+ .browser_context
.as_ref()
.expect("browser context")
.active_target
@@ -7386,17 +7390,19 @@ async fn command_dispatch_completes_live_page_preload_without_legacy_fallback()
"params": { "identifier": identifier }
}))
.unwrap();
- let remove_pending = match conn.start_command_dispatch(&remove_raw) {
+ let remove_pending = match ctx.conn.start_command_dispatch(&remove_raw) {
CdpCommandTaskStep::Pending(pending) => pending,
CdpCommandTaskStep::Complete(_) => {
panic!("live Page.removeScriptToEvaluateOnNewDocument should update the live page")
}
};
- let remove_step = conn
+ let remove_step = ctx
+ .conn
.complete_pending_command_dispatch(remove_pending.wait().await)
.await;
+ let (remove_messages, _) = ctx.complete_command_task_step_for_test(remove_step).await;
assert_eq!(
- complete_messages(remove_step),
+ remove_messages,
vec![json!({
"id": 43,
"sessionId": "SID-page-preload-live",
@@ -7404,7 +7410,8 @@ async fn command_dispatch_completes_live_page_preload_without_legacy_fallback()
})]
);
assert!(
- conn.browser_context
+ ctx.conn
+ .browser_context
.as_ref()
.expect("browser context")
.active_target
@@ -7424,14 +7431,15 @@ async fn command_dispatch_completes_live_page_preload_without_legacy_fallback()
}
}))
.unwrap();
- let create_world_pending = match conn.start_command_dispatch(&create_world_raw) {
+ let create_world_pending = match ctx.conn.start_command_dispatch(&create_world_raw) {
CdpCommandTaskStep::Pending(pending) => pending,
CdpCommandTaskStep::Complete(_) => {
panic!("live Page.createIsolatedWorld should use explicit pending page dispatch")
}
};
- let create_world_messages =
- complete_command_task_for_test(&mut conn, *create_world_pending).await;
+ let (create_world_messages, _) = ctx
+ .complete_command_task_step_for_test(CdpCommandTaskStep::Pending(create_world_pending))
+ .await;
assert_eq!(create_world_messages.len(), 1);
assert_eq!(create_world_messages[0]["id"], json!(44));
assert_eq!(
@@ -8416,15 +8424,17 @@ async fn pending_security_tls_keeps_background_owner_route_across_completion() {
#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_fetch_enable_without_legacy_fallback() {
- let mut conn = CdpConnection::new();
+ let mut ctx = crate::testing::TestContext::new();
let mut browser_context = BrowserContext::new("BID-fetch-live".to_owned());
browser_context.set_active_target_id("TID-fetch-live".to_owned());
- conn.browser_context = Some(browser_context);
- let page = conn
+ ctx.conn.browser_context = Some(browser_context);
+ let page = ctx
+ .conn
.load_page_via_runtime_async("data:text/html,<p>fetch</p>")
.await
.expect("page should load");
- conn.browser_context
+ ctx.conn
+ .browser_context
.as_mut()
.expect("browser context")
.active_target
@@ -8439,18 +8449,16 @@ async fn command_dispatch_completes_live_fetch_enable_without_legacy_fallback()
}
}))
.unwrap();
- let pending = match conn.start_command_dispatch(&raw) {
+ let pending = match ctx.conn.start_command_dispatch(&raw) {
CdpCommandTaskStep::Pending(pending) => pending,
CdpCommandTaskStep::Complete(_) => {
panic!("live Fetch.enable should update live page interception state")
}
};
let completed = pending.wait().await;
- let step = conn.complete_pending_command_dispatch(completed).await;
- assert_eq!(
- complete_messages(step),
- vec![json!({ "id": 69, "result": {} })]
- );
+ let step = ctx.conn.complete_pending_command_dispatch(completed).await;
+ let (messages, _) = ctx.complete_command_task_step_for_test(step).await;
+ assert_eq!(messages, vec![json!({ "id": 69, "result": {} })]);
}
#[tokio::test]
@@ -8651,19 +8659,21 @@ async fn devtools_network_intercept_commands_route_to_fetch_owner() {
#[tokio::test(flavor = "multi_thread")]
async fn command_dispatch_completes_live_fetch_disable_without_legacy_fallback() {
- let mut conn = CdpConnection::new();
+ let mut ctx = crate::testing::TestContext::new();
let mut browser_context = BrowserContext::new("BID-fetch-disable-live".to_owned());
browser_context.set_active_target_id("TID-fetch-disable-live".to_owned());
browser_context
.active_target
.fetch_owner
.configure(None, true, Vec::new());
- conn.browser_context = Some(browser_context);
- let page = conn
+ ctx.conn.browser_context = Some(browser_context);
+ let page = ctx
+ .conn
.load_page_via_runtime_async("data:text/html,<p>fetch disable</p>")
.await
.expect("page should load");
- conn.browser_context
+ ctx.conn
+ .browser_context
.as_mut()
.expect("browser context")
.active_target
@@ -8675,20 +8685,18 @@ async fn command_dispatch_completes_live_fetch_disable_without_legacy_fallback()
"method": "Fetch.disable"
}))
.unwrap();
- let pending = match conn.start_command_dispatch(&raw) {
+ let pending = match ctx.conn.start_command_dispatch(&raw) {
CdpCommandTaskStep::Pending(pending) => pending,
CdpCommandTaskStep::Complete(_) => {
panic!("live Fetch.disable should clear live page interception state")
}
};
let completed = pending.wait().await;
- let step = conn.complete_pending_command_dispatch(completed).await;
- assert_eq!(
- complete_messages(step),
- vec![json!({ "id": 6901, "result": {} })]
- );
+ let step = ctx.conn.complete_pending_command_dispatch(completed).await;
+ let (messages, _) = ctx.complete_command_task_step_for_test(step).await;
+ assert_eq!(messages, vec![json!({ "id": 6901, "result": {} })]);
assert!(
- !conn
+ !ctx.conn
.browser_context
.as_ref()
.expect("browser context should remain loaded")
diff --git a/moli-protocol/src/conn/scheduler_state.rs b/moli-protocol/src/conn/scheduler_state.rs
index e13d0ef93..6c05d6cdc 100644
--- a/moli-protocol/src/conn/scheduler_state.rs
+++ b/moli-protocol/src/conn/scheduler_state.rs
@@ -24,6 +24,18 @@ pub struct CdpTurnOutcome {
renderer_output_boundary: Option<moli_core::RendererOutputFence>,
post_response_events: Vec<BackgroundProtocolEvent>,
scheduler_events: Vec<CdpSchedulerEvent>,
+}
+
+/// One renderer-owner turn whose exact publication predecessor must be
+/// projected before its protocol result becomes observable.
+///
+/// This wrapper is intentionally a different type from [`CdpTurnOutcome`]. A
+/// scheduler hook cannot pass it to a protocol-only turn consumer and rely on
+/// a runtime assertion to catch the lost predecessor.
+#[must_use = "renderer owner turns must project or explicitly consume their predecessor"]
+#[derive(Debug)]
+pub struct CdpRendererOwnerTurnOutcome {
+ turn: CdpTurnOutcome,
renderer_output_predecessor: Option<moli_core::RendererOutputFence>,
}
@@ -64,7 +76,6 @@ impl CdpTurnOutcome {
renderer_output_boundary: None,
post_response_events,
scheduler_events,
- renderer_output_predecessor: None,
}
}
@@ -104,13 +115,13 @@ impl CdpTurnOutcome {
/// contributions in that stream collapse to its latest cursor; combining
/// unrelated streams is an ownership error rather than a frontier.
pub(crate) fn with_renderer_output_predecessor(
- mut self,
+ self,
predecessor: Option<moli_core::RendererOutputFence>,
- ) -> Self {
- if let Some(predecessor) = predecessor {
- predecessor.merge_into_same_stream_tail(&mut self.renderer_output_predecessor);
+ ) -> CdpRendererOwnerTurnOutcome {
+ CdpRendererOwnerTurnOutcome {
+ turn: self,
+ renderer_output_predecessor: predecessor,
}
- self
}
#[cfg(test)]
@@ -133,11 +144,7 @@ impl CdpTurnOutcome {
pub fn into_protocol_event_parts(
self,
- ) -> (
- Vec<BackgroundProtocolEvent>,
- Vec<CdpSchedulerEvent>,
- Option<moli_core::RendererOutputFence>,
- ) {
+ ) -> (Vec<BackgroundProtocolEvent>, Vec<CdpSchedulerEvent>) {
let mut protocol_events = self.protocol_events;
assert!(
self.renderer_output_boundary.is_none(),
@@ -145,11 +152,7 @@ impl CdpTurnOutcome {
);
protocol_events.extend(self.post_renderer_output_events);
protocol_events.extend(self.post_response_events);
- (
- protocol_events,
- self.scheduler_events,
- self.renderer_output_predecessor,
- )
+ (protocol_events, self.scheduler_events)
}
pub fn into_command_turn_parts(
@@ -160,7 +163,6 @@ impl CdpTurnOutcome {
Option<moli_core::RendererOutputFence>,
Vec<BackgroundProtocolEvent>,
Vec<CdpSchedulerEvent>,
- Option<moli_core::RendererOutputFence>,
) {
(
self.protocol_events,
@@ -168,6 +170,58 @@ impl CdpTurnOutcome {
self.renderer_output_boundary,
self.post_response_events,
self.scheduler_events,
+ )
+ }
+}
+
+impl CdpRendererOwnerTurnOutcome {
+ #[cfg(test)]
+ pub fn into_parts(self) -> (Vec<serde_json::Value>, Vec<CdpSchedulerEvent>) {
+ assert!(
+ self.renderer_output_predecessor.is_none(),
+ "tests must project an exact renderer predecessor instead of flattening it"
+ );
+ self.turn.into_parts()
+ }
+
+ pub fn into_protocol_event_parts(
+ self,
+ ) -> (
+ Vec<BackgroundProtocolEvent>,
+ Vec<CdpSchedulerEvent>,
+ Option<moli_core::RendererOutputFence>,
+ ) {
+ let (protocol_events, scheduler_events) = self.turn.into_protocol_event_parts();
+ (
+ protocol_events,
+ scheduler_events,
+ self.renderer_output_predecessor,
+ )
+ }
+
+ pub fn into_renderer_owner_turn_parts(
+ self,
+ ) -> (
+ Vec<BackgroundProtocolEvent>,
+ Vec<BackgroundProtocolEvent>,
+ Option<moli_core::RendererOutputFence>,
+ Vec<BackgroundProtocolEvent>,
+ Vec<CdpSchedulerEvent>,
+ Option<moli_core::RendererOutputFence>,
+ ) {
+ let (
+ protocol_events,
+ post_renderer_output_events,
+ renderer_output_boundary,
+ post_response_events,
+ scheduler_events,
+ ) = self.turn.into_command_turn_parts();
+ (
+ protocol_events,
+ post_renderer_output_events,
+ renderer_output_boundary,
+ post_response_events,
+ scheduler_events,
self.renderer_output_predecessor,
)
}
@@ -193,10 +247,8 @@ mod tests {
Vec::new(),
);
- let (events, scheduler_events, renderer_output_predecessor) =
- outcome.into_protocol_event_parts();
+ let (events, scheduler_events) = outcome.into_protocol_event_parts();
assert!(scheduler_events.is_empty());
- assert!(renderer_output_predecessor.is_none());
let [(message, automation_event)] = events
.into_iter()
.map(BackgroundProtocolEvent::into_parts)
diff --git a/moli-protocol/src/conn/tests/resource_runtime.rs b/moli-protocol/src/conn/tests/resource_runtime.rs
index 0e2060aea..89ced9a8d 100644
--- a/moli-protocol/src/conn/tests/resource_runtime.rs
+++ b/moli-protocol/src/conn/tests/resource_runtime.rs
@@ -1330,20 +1330,8 @@ async fn direct_network_enable_routes_to_inactive_active_owner_without_promoting
#[tokio::test]
async fn direct_runtime_evaluate_routes_to_inactive_active_owner_without_promoting_slot() {
- let mut conn = CdpConnection::new();
+ let mut ctx = crate::testing::TestContext::new();
- let mut page = conn
- .load_page_via_runtime_async(
- "data:text/html,<!doctype html><title>runtime-direct-owner</title>",
- )
- .await
- .expect("test page should load");
- let _ = page
- .dispatch_runtime_protocol_message_async(
- &json!({"id": 9001, "method": "Runtime.enable", "params": {}}).to_string(),
- )
- .await
- .expect("Runtime.enable should create the owner inspector context");
let mut inactive = BrowserContext::new("BID-B".into());
inactive.set_active_target_id("TID-B".to_owned());
inactive.attach_active_session("SID-B");
@@ -1351,23 +1339,35 @@ async fn direct_runtime_evaluate_routes_to_inactive_active_owner_without_promoti
.devtools_session_state
.runtime_session_state
.runtime_frontend_enabled = true;
- inactive.replace_loaded_page(Some(page));
- conn.inactive_browser_contexts.push(inactive);
+ ctx.conn.inactive_browser_contexts.push(inactive);
+ ctx.install_navigation_fixture_for_session_owner(
+ "data:text/html,<!doctype html><title>runtime-direct-owner</title>",
+ Some("SID-B"),
+ )
+ .await;
- let response = conn
- .process_message_messages_only_for_test(
- r#"{"id":1,"method":"Runtime.evaluate","sessionId":"SID-B","params":{"expression":"document.title","returnByValue":true}}"#,
- )
- .await;
- assert_eq!(response[0]["id"], json!(1));
+ ctx.sent.clear();
+ ctx.process_async(json!({
+ "id": 1,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-B",
+ "params": {"expression": "document.title", "returnByValue": true}
+ }))
+ .await;
+ let response = std::mem::take(&mut ctx.sent);
+ let response = response
+ .iter()
+ .find(|message| message["id"] == json!(1))
+ .unwrap_or_else(|| panic!("missing Runtime.evaluate response: {response:?}"));
+ assert_eq!(response["id"], json!(1));
assert_eq!(
- response[0]["result"]["result"]["value"],
+ response["result"]["result"]["value"],
json!("runtime-direct-owner"),
"{response:?}"
);
- assert_eq!(response[0]["sessionId"], json!("SID-B"));
+ assert_eq!(response["sessionId"], json!("SID-B"));
assert!(
- conn.browser_context.is_none(),
+ ctx.conn.browser_context.is_none(),
"direct Runtime.evaluate should not promote the inactive owner into the active slot"
);
}
@@ -1887,15 +1887,16 @@ async fn direct_runtime_evaluate_popup_creates_target_in_inactive_background_own
#[tokio::test]
async fn direct_runtime_evaluate_self_popup_does_not_navigate_active_target_for_inactive_owner() {
- let mut conn = CdpConnection::new();
+ let mut ctx = crate::testing::TestContext::new();
let mut active = BrowserContext::new("BID-active".into());
active.set_active_target_id("TID-active".to_owned());
active.attach_active_session("SID-active");
active.set_target_url("https://active.example/current".to_owned());
- conn.browser_context = Some(active);
+ ctx.conn.browser_context = Some(active);
- let mut page = conn
+ let mut page = ctx
+ .conn
.load_page_via_runtime_async("data:text/html,<!doctype html><title>self-popup</title>")
.await
.expect("background page should load");
@@ -1920,13 +1921,19 @@ async fn direct_runtime_evaluate_self_popup_does_not_navigate_active_target_for_
.runtime_session_state
.runtime_frontend_enabled = true;
});
- conn.inactive_browser_contexts.push(inactive);
+ ctx.conn.inactive_browser_contexts.push(inactive);
- let response = conn
- .process_message_messages_only_for_test(
- r#"{"id":1,"method":"Runtime.evaluate","sessionId":"SID-self-popup-background","params":{"expression":"window.open('https://example.com/should-not-hit-active', '_self') !== null"}}"#,
- )
- .await;
+ ctx.sent.clear();
+ ctx.process_async(json!({
+ "id": 1,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-self-popup-background",
+ "params": {
+ "expression": "window.open('https://example.com/should-not-hit-active', '_self') !== null"
+ }
+ }))
+ .await;
+ let response = std::mem::take(&mut ctx.sent);
assert!(
response.iter().any(|message| {
@@ -1943,7 +1950,7 @@ async fn direct_runtime_evaluate_self_popup_does_not_navigate_active_target_for_
"_self window.open should not create a popup target: {response:?}"
);
assert_eq!(
- conn.browser_context.as_ref().map(|bc| bc.target_url()),
+ ctx.conn.browser_context.as_ref().map(|bc| bc.target_url()),
Some("https://active.example/current"),
"inactive owner _self popup must not navigate the currently active target"
);
@@ -2026,20 +2033,8 @@ async fn direct_runtime_evaluate_file_chooser_uses_inactive_background_owner() {
#[tokio::test]
async fn direct_runtime_evaluate_routes_to_inactive_auxiliary_owner_without_promoting_slot() {
- let mut conn = CdpConnection::new();
+ let mut ctx = crate::testing::TestContext::new();
- let mut page = conn
- .load_page_via_runtime_async(
- "data:text/html,<!doctype html><title>runtime-direct-aux</title>",
- )
- .await
- .expect("test page should load");
- let _ = page
- .dispatch_runtime_protocol_message_async(
- &json!({"id": 9002, "method": "Runtime.enable", "params": {}}).to_string(),
- )
- .await
- .expect("Runtime.enable should create the owner inspector context");
let mut inactive = BrowserContext::new("BID-B".into());
inactive.set_active_target_id("TID-B".to_owned());
inactive.attach_active_session("SID-primary");
@@ -2048,23 +2043,35 @@ async fn direct_runtime_evaluate_routes_to_inactive_auxiliary_owner_without_prom
.devtools_session_state
.runtime_session_state
.runtime_frontend_enabled = true;
- inactive.replace_loaded_page(Some(page));
- conn.inactive_browser_contexts.push(inactive);
+ ctx.conn.inactive_browser_contexts.push(inactive);
+ ctx.install_navigation_fixture_for_session_owner(
+ "data:text/html,<!doctype html><title>runtime-direct-aux</title>",
+ Some("SID-aux"),
+ )
+ .await;
- let response = conn
- .process_message_messages_only_for_test(
- r#"{"id":1,"method":"Runtime.evaluate","sessionId":"SID-aux","params":{"expression":"document.title","returnByValue":true}}"#,
- )
- .await;
- assert_eq!(response[0]["id"], json!(1));
+ ctx.sent.clear();
+ ctx.process_async(json!({
+ "id": 1,
+ "method": "Runtime.evaluate",
+ "sessionId": "SID-aux",
+ "params": {"expression": "document.title", "returnByValue": true}
+ }))
+ .await;
+ let response = std::mem::take(&mut ctx.sent);
+ let response = response
+ .iter()
+ .find(|message| message["id"] == json!(1))
+ .unwrap_or_else(|| panic!("missing Runtime.evaluate response: {response:?}"));
+ assert_eq!(response["id"], json!(1));
assert_eq!(
- response[0]["result"]["result"]["value"],
+ response["result"]["result"]["value"],
json!("runtime-direct-aux"),
"{response:?}"
);
- assert_eq!(response[0]["sessionId"], json!("SID-aux"));
+ assert_eq!(response["sessionId"], json!("SID-aux"));
assert!(
- conn.browser_context.is_none(),
+ ctx.conn.browser_context.is_none(),
"direct auxiliary Runtime.evaluate should not promote the inactive owner"
);
}
diff --git a/moli-protocol/src/domains/activity/main_document.rs b/moli-protocol/src/domains/activity/main_document.rs
index b84f6650d..6533b6bd8 100644
--- a/moli-protocol/src/domains/activity/main_document.rs
+++ b/moli-protocol/src/domains/activity/main_document.rs
@@ -1595,9 +1595,7 @@ mod tests {
"the same durable owner-action residence must observe the terminal"
);
let outcome = conn.complete_ready_protocol_scheduler_work_turn(work).await;
- let (_, scheduler_events, renderer_output_predecessor) =
- outcome.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
+ let (_, scheduler_events) = outcome.into_protocol_event_parts();
assert!(
scheduler_events.iter().all(|event| !matches!(
event,
diff --git a/moli-protocol/src/domains/activity/runtime_command_barrier.rs b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
index 76b7a57d4..f71d15093 100644
--- a/moli-protocol/src/domains/activity/runtime_command_barrier.rs
+++ b/moli-protocol/src/domains/activity/runtime_command_barrier.rs
@@ -633,11 +633,10 @@ mod tests {
panic!("barrier release must publish concrete protocol work");
};
assert!(work.is_top_level_location_navigation_owner_action());
- let (events, nested_scheduler_events, renderer_output_predecessor) = conn
+ let (events, nested_scheduler_events) = conn
.complete_ready_protocol_scheduler_work_turn(work)
.await
.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
assert!(
!nested_scheduler_events.iter().any(|event| {
matches!(
diff --git a/moli-protocol/src/domains/dom/tests/mod.rs b/moli-protocol/src/domains/dom/tests/mod.rs
index fb013319f..b6e595378 100644
--- a/moli-protocol/src/domains/dom/tests/mod.rs
+++ b/moli-protocol/src/domains/dom/tests/mod.rs
@@ -249,15 +249,11 @@ fn assert_non_empty_geometry_quads(value: &Value) {
async fn complete_pending_command_task_for_test(
ctx: &mut TestContext,
- mut pending: PendingCdpCommandDispatch,
+ pending: PendingCdpCommandDispatch,
) -> Vec<Value> {
- loop {
- let completed = Box::pin(pending.wait()).await;
- match Box::pin(ctx.conn.complete_pending_command_dispatch(completed)).await {
- CdpCommandTaskStep::Pending(next) => pending = *next,
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts().0,
- }
- }
+ ctx.complete_command_task_step_for_test(CdpCommandTaskStep::Pending(Box::new(pending)))
+ .await
+ .0
}
async fn complete_command_dispatch_without_legacy_fallback_for_test(
@@ -266,12 +262,8 @@ async fn complete_command_dispatch_without_legacy_fallback_for_test(
_expectation: &str,
) -> Vec<Value> {
let raw = command.to_string();
- match ctx.conn.start_command_dispatch(&raw) {
- CdpCommandTaskStep::Complete(outcome) => outcome.into_parts().0,
- CdpCommandTaskStep::Pending(pending) => {
- complete_pending_command_task_for_test(ctx, *pending).await
- }
- }
+ let step = ctx.conn.start_command_dispatch(&raw);
+ ctx.complete_command_task_step_for_test(step).await.0
}
fn child_element_by_node_name<'a>(node: &'a Value, node_name: &str) -> &'a Value {
diff --git a/moli-protocol/src/domains/dom_snapshot.rs b/moli-protocol/src/domains/dom_snapshot.rs
index 699936c55..85a4f0d8d 100644
--- a/moli-protocol/src/domains/dom_snapshot.rs
+++ b/moli-protocol/src/domains/dom_snapshot.rs
@@ -225,35 +225,18 @@ mod tests {
async fn process_via_command_dispatch(ctx: &mut TestContext, msg: serde_json::Value) {
let raw = serde_json::to_string(&msg).expect("test command should serialize");
- let mut step = ctx.conn.start_command_dispatch(&raw);
- loop {
- match step {
- CdpCommandTaskStep::Complete(outcome) => {
- let (messages, _) = outcome.into_parts();
- ctx.sent.extend(messages);
- break;
- }
- CdpCommandTaskStep::Pending(pending) => {
- step = ctx
- .conn
- .complete_pending_command_dispatch(pending.wait().await)
- .await;
- }
- }
- }
+ let step = ctx.conn.start_command_dispatch(&raw);
+ let (messages, _) = ctx.complete_command_task_step_for_test(step).await;
+ ctx.sent.extend(messages);
}
async fn complete_pending_command_task_for_test(
ctx: &mut TestContext,
- mut pending: crate::conn::PendingCdpCommandDispatch,
+ pending: crate::conn::PendingCdpCommandDispatch,
) -> Vec<serde_json::Value> {
- loop {
- let completed = pending.wait().await;
- match ctx.conn.complete_pending_command_dispatch(completed).await {
- CdpCommandTaskStep::Pending(next) => pending = *next,
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts().0,
- }
- }
+ ctx.complete_command_task_step_for_test(CdpCommandTaskStep::Pending(Box::new(pending)))
+ .await
+ .0
}
async fn wait_until_runtime_value(
diff --git a/moli-protocol/src/domains/input/tests.rs b/moli-protocol/src/domains/input/tests.rs
index 7f08648d8..0569c7bbf 100644
--- a/moli-protocol/src/domains/input/tests.rs
+++ b/moli-protocol/src/domains/input/tests.rs
@@ -1274,7 +1274,7 @@ async fn coordinate_mouse_event_completes_through_pending_layout_dispatch() {
.conn
.complete_pending_command_dispatch(pending.wait().await)
.await;
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
@@ -1320,7 +1320,7 @@ async fn dispatch_key_event_can_complete_through_pending_command_dispatch() {
.conn
.complete_pending_command_dispatch(pending.wait().await)
.await;
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
@@ -1363,7 +1363,7 @@ async fn insert_text_can_complete_through_pending_command_dispatch() {
.conn
.complete_pending_command_dispatch(pending.wait().await)
.await;
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
@@ -1421,7 +1421,7 @@ async fn coordinate_touch_commands_complete_through_pending_layout_dispatch() {
.conn
.complete_pending_command_dispatch(pending.wait().await)
.await;
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
@@ -1518,7 +1518,7 @@ async fn coordinate_drag_event_completes_through_pending_layout_dispatch() {
.conn
.complete_pending_command_dispatch(pending.wait().await)
.await;
- let (messages, scheduler_events) = outcome.into_parts();
+ let (messages, scheduler_events) = ctx.complete_command_task_step_for_test(outcome).await;
assert!(
scheduler_events.is_empty(),
"drag event dispatch should not enqueue scheduler work"
diff --git a/moli-protocol/src/domains/page.rs b/moli-protocol/src/domains/page.rs
index 529561e82..68deff864 100644
--- a/moli-protocol/src/domains/page.rs
+++ b/moli-protocol/src/domains/page.rs
@@ -3643,11 +3643,10 @@ mod producer_tests {
}
let work = take_top_level_location_navigation_work_for_test(&mut conn);
- let (navigation_events, nested_scheduler_events, renderer_output_predecessor) = conn
+ let (navigation_events, nested_scheduler_events) = conn
.complete_ready_protocol_scheduler_work_turn(work)
.await
.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
assert!(
!nested_scheduler_events.iter().any(|event| {
matches!(
@@ -5064,11 +5063,10 @@ mod producer_tests {
);
let work = take_top_level_location_navigation_work_for_test(&mut conn);
- let (events, scheduler_events, renderer_output_predecessor) = conn
+ let (events, scheduler_events) = conn
.complete_ready_protocol_scheduler_work_turn(work)
.await
.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
assert!(!scheduler_events.iter().any(|event| {
matches!(
event,
@@ -5140,11 +5138,10 @@ mod producer_tests {
Some(&mut prepared),
);
let work = take_top_level_location_navigation_work_for_test(&mut conn);
- let (out, scheduler_events, renderer_output_predecessor) = conn
+ let (out, scheduler_events) = conn
.complete_ready_protocol_scheduler_work_turn(work)
.await
.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
assert!(!scheduler_events.iter().any(|event| {
matches!(
event,
@@ -5201,11 +5198,10 @@ mod producer_tests {
Some(&mut prepared),
);
let work = take_top_level_location_navigation_work_for_test(&mut conn);
- let (out, scheduler_events, renderer_output_predecessor) = conn
+ let (out, scheduler_events) = conn
.complete_ready_protocol_scheduler_work_turn(work)
.await
.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
assert!(scheduler_events.is_empty());
assert!(out.is_empty(), "a retired Page must start no navigation");
diff --git a/moli-protocol/src/domains/page/tests/lifecycle.rs b/moli-protocol/src/domains/page/tests/lifecycle.rs
index cad6331f1..eca2d9ad8 100644
--- a/moli-protocol/src/domains/page/tests/lifecycle.rs
+++ b/moli-protocol/src/domains/page/tests/lifecycle.rs
@@ -3485,7 +3485,7 @@ async fn close_command_background_events_keep_target_detached_sidecar() {
post_response_events,
scheduler_events,
renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
assert!(renderer_output_boundary.is_none());
assert!(post_renderer_output_events.is_empty());
assert!(renderer_output_predecessor.is_none());
@@ -3505,12 +3505,11 @@ async fn close_command_background_events_keep_target_detached_sidecar() {
// only then may this owner action retire the session route and materialize
// the detach sidecar. Exercise that real scheduler boundary instead of
// expecting the old command-local destructive drain.
- let (mut termination_events, nested_scheduler_events, termination_predecessor) = ctx
+ let (mut termination_events, nested_scheduler_events) = ctx
.conn
.complete_ready_protocol_scheduler_work_turn(work)
.await
.into_protocol_event_parts();
- assert!(termination_predecessor.is_none());
assert!(nested_scheduler_events.is_empty());
events.append(&mut termination_events);
diff --git a/moli-protocol/src/domains/profiler.rs b/moli-protocol/src/domains/profiler.rs
index cdd22930e..8280f20b0 100644
--- a/moli-protocol/src/domains/profiler.rs
+++ b/moli-protocol/src/domains/profiler.rs
@@ -101,15 +101,11 @@ mod tests {
async fn complete_pending_command_task_for_test(
ctx: &mut TestContext,
- mut pending: PendingCdpCommandDispatch,
+ pending: PendingCdpCommandDispatch,
) -> Vec<serde_json::Value> {
- loop {
- let completed = pending.wait().await;
- match ctx.conn.complete_pending_command_dispatch(completed).await {
- CdpCommandTaskStep::Pending(next) => pending = *next,
- CdpCommandTaskStep::Complete(outcome) => return outcome.into_parts().0,
- }
- }
+ ctx.complete_command_task_step_for_test(CdpCommandTaskStep::Pending(Box::new(pending)))
+ .await
+ .0
}
async fn process_and_take_response(
diff --git a/moli-protocol/src/domains/runtime/tests/evaluate.rs b/moli-protocol/src/domains/runtime/tests/evaluate.rs
index 5646e3b4e..4b8661f83 100644
--- a/moli-protocol/src/domains/runtime/tests/evaluate.rs
+++ b/moli-protocol/src/domains/runtime/tests/evaluate.rs
@@ -2699,9 +2699,8 @@ async fn evaluate_can_complete_through_pending_command_dispatch() {
.conn
.try_start_pending_command_dispatch(&raw)
.expect("simple Runtime.evaluate should start as a pending command");
- let completed = pending.wait().await;
- let outcome = ctx.conn.complete_pending_command_dispatch(completed).await;
- let (mut messages, scheduler_events) = outcome.into_parts();
+ let (mut messages, scheduler_events) =
+ super::complete_pending_command_task_for_test(&mut ctx, pending).await;
let msg = messages
.pop()
@@ -2964,11 +2963,7 @@ async fn isolated_evaluate_can_complete_through_pending_command_dispatch() {
.conn
.try_start_pending_command_dispatch(&raw)
.expect("Runtime.evaluate with isolated contextId should start as a pending command");
- let outcome = ctx
- .conn
- .complete_pending_command_dispatch(pending.wait().await)
- .await;
- let (messages, _) = outcome.into_parts();
+ let (messages, _) = super::complete_pending_command_task_for_test(&mut ctx, pending).await;
let response = messages
.iter()
.find(|message| message["id"] == json!(3_022))
@@ -3018,11 +3013,8 @@ async fn call_function_context_resolution_can_complete_through_pending_command_d
.conn
.try_start_pending_command_dispatch(&isolated_raw)
.expect("Runtime.callFunctionOn with isolated executionContextId should start pending");
- let isolated_outcome = ctx
- .conn
- .complete_pending_command_dispatch(isolated_pending.wait().await)
- .await;
- let (isolated_messages, _) = isolated_outcome.into_parts();
+ let (isolated_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, isolated_pending).await;
let isolated_response = isolated_messages
.iter()
.find(|message| message["id"] == json!(3_025))
@@ -3042,11 +3034,8 @@ async fn call_function_context_resolution_can_complete_through_pending_command_d
.conn
.try_start_pending_command_dispatch(&default_raw)
.expect("Runtime.callFunctionOn without objectId should start pending");
- let default_outcome = ctx
- .conn
- .complete_pending_command_dispatch(default_pending.wait().await)
- .await;
- let (default_messages, _) = default_outcome.into_parts();
+ let (default_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, default_pending).await;
let default_response = default_messages
.iter()
.find(|message| message["id"] == json!(3_026))
@@ -3086,11 +3075,8 @@ async fn object_runtime_commands_can_complete_through_pending_command_dispatch()
.conn
.try_start_pending_command_dispatch(&call_raw)
.expect("Runtime.callFunctionOn with objectId should start as a pending command");
- let call_outcome = ctx
- .conn
- .complete_pending_command_dispatch(call_pending.wait().await)
- .await;
- let (call_messages, _) = call_outcome.into_parts();
+ let (call_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, call_pending).await;
let call_response = call_messages
.iter()
.find(|message| message["id"] == json!(3_04))
@@ -3107,11 +3093,8 @@ async fn object_runtime_commands_can_complete_through_pending_command_dispatch()
.conn
.try_start_pending_command_dispatch(&properties_raw)
.expect("Runtime.getProperties with objectId should start as a pending command");
- let properties_outcome = ctx
- .conn
- .complete_pending_command_dispatch(properties_pending.wait().await)
- .await;
- let (properties_messages, _) = properties_outcome.into_parts();
+ let (properties_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, properties_pending).await;
let properties_response = properties_messages
.iter()
.find(|message| message["id"] == json!(3_05))
@@ -3157,11 +3140,8 @@ async fn object_runtime_commands_can_complete_through_pending_command_dispatch()
.conn
.try_start_pending_command_dispatch(&release_raw)
.expect("Runtime.releaseObject should start as a pending command");
- let release_outcome = ctx
- .conn
- .complete_pending_command_dispatch(release_pending.wait().await)
- .await;
- let (release_messages, _) = release_outcome.into_parts();
+ let (release_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, release_pending).await;
let release_response = release_messages
.iter()
.find(|message| message["id"] == json!(3_07))
@@ -3188,11 +3168,8 @@ async fn heap_usage_and_release_group_can_complete_through_pending_command_dispa
.conn
.try_start_pending_command_dispatch(&heap_raw)
.expect("Runtime.getHeapUsage should start as a pending command");
- let heap_outcome = ctx
- .conn
- .complete_pending_command_dispatch(heap_pending.wait().await)
- .await;
- let (heap_messages, _) = heap_outcome.into_parts();
+ let (heap_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, heap_pending).await;
let heap_response = heap_messages
.iter()
.find(|message| message["id"] == json!(3_08))
@@ -3226,11 +3203,8 @@ async fn heap_usage_and_release_group_can_complete_through_pending_command_dispa
.conn
.try_start_pending_command_dispatch(&release_group_raw)
.expect("Runtime.releaseObjectGroup should start as a pending command");
- let release_group_outcome = ctx
- .conn
- .complete_pending_command_dispatch(release_group_pending.wait().await)
- .await;
- let (release_group_messages, _) = release_group_outcome.into_parts();
+ let (release_group_messages, _) =
+ super::complete_pending_command_task_for_test(&mut ctx, release_group_pending).await;
let release_group_response = release_group_messages
.iter()
.find(|message| message["id"] == json!(3_10))
diff --git a/moli-protocol/src/domains/target/attachment.rs b/moli-protocol/src/domains/target/attachment.rs
index 79bc3be34..0f5a2970d 100644
--- a/moli-protocol/src/domains/target/attachment.rs
+++ b/moli-protocol/src/domains/target/attachment.rs
@@ -462,7 +462,7 @@ async fn send_message_to_target_inner_async(
post_response_events,
nested_scheduler_events,
renderer_output_predecessor,
- ) = nested_outcome.into_command_turn_parts();
+ ) = nested_outcome.into_renderer_owner_turn_parts();
if let Some(predecessor) = renderer_output_predecessor {
command_context.set_renderer_output_predecessor(predecessor);
}
diff --git a/moli-protocol/src/domains/target/lifecycle.rs b/moli-protocol/src/domains/target/lifecycle.rs
index 998a6e60b..9cb45a71a 100644
--- a/moli-protocol/src/domains/target/lifecycle.rs
+++ b/moli-protocol/src/domains/target/lifecycle.rs
@@ -1263,11 +1263,7 @@ async fn settle_target_close_after_pending_fetches_async(
let outcome =
crate::domains::page::complete_page_target_termination_owner_action_async(conn, action)
.await;
- let (events, scheduler_events, unexpected_predecessor) = outcome.into_protocol_event_parts();
- assert!(
- unexpected_predecessor.is_none(),
- "a target-termination owner action cannot produce renderer output"
- );
+ let (events, scheduler_events) = outcome.into_protocol_event_parts();
out.extend_background_events(events);
conn.extend_scheduler_events(scheduler_events);
}
diff --git a/moli-protocol/src/lib.rs b/moli-protocol/src/lib.rs
index 6162a5c2c..d15f7d263 100644
--- a/moli-protocol/src/lib.rs
+++ b/moli-protocol/src/lib.rs
@@ -20,11 +20,11 @@ pub use devtools_runtime::*;
pub use conn::{
BackgroundCommandResponsePayload, BackgroundProtocolEvent, CdpCommandTaskStep, CdpConnection,
CdpInitialStoragePartition, CdpRendererCommandAccess, CdpRendererCommandReplacement,
- CdpRendererCommandReplayDispatch, CdpSchedulerEvent, CdpTargetHostLifecycleDelta,
- CdpTargetHostLifecycleObserver, CdpTurnOutcome, CommandDispatchContext,
- CommandResponseFlushContext, CommandResponseFlushPermit, CompletedCdpCommandDispatch,
- CompletedDeferredMainDocumentLoadCompletion, CompletedRuntimeProtocolMessageDispatch,
- DeferredMainDocumentLoadCompletionOutputAction,
+ CdpRendererCommandReplayDispatch, CdpRendererOwnerTurnOutcome, CdpSchedulerEvent,
+ CdpTargetHostLifecycleDelta, CdpTargetHostLifecycleObserver, CdpTurnOutcome,
+ CommandDispatchContext, CommandResponseFlushContext, CommandResponseFlushPermit,
+ CompletedCdpCommandDispatch, CompletedDeferredMainDocumentLoadCompletion,
+ CompletedRuntimeProtocolMessageDispatch, DeferredMainDocumentLoadCompletionOutputAction,
DeferredMainDocumentLoadCompletionOutputInterest, DeferredMainDocumentLoadObservationId,
DeferredMainDocumentLoadPredecessorCandidate, DevToolsCommandDispatchOutcome,
DevToolsDocumentLifecycleWaitKey, DevToolsDocumentLifecycleWaitState,
diff --git a/moli-protocol/src/testing.rs b/moli-protocol/src/testing.rs
index 89b4d279f..707eb6757 100644
--- a/moli-protocol/src/testing.rs
+++ b/moli-protocol/src/testing.rs
@@ -9,7 +9,7 @@ use std::time::Duration;
use super::conn::{
BackgroundProtocolEvent, CdpCommandTaskStep, CdpConnection, CdpInitialStoragePartition,
- CdpSchedulerEvent, CdpTurnOutcome, CommandDispatchContext, CommandResponseFlushPermit,
+ CdpSchedulerEvent, CommandDispatchContext, CommandResponseFlushPermit,
LoadedNavigationRendererAttachmentCommit, ParsedCdpCommand, PendingCdpCommandDispatch,
RuntimeInspectorResponseReady,
};
@@ -759,7 +759,7 @@ impl TestContext {
mut post_response_events,
mut new_scheduler_events,
mut renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
if let Some(command_predecessor) =
command_context.take_renderer_output_predecessor()
{
@@ -913,7 +913,7 @@ impl TestContext {
/// outcome into a message-only vector.
pub(crate) async fn route_completed_command_outcome_for_test(
&mut self,
- outcome: CdpTurnOutcome,
+ outcome: crate::CdpRendererOwnerTurnOutcome,
) -> (Vec<Value>, Vec<CdpSchedulerEvent>) {
let sent_start = self.sent.len();
let (
@@ -923,7 +923,7 @@ impl TestContext {
post_response_events,
scheduler_events,
renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
if let Some(predecessor) = renderer_output_predecessor {
Box::pin(self.route_renderer_output_predecessor_before_command_response(predecessor))
.await;
@@ -956,12 +956,8 @@ impl TestContext {
permit,
)
.await;
- let (protocol_events, scheduler_events, renderer_output_predecessor) =
+ let (protocol_events, scheduler_events) =
completion.into_outcome().into_protocol_event_parts();
- assert!(
- renderer_output_predecessor.is_none(),
- "releasing a Runtime output barrier cannot introduce another renderer fence"
- );
if route_scheduler_events {
Box::pin(self.route_test_scheduler_causal_batch(protocol_events, scheduler_events))
.await;
@@ -977,12 +973,8 @@ impl TestContext {
completion: RuntimeCommandOutputBarrierCompletion,
work: &mut VecDeque<TestSchedulerWork>,
) {
- let (protocol_events, scheduler_events, renderer_output_predecessor) =
+ let (protocol_events, scheduler_events) =
completion.into_outcome().into_protocol_event_parts();
- assert!(
- renderer_output_predecessor.is_none(),
- "a Runtime output barrier terminal cannot introduce another renderer fence"
- );
if !scheduler_events.is_empty() {
work.push_front(TestSchedulerWork::SchedulerEvents(scheduler_events));
}
@@ -1151,7 +1143,7 @@ impl TestContext {
mut post_response_events,
scheduler_events,
renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
assert!(
renderer_output_predecessor.is_none(),
"background navigation completion must use an insertion boundary"
@@ -1491,15 +1483,11 @@ impl TestContext {
.pending_protocol_scheduler_work
.remove(selected_index)
.expect("ready protocol work must remain resident");
- let (events, scheduler_events, renderer_output_predecessor) = self
+ let (events, scheduler_events) = self
.conn
.complete_ready_protocol_scheduler_work_turn(protocol_work)
.await
.into_protocol_event_parts();
- assert!(
- renderer_output_predecessor.is_none(),
- "protocol scheduler work must not introduce a renderer command fence"
- );
if !events.is_empty() {
work.push_back(TestSchedulerWork::ProtocolEvents(events));
}
@@ -1533,12 +1521,7 @@ impl TestContext {
&mut self.runtime_command_output_barriers,
)
.await;
- let (protocol_events, scheduler_events, renderer_output_predecessor) =
- outcome.into_protocol_event_parts();
- assert!(
- renderer_output_predecessor.is_none(),
- "renderer ingress cannot recursively introduce a renderer command fence"
- );
+ let (protocol_events, scheduler_events) = outcome.into_protocol_event_parts();
if !protocol_events.is_empty() {
work.push_back(TestSchedulerWork::ProtocolEvents(protocol_events));
}
@@ -1841,11 +1824,10 @@ async fn drain_scheduler_events_like_scheduler_with_materializer(
protocol_work.is_ready(),
"the stateless compatibility materializer cannot own pending protocol work; use TestContext or the production CdpScheduler"
);
- let (events, nested_scheduler_events, renderer_output_predecessor) = conn
+ let (events, nested_scheduler_events) = conn
.complete_ready_protocol_scheduler_work_turn(protocol_work)
.await
.into_protocol_event_parts();
- assert!(renderer_output_predecessor.is_none());
out.extend(events.into_iter().map(materialize_event));
enqueue_scheduler_events_like_scheduler(&mut queue, nested_scheduler_events);
enqueue_scheduler_events_like_scheduler(&mut queue, conn.take_scheduler_events());
diff --git a/moli/src/cdp_scheduler.rs b/moli/src/cdp_scheduler.rs
index 3de4ccac7..055fd4514 100644
--- a/moli/src/cdp_scheduler.rs
+++ b/moli/src/cdp_scheduler.rs
@@ -730,7 +730,7 @@ impl CdpScheduler {
post_response_events,
scheduler_events,
renderer_output_predecessor,
- ) = result.into_command_turn_parts();
+ ) = result.into_renderer_owner_turn_parts();
CommandTaskStep::Complete(Box::new(
CommandTurnOutput::new_with_post_response_events(
self.route_background_events_around_inflight_navigation(events),
@@ -776,7 +776,7 @@ impl CdpScheduler {
post_response_events,
scheduler_events,
renderer_output_predecessor,
- ) = result.into_command_turn_parts();
+ ) = result.into_renderer_owner_turn_parts();
CommandTaskStep::Complete(Box::new(
CommandTurnOutput::new_with_post_response_events(
self.route_background_events_around_inflight_navigation(events),
@@ -886,7 +886,7 @@ impl CdpScheduler {
.conn
.process_message_with_turn_outcome_async(&message.to_string())
.await;
- self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)
+ self.apply_renderer_owner_turn_outcome(receivers, outcome)
.await
}
@@ -938,7 +938,7 @@ impl CdpScheduler {
else {
return Ok(ProtocolOutputSequence::empty());
};
- self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)
+ self.apply_renderer_owner_turn_outcome(receivers, outcome)
.await
}
@@ -954,7 +954,7 @@ impl CdpScheduler {
else {
return Ok(ProtocolOutputSequence::empty());
};
- self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)
+ self.apply_renderer_owner_turn_outcome(receivers, outcome)
.await
}
@@ -1896,35 +1896,27 @@ impl CdpScheduler {
}
}
- fn apply_turn_outcome(
+ fn apply_protocol_only_turn_outcome(
&mut self,
outcome: moli_protocol::CdpTurnOutcome,
) -> ProtocolOutputSequence {
- let (
- mut output,
- post_renderer_output,
- renderer_output_boundary,
- renderer_output_predecessor,
- ) = self.materialize_turn_outcome(outcome);
+ let (mut output, post_renderer_output, renderer_output_boundary) =
+ self.materialize_protocol_only_turn_outcome(outcome);
assert!(
renderer_output_boundary.is_none(),
"non-command turn must consume its renderer insertion boundary at its owner boundary"
);
- assert!(
- renderer_output_predecessor.is_none(),
- "non-command turn must consume its renderer output predecessor at its owner boundary"
- );
output.append(post_renderer_output);
output
}
- async fn apply_turn_outcome_at_renderer_owner_boundary(
+ async fn apply_renderer_owner_turn_outcome(
&mut self,
receivers: &mut CdpSchedulerEventReceivers,
- outcome: moli_protocol::CdpTurnOutcome,
+ outcome: moli_protocol::CdpRendererOwnerTurnOutcome,
) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
let (output, post_renderer_output, renderer_output_boundary, renderer_output_predecessor) =
- self.materialize_turn_outcome(outcome);
+ self.materialize_renderer_owner_turn_outcome(outcome);
assert!(
renderer_output_boundary.is_none(),
"non-navigation owner turn must not carry a renderer insertion boundary"
@@ -1945,9 +1937,33 @@ impl CdpScheduler {
Ok(causal_output)
}
- fn materialize_turn_outcome(
+ fn materialize_protocol_only_turn_outcome(
&mut self,
outcome: moli_protocol::CdpTurnOutcome,
+ ) -> (
+ ProtocolOutputSequence,
+ ProtocolOutputSequence,
+ Option<moli_core::RendererOutputFence>,
+ ) {
+ let (
+ events,
+ mut post_renderer_output_events,
+ renderer_output_boundary,
+ mut post_response_events,
+ scheduler_events,
+ ) = outcome.into_command_turn_parts();
+ post_renderer_output_events.append(&mut post_response_events);
+ self.apply_scheduler_events(scheduler_events);
+ (
+ self.route_background_events_around_inflight_navigation(events),
+ self.route_background_events_around_inflight_navigation(post_renderer_output_events),
+ renderer_output_boundary,
+ )
+ }
+
+ fn materialize_renderer_owner_turn_outcome(
+ &mut self,
+ outcome: moli_protocol::CdpRendererOwnerTurnOutcome,
) -> (
ProtocolOutputSequence,
ProtocolOutputSequence,
@@ -1961,7 +1977,7 @@ impl CdpScheduler {
mut post_response_events,
scheduler_events,
renderer_output_predecessor,
- ) = outcome.into_command_turn_parts();
+ ) = outcome.into_renderer_owner_turn_parts();
post_renderer_output_events.append(&mut post_response_events);
self.apply_scheduler_events(scheduler_events);
(
@@ -2021,16 +2037,11 @@ impl CdpScheduler {
renderer_output_boundary,
mut post_response_events,
scheduler_events,
- renderer_output_predecessor,
) = outcome.into_command_turn_parts();
assert!(
renderer_output_boundary.is_none(),
"renderer output ingress cannot recursively insert another renderer cursor"
);
- assert!(
- renderer_output_predecessor.is_none(),
- "renderer output ingress cannot recursively depend on another renderer cursor"
- );
events.append(&mut post_renderer_output_events);
events.append(&mut post_response_events);
let output = ProtocolOutputSequence::from_background_events(events);
@@ -2170,7 +2181,7 @@ impl CdpScheduler {
terminal = ?completion.terminal(),
);
}
- self.apply_turn_outcome(completion.into_outcome())
+ self.apply_protocol_only_turn_outcome(completion.into_outcome())
}
fn next_protocol_scheduler_step(&self) -> ProtocolSchedulerStep {
@@ -2233,7 +2244,7 @@ impl CdpScheduler {
.conn
.project_protocol_local_command_outputs_turn_async(session_id)
.await;
- self.apply_turn_outcome(outcome)
+ self.apply_protocol_only_turn_outcome(outcome)
}
async fn complete_protocol_residence(
@@ -2288,7 +2299,7 @@ impl CdpScheduler {
.conn
.complete_ready_protocol_scheduler_work_turn(work)
.await;
- out.append(self.apply_turn_outcome(outcome));
+ out.append(self.apply_protocol_only_turn_outcome(outcome));
if let Some(observation_id) = load_observation_id {
self.queues.satisfy_load_predecessor(observation_id);
}
@@ -2385,7 +2396,7 @@ impl CdpScheduler {
.conn
.complete_deferred_main_document_load_completion_for_scheduler(completion)
.await;
- let output = self.apply_turn_outcome(outcome);
+ let output = self.apply_protocol_only_turn_outcome(outcome);
self.queues.satisfy_load_predecessor(observation_id);
if let Some(started) = trace_started {
tracing::info!(
@@ -2413,7 +2424,7 @@ impl CdpScheduler {
.drain_background_navigation_completion_turn_async(completion)
.await;
let (out, post_renderer_output, renderer_output_boundary, renderer_output_predecessor) =
- self.materialize_turn_outcome(outcome);
+ self.materialize_renderer_owner_turn_outcome(outcome);
if let Some(started) = trace_started {
tracing::info!(
target: "moli_cdp_runtime",