Skip to content

armgit / moli

Public Imported from GitHub
0

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

fix(webdriver): project BiDi hook predecessors

ldm019ad99cf154c
diff --git a/moli/src/cdp_scheduler.rs b/moli/src/cdp_scheduler.rs
index a9cad0b6d..7461a8409 100644
--- a/moli/src/cdp_scheduler.rs
+++ b/moli/src/cdp_scheduler.rs
@@ -933,13 +933,15 @@ impl CdpScheduler {
pub(crate) async fn execute_internal_protocol_message(
&mut self,
+ receivers: &mut CdpSchedulerEventReceivers,
message: Value,
- ) -> ProtocolOutputSequence {
+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
let outcome = self
.conn
.process_message_with_turn_outcome_async(&message.to_string())
.await;
- self.apply_turn_outcome(outcome)
+ self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)
+ .await
}
pub(crate) fn enable_network_listener_for_target(&mut self, target_id: &str) -> bool {
@@ -980,30 +982,34 @@ impl CdpScheduler {
pub(crate) async fn enable_runtime_listener_for_target(
&mut self,
+ receivers: &mut CdpSchedulerEventReceivers,
target_id: &str,
- ) -> ProtocolOutputSequence {
+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
let Some(outcome) = self
.conn
.enable_runtime_listener_for_target(target_id)
.await
else {
- return ProtocolOutputSequence::empty();
+ return Ok(ProtocolOutputSequence::empty());
};
- self.apply_turn_outcome(outcome)
+ self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)
+ .await
}
pub(crate) async fn disable_runtime_listener_for_target(
&mut self,
+ receivers: &mut CdpSchedulerEventReceivers,
target_id: &str,
- ) -> ProtocolOutputSequence {
+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
let Some(outcome) = self
.conn
.disable_runtime_listener_for_target(target_id)
.await
else {
- return ProtocolOutputSequence::empty();
+ return Ok(ProtocolOutputSequence::empty());
};
- self.apply_turn_outcome(outcome)
+ self.apply_turn_outcome_at_renderer_owner_boundary(receivers, outcome)
+ .await
}
pub(crate) fn replace_target_discovery_enabled(&mut self, enabled: bool) -> bool {
@@ -1970,6 +1976,33 @@ impl CdpScheduler {
output
}
+ async fn apply_turn_outcome_at_renderer_owner_boundary(
+ &mut self,
+ receivers: &mut CdpSchedulerEventReceivers,
+ outcome: moli_protocol::CdpTurnOutcome,
+ ) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
+ let (output, post_renderer_output, renderer_output_boundary, renderer_output_predecessor) =
+ self.materialize_turn_outcome(outcome);
+ assert!(
+ renderer_output_boundary.is_none(),
+ "non-navigation owner turn must not carry a renderer insertion boundary"
+ );
+
+ let mut causal_output = ProtocolOutputSequence::empty();
+ if let Some(predecessor) = renderer_output_predecessor {
+ causal_output.append(
+ self.project_renderer_output_predecessor_before_devtools_result(
+ receivers,
+ &predecessor,
+ )
+ .await?,
+ );
+ }
+ causal_output.append(output);
+ causal_output.append(post_renderer_output);
+ Ok(causal_output)
+ }
+
fn materialize_turn_outcome(
&mut self,
outcome: moli_protocol::CdpTurnOutcome,
diff --git a/moli/src/protocol_server/tests/bidi.rs b/moli/src/protocol_server/tests/bidi.rs
index 56a567c76..99e6757e6 100644
--- a/moli/src/protocol_server/tests/bidi.rs
+++ b/moli/src/protocol_server/tests/bidi.rs
@@ -797,6 +797,101 @@ async fn websocket_bidi_classic_session_omits_synthetic_service_worker_runtime()
protocol_server.abort();
}
+#[tokio::test]
+async fn websocket_bidi_shared_worker_subscription_projects_runtime_listener_predecessor() {
+ let (fixture_addr, _fixture_server) = spawn_shared_worker_fixture_server("bidi-shared-worker");
+ let page_url = format!("http://{fixture_addr}/");
+ let worker_url = format!("http://{fixture_addr}/shared-worker.js");
+
+ let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
+ let (mut socket, context_id) = bidi_session_with_context(cdp_addr).await;
+
+ let navigate = send_bidi_command_response(
+ &mut socket,
+ 3,
+ "browsingContext.navigate",
+ json!({
+ "context": context_id.clone(),
+ "url": page_url,
+ "wait": "complete"
+ }),
+ )
+ .await;
+ assert_eq!(navigate["type"], json!("success"), "{navigate:?}");
+
+ let subscribe = send_bidi_command_response(
+ &mut socket,
+ 4,
+ "session.subscribe",
+ json!({
+ "events": [
+ "browsingContext.contextCreated",
+ "script.realmCreated"
+ ]
+ }),
+ )
+ .await;
+ assert_eq!(subscribe["type"], json!("success"), "{subscribe:?}");
+
+ socket
+ .send(WsMessage::Text(
+ json!({
+ "id": 5_u64,
+ "method": "script.evaluate",
+ "params": {
+ "expression": "globalThis.__sharedWorkerProbe('bidi').then(value => JSON.stringify(value))",
+ "target": { "context": context_id },
+ "awaitPromise": true
+ }
+ })
+ .to_string()
+ .into(),
+ ))
+ .await
+ .expect("send shared worker script.evaluate");
+ let messages = recv_until_id(&mut socket, 5).await;
+ let messages = collect_bidi_messages_until(
+ &mut socket,
+ messages,
+ |messages| {
+ let saw_context = messages.iter().any(|message| {
+ message["method"] == json!("browsingContext.contextCreated")
+ && message["params"]["url"] == json!(worker_url)
+ });
+ let saw_realm = messages.iter().any(|message| {
+ message["method"] == json!("script.realmCreated")
+ && message["params"]["type"] == json!("shared-worker")
+ });
+ saw_context && saw_realm
+ },
+ "shared worker context and realm events",
+ )
+ .await;
+
+ let evaluate = bidi_message_by_id(&messages, 5);
+ assert_eq!(evaluate["type"], json!("success"), "{messages:#?}");
+ let probe: serde_json::Value = serde_json::from_str(
+ evaluate["result"]["result"]["value"]
+ .as_str()
+ .expect("shared worker probe JSON string"),
+ )
+ .expect("parse shared worker probe JSON");
+ assert_eq!(probe["echoed"], json!("bidi"));
+ assert_eq!(probe["isSharedWorker"], json!(true));
+
+ let end = send_bidi_command_response(&mut socket, 6, "session.end", json!({})).await;
+ assert_eq!(end["type"], json!("success"), "{end:?}");
+ let closed = timeout(Duration::from_secs(1), socket.next())
+ .await
+ .expect("BiDi socket should close after releasing shared worker event sources");
+ assert!(matches!(
+ closed,
+ Some(Ok(WsMessage::Close(_))) | None | Some(Err(_))
+ ));
+
+ protocol_server.abort();
+}
+
#[tokio::test]
async fn websocket_bidi_session_registry_allocates_unique_ids_across_connections() {
let (cdp_addr, protocol_server) = spawn_test_protocol_server().await;
diff --git a/moli/src/protocol_server/tests/classic.rs b/moli/src/protocol_server/tests/classic.rs
index 453dfde2f..1946aedb4 100644
--- a/moli/src/protocol_server/tests/classic.rs
+++ b/moli/src/protocol_server/tests/classic.rs
@@ -13823,7 +13823,8 @@ async fn webdriver_classic_service_worker_projection_does_not_pollute_window_han
#[tokio::test]
async fn webdriver_classic_shared_worker_reuses_instance_and_does_not_pollute_window_handles() {
- let (fixture_addr, _fixture_server) = spawn_classic_shared_worker_fixture_server();
+ let (fixture_addr, _fixture_server) =
+ spawn_shared_worker_fixture_server("classic-shared-worker");
let app = build_router(test_state());
let session = classic_request_json(app.clone(), Method::POST, "/session").await;
@@ -16643,48 +16644,6 @@ fn spawn_classic_service_worker_fixture_server() -> (std::net::SocketAddr, Dedic
spawn_dedicated_fixture_server(app, "classic-service-worker")
}
-fn spawn_classic_shared_worker_fixture_server() -> (std::net::SocketAddr, DedicatedFixtureServer) {
- let app = Router::new()
- .route(
- "/",
- get(|| async move {
- (
- [(header::CONTENT_TYPE.as_str(), "text/html")],
- "<!doctype html><html><body>classic shared worker</body></html>",
- )
- }),
- )
- .route(
- "/shared-worker.js",
- get(|| async move {
- (
- [(header::CONTENT_TYPE.as_str(), "text/javascript")],
- "globalThis.__classicSharedWorkerConnectCount = 0;\
- self.onconnect = event => {\
- globalThis.__classicSharedWorkerConnectCount += 1;\
- const port = event.ports[0];\
- port.onmessage = message => {\
- const data = message.data;\
- if (data && data.kind === 'probe') {\
- port.postMessage({\
- kind: 'probe-result',\
- echoed: data.value,\
- name,\
- pathname: self.location.pathname,\
- isSharedWorker: typeof SharedWorkerGlobalScope !== 'undefined' && self instanceof SharedWorkerGlobalScope,\
- selfEqualsGlobal: self === globalThis,\
- connectCount: globalThis.__classicSharedWorkerConnectCount\
- });\
- }\
- };\
- port.start();\
- };",
- )
- }),
- );
- spawn_dedicated_fixture_server(app, "classic-shared-worker")
-}
-
async fn classic_switch_to_child_frame_and_remove_current_frame(
app: Router,
session_id: &str,
diff --git a/moli/src/protocol_server/tests/mod.rs b/moli/src/protocol_server/tests/mod.rs
index 38db0cf98..9be2b7664 100644
--- a/moli/src/protocol_server/tests/mod.rs
+++ b/moli/src/protocol_server/tests/mod.rs
@@ -3,7 +3,7 @@ use axum::{
Router,
body::{Body, to_bytes},
extract::{WebSocketUpgrade, ws::Message},
- http::{Method, Request, StatusCode},
+ http::{Method, Request, StatusCode, header},
response::IntoResponse,
routing::{get, post},
};
@@ -94,6 +94,65 @@ fn spawn_dedicated_fixture_server(
)
}
+fn spawn_shared_worker_fixture_server(
+ name: &'static str,
+) -> (std::net::SocketAddr, DedicatedFixtureServer) {
+ let app = Router::new()
+ .route(
+ "/",
+ get(|| async move {
+ (
+ [(header::CONTENT_TYPE.as_str(), "text/html")],
+ r#"<!doctype html><html><body>shared worker
+<script>
+globalThis.__sharedWorkerProbe = value => new Promise((resolve, reject) => {
+ const timer = setTimeout(() => reject(new Error('shared worker timeout')), 1000);
+ const worker = new SharedWorker('/shared-worker.js', 'webdriver-shared-worker-smoke');
+ globalThis.__sharedWorkerSmoke = worker;
+ worker.port.onmessage = event => {
+ if (event.data && event.data.kind === 'probe-result') {
+ clearTimeout(timer);
+ resolve(event.data);
+ }
+ };
+ worker.port.start();
+ worker.port.postMessage({ kind: 'probe', value });
+});
+</script></body></html>"#,
+ )
+ }),
+ )
+ .route(
+ "/shared-worker.js",
+ get(|| async move {
+ (
+ [(header::CONTENT_TYPE.as_str(), "text/javascript")],
+ "globalThis.__sharedWorkerConnectCount = 0;\
+ self.onconnect = event => {\
+ globalThis.__sharedWorkerConnectCount += 1;\
+ const port = event.ports[0];\
+ port.onmessage = message => {\
+ const data = message.data;\
+ if (data && data.kind === 'probe') {\
+ port.postMessage({\
+ kind: 'probe-result',\
+ echoed: data.value,\
+ name,\
+ pathname: self.location.pathname,\
+ isSharedWorker: typeof SharedWorkerGlobalScope !== 'undefined' && self instanceof SharedWorkerGlobalScope,\
+ selfEqualsGlobal: self === globalThis,\
+ connectCount: globalThis.__sharedWorkerConnectCount\
+ });\
+ }\
+ };\
+ port.start();\
+ };",
+ )
+ }),
+ );
+ spawn_dedicated_fixture_server(app, name)
+}
+
fn wait_for_dedicated_fixture_ready(addr: std::net::SocketAddr, name: &'static str) {
let mut stream = std::net::TcpStream::connect(addr)
.unwrap_or_else(|error| panic!("connect to {name} fixture readiness route: {error}"));
diff --git a/moli/src/protocol_server/webdriver_bidi.rs b/moli/src/protocol_server/webdriver_bidi.rs
index 5158d903f..aad4a1b7f 100644
--- a/moli/src/protocol_server/webdriver_bidi.rs
+++ b/moli/src/protocol_server/webdriver_bidi.rs
@@ -52,6 +52,7 @@ use crate::cdp_scheduler::{
CdpScheduler, CdpSchedulerEventReceivers, DevToolsRuntimeCommandProgress,
PendingDevToolsRuntimeDeferredReplyExecution, ProtocolAdapterScheduler,
ProtocolAdapterSchedulerAdvance, ProtocolAdapterSchedulerInput, ProtocolOutputSequence,
+ RendererOutputTransportFailure,
};
use super::webdriver_files::selected_files_from_paths;
@@ -251,7 +252,9 @@ async fn handle_bidi_session_socket_local(
}
}
}
- actor.release_event_sources(&mut scheduler).await;
+ actor
+ .release_event_sources(&mut scheduler, &mut receivers)
+ .await;
actor.release_session(&mut session_registry.lock());
CookieProfileCommit::from_optional_profile_backed_snapshot(
initial_cookie_snapshot,
@@ -323,10 +326,19 @@ impl BidiSocketActor {
pub(in crate::protocol_server) async fn release_event_sources(
&mut self,
scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
) {
self.release_pending_runtime_command_state(scheduler);
let plan = self.bidi.release_event_source_hook_plan();
- let _ = execute_bidi_event_source_hook_plan(scheduler, &mut self.bidi, &plan).await;
+ let mut events = Vec::new();
+ let _ = append_bidi_event_source_hook_plan_events(
+ scheduler,
+ receivers,
+ &mut self.bidi,
+ &plan,
+ &mut events,
+ )
+ .await;
}
fn release_pending_runtime_command_state(&mut self, scheduler: &mut CdpScheduler) {
@@ -485,7 +497,8 @@ impl BidiSocketActor {
if self.pending_runtime_command.is_none() {
return send_bidi_protocol_output(
&mut self.socket,
- Some(scheduler),
+ scheduler,
+ receivers,
&mut self.bidi,
output,
owner_context,
@@ -506,7 +519,8 @@ impl BidiSocketActor {
let Some(mut pending_command) = self.pending_runtime_command.take() else {
return send_bidi_protocol_output(
&mut self.socket,
- Some(scheduler),
+ scheduler,
+ receivers,
&mut self.bidi,
output,
None,
@@ -535,7 +549,8 @@ impl BidiSocketActor {
let output = scheduler.route_registered_runtime_inspector_response(response);
return send_bidi_protocol_output(
&mut self.socket,
- Some(scheduler),
+ scheduler,
+ receivers,
&mut self.bidi,
output,
None,
@@ -586,7 +601,8 @@ impl BidiSocketActor {
pending_command.pending = Some(pending);
let sent = send_bidi_protocol_output(
&mut self.socket,
- Some(scheduler),
+ scheduler,
+ receivers,
&mut self.bidi,
protocol_output,
None,
@@ -799,8 +815,17 @@ async fn handle_bidi_socket_message(
&initial_sources,
pending.completion.event_context.as_deref(),
);
- append_context_created_event_source_hook_events(scheduler, bidi, &mut bidi_events)
- .await;
+ if !append_context_created_event_source_hook_events(
+ scheduler,
+ receivers,
+ bidi,
+ &mut bidi_events,
+ )
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ return false;
+ }
if !send_bidi_json_events(socket, bidi_events).await {
return false;
}
@@ -845,15 +870,34 @@ async fn handle_bidi_socket_message(
&command_output.event_sources,
command_output.event_context.as_deref(),
);
- if !renderer_output_transport_terminal {
- append_context_created_event_source_hook_events(scheduler, bidi, &mut bidi_events).await;
+ if !renderer_output_transport_terminal
+ && !append_context_created_event_source_hook_events(
+ scheduler,
+ receivers,
+ bidi,
+ &mut bidi_events,
+ )
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ return false;
}
if command_method.as_deref() == Some("session.subscribe")
&& command_output.response["type"] == json!("success")
&& !renderer_output_transport_terminal
{
- if let Some(plan) = subscribe_hook_plan.as_ref() {
- bidi_events.extend(execute_bidi_event_source_hook_plan(scheduler, bidi, plan).await);
+ if let Some(plan) = subscribe_hook_plan.as_ref()
+ && !append_bidi_event_source_hook_plan_events(
+ scheduler,
+ receivers,
+ bidi,
+ plan,
+ &mut bidi_events,
+ )
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ return false;
}
bidi_events.extend(
replay_existing_bidi_realm_created_events(
@@ -865,21 +909,36 @@ async fn handle_bidi_socket_message(
);
bidi_events.extend(bidi.replay_buffered_bidi_log_entry_events_for_subscriptions());
}
- bidi_events
- .extend(execute_bidi_event_source_hook_plan(scheduler, bidi, &command_hook_plan).await);
+ if !append_bidi_event_source_hook_plan_events(
+ scheduler,
+ receivers,
+ bidi,
+ &command_hook_plan,
+ &mut bidi_events,
+ )
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ return false;
+ }
let mut post_response_bidi_events = subscribed_bidi_events_from_devtools_event_sources(
Some(&*scheduler),
bidi,
&command_output.post_response_event_sources,
command_output.event_context.as_deref(),
);
- if !renderer_output_transport_terminal {
- append_context_created_event_source_hook_events(
+ if !renderer_output_transport_terminal
+ && !append_context_created_event_source_hook_events(
scheduler,
+ receivers,
bidi,
&mut post_response_bidi_events,
)
- .await;
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ let _ = send_bidi_json_events(socket, post_response_bidi_events).await;
+ return false;
}
if !send_bidi_json_events(socket, bidi_events).await {
return false;
@@ -1002,24 +1061,48 @@ async fn complete_and_send_bidi_pending_runtime_command(
&command_output.event_sources,
command_output.event_context.as_deref(),
);
- if !renderer_output_transport_terminal {
- append_context_created_event_source_hook_events(scheduler, bidi, &mut bidi_events).await;
+ if !renderer_output_transport_terminal
+ && !append_context_created_event_source_hook_events(
+ scheduler,
+ receivers,
+ bidi,
+ &mut bidi_events,
+ )
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ return false;
+ }
+ if !append_bidi_event_source_hook_plan_events(
+ scheduler,
+ receivers,
+ bidi,
+ &command_hook_plan,
+ &mut bidi_events,
+ )
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ return false;
}
- bidi_events
- .extend(execute_bidi_event_source_hook_plan(scheduler, bidi, &command_hook_plan).await);
let mut post_response_bidi_events = subscribed_bidi_events_from_devtools_event_sources(
Some(&*scheduler),
bidi,
&command_output.post_response_event_sources,
command_output.event_context.as_deref(),
);
- if !renderer_output_transport_terminal {
- append_context_created_event_source_hook_events(
+ if !renderer_output_transport_terminal
+ && !append_context_created_event_source_hook_events(
scheduler,
+ receivers,
bidi,
&mut post_response_bidi_events,
)
- .await;
+ .await
+ {
+ let _ = send_bidi_json_events(socket, bidi_events).await;
+ let _ = send_bidi_json_events(socket, post_response_bidi_events).await;
+ return false;
}
if !send_bidi_json_events(socket, bidi_events).await {
return false;
@@ -1106,13 +1189,17 @@ async fn drain_and_send_bidi_navigation_after_response(
&background_navigation_sources,
event_context,
);
- if transport_is_live {
- append_context_created_event_source_hook_events(
+ if transport_is_live
+ && !append_context_created_event_source_hook_events(
scheduler,
+ receivers,
bidi,
&mut background_navigation_events,
)
- .await;
+ .await
+ {
+ let _ = send_bidi_json_events(socket, background_navigation_events).await;
+ return false;
}
if !send_bidi_json_events(socket, background_navigation_events).await {
return false;
@@ -1149,36 +1236,74 @@ fn bidi_command_channel_from_message(message: &serde_json::Value) -> Result<Opti
}
}
-async fn execute_bidi_event_source_hook_plan(
+async fn append_bidi_event_source_hook_plan_events(
scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
bidi: &mut BidiConnectionState,
plan: &BidiEventSourceHookPlan,
-) -> Vec<Value> {
- let mut events = Vec::new();
+ events: &mut Vec<Value>,
+) -> bool {
+ match try_append_bidi_event_source_hook_plan_events(scheduler, receivers, bidi, plan, events)
+ .await
+ {
+ Ok(()) => true,
+ Err(error) => {
+ warn!(
+ ?error,
+ "BiDi event-source owner turn lost its renderer transport"
+ );
+ false
+ }
+ }
+}
+
+async fn try_append_bidi_event_source_hook_plan_events(
+ scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
+ bidi: &mut BidiConnectionState,
+ plan: &BidiEventSourceHookPlan,
+ events: &mut Vec<Value>,
+) -> Result<(), DevToolsError> {
if let Some(contexts) = plan.runtime_contexts() {
if contexts.is_empty() {
- let runtime_enable_output = enable_bidi_runtime_protocol_sources(scheduler).await;
+ let runtime_enable_result =
+ enable_bidi_runtime_protocol_sources(scheduler, receivers).await;
+ let runtime_enable_output = materialize_bidi_event_source_hook_output(
+ scheduler,
+ bidi,
+ events,
+ runtime_enable_result,
+ None,
+ )?;
if !runtime_enable_output.is_empty() && plan.runtime_events_enabled() {
bidi.record_bidi_runtime_events_opened();
}
extend_bidi_events_from_protocol_output(
Some(&*scheduler),
bidi,
- &mut events,
+ events,
runtime_enable_output,
None,
);
} else {
for context in contexts {
- let runtime_enable_output =
- scheduler.enable_runtime_listener_for_target(context).await;
+ let runtime_enable_result = scheduler
+ .enable_runtime_listener_for_target(receivers, context)
+ .await;
+ let runtime_enable_output = materialize_bidi_event_source_hook_output(
+ scheduler,
+ bidi,
+ events,
+ runtime_enable_result,
+ Some(context),
+ )?;
if !runtime_enable_output.is_empty() && plan.records_runtime_context_ownership() {
bidi.record_bidi_runtime_event_source_opened(context);
}
extend_bidi_events_from_protocol_output(
Some(&*scheduler),
bidi,
- &mut events,
+ events,
runtime_enable_output,
Some(context),
);
@@ -1186,15 +1311,31 @@ async fn execute_bidi_event_source_hook_plan(
}
}
if plan.runtime_events_disabled() {
- let runtime_disable_output = disable_bidi_runtime_protocol_sources(scheduler).await;
+ let runtime_disable_result =
+ disable_bidi_runtime_protocol_sources(scheduler, receivers).await;
+ let runtime_disable_output = materialize_bidi_event_source_hook_output(
+ scheduler,
+ bidi,
+ events,
+ runtime_disable_result,
+ None,
+ )?;
if !runtime_disable_output.is_empty() {
bidi.record_bidi_runtime_events_closed();
}
}
if let Some(contexts) = plan.runtime_disabled_contexts() {
for context in contexts {
- let runtime_disable_output =
- scheduler.disable_runtime_listener_for_target(context).await;
+ let runtime_disable_result = scheduler
+ .disable_runtime_listener_for_target(receivers, context)
+ .await;
+ let runtime_disable_output = materialize_bidi_event_source_hook_output(
+ scheduler,
+ bidi,
+ events,
+ runtime_disable_result,
+ Some(context),
+ )?;
if !runtime_disable_output.is_empty() {
bidi.record_bidi_runtime_event_source_closed(context);
}
@@ -1202,11 +1343,19 @@ async fn execute_bidi_event_source_hook_plan(
}
if let Some(contexts) = plan.network_contexts() {
if contexts.is_empty() {
- let network_enable_output = enable_bidi_network_protocol_sources(scheduler).await;
+ let network_enable_result =
+ enable_bidi_network_protocol_sources(scheduler, receivers).await;
+ let network_enable_output = materialize_bidi_event_source_hook_output(
+ scheduler,
+ bidi,
+ events,
+ network_enable_result,
+ None,
+ )?;
extend_bidi_events_from_protocol_output(
Some(&*scheduler),
bidi,
- &mut events,
+ events,
network_enable_output,
None,
);
@@ -1245,12 +1394,36 @@ async fn execute_bidi_event_source_hook_plan(
if plan.download_events_disabled() && scheduler.disable_webdriver_bidi_download_events() {
bidi.record_bidi_download_event_source_closed();
}
- events
+ Ok(())
+}
+
+fn materialize_bidi_event_source_hook_output(
+ scheduler: &CdpScheduler,
+ bidi: &mut BidiConnectionState,
+ events: &mut Vec<Value>,
+ result: Result<ProtocolOutputSequence, RendererOutputTransportFailure>,
+ owner_context: Option<&str>,
+) -> Result<ProtocolOutputSequence, DevToolsError> {
+ match result {
+ Ok(output) => Ok(output),
+ Err(failure) => {
+ let (output, error) = failure.into_parts();
+ extend_bidi_events_from_protocol_output(
+ Some(scheduler),
+ bidi,
+ events,
+ output,
+ owner_context,
+ );
+ Err(error)
+ }
+ }
}
async fn send_bidi_protocol_output(
socket: &mut WebSocket,
- scheduler: Option<&mut CdpScheduler>,
+ scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
bidi: &mut BidiConnectionState,
output: ProtocolOutputSequence,
owner_context: Option<&str>,
@@ -1263,13 +1436,16 @@ async fn send_bidi_protocol_output(
let pending_response =
take_pending_navigation_response_from_sources(pending_navigation_response, &sources);
let mut events = subscribed_bidi_events_from_devtools_event_sources(
- scheduler.as_deref(),
+ Some(&*scheduler),
bidi,
&sources,
owner_context,
);
- if let Some(scheduler) = scheduler {
- append_context_created_event_source_hook_events(scheduler, bidi, &mut events).await;
+ if !append_context_created_event_source_hook_events(scheduler, receivers, bidi, &mut events)
+ .await
+ {
+ let _ = send_bidi_json_events(socket, events).await;
+ return false;
}
if !send_bidi_json_events(socket, events).await {
return false;
@@ -1287,11 +1463,12 @@ async fn send_bidi_protocol_output(
async fn append_context_created_event_source_hook_events(
scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
bidi: &mut BidiConnectionState,
events: &mut Vec<serde_json::Value>,
-) {
+) -> bool {
let plan = bidi.context_created_event_source_hook_plan(events);
- events.extend(execute_bidi_event_source_hook_plan(scheduler, bidi, &plan).await);
+ append_bidi_event_source_hook_plan_events(scheduler, receivers, bidi, &plan, events).await
}
struct BidiDevToolsCommandOutput {
@@ -1758,37 +1935,49 @@ fn bidi_protocol_message_owner_context(
async fn enable_bidi_runtime_protocol_sources(
scheduler: &mut CdpScheduler,
-) -> ProtocolOutputSequence {
+ receivers: &mut CdpSchedulerEventReceivers,
+) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
scheduler
- .execute_internal_protocol_message(json!({
- "id": 0_u64,
- "method": "Runtime.enable",
- "params": {}
- }))
+ .execute_internal_protocol_message(
+ receivers,
+ json!({
+ "id": 0_u64,
+ "method": "Runtime.enable",
+ "params": {}
+ }),
+ )
.await
}
async fn disable_bidi_runtime_protocol_sources(
scheduler: &mut CdpScheduler,
-) -> ProtocolOutputSequence {
+ receivers: &mut CdpSchedulerEventReceivers,
+) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
scheduler
- .execute_internal_protocol_message(json!({
- "id": 0_u64,
- "method": "Runtime.disable",
- "params": {}
- }))
+ .execute_internal_protocol_message(
+ receivers,
+ json!({
+ "id": 0_u64,
+ "method": "Runtime.disable",
+ "params": {}
+ }),
+ )
.await
}
async fn enable_bidi_network_protocol_sources(
scheduler: &mut CdpScheduler,
-) -> ProtocolOutputSequence {
+ receivers: &mut CdpSchedulerEventReceivers,
+) -> Result<ProtocolOutputSequence, RendererOutputTransportFailure> {
scheduler
- .execute_internal_protocol_message(json!({
- "id": 0_u64,
- "method": "Network.enable",
- "params": {}
- }))
+ .execute_internal_protocol_message(
+ receivers,
+ json!({
+ "id": 0_u64,
+ "method": "Network.enable",
+ "params": {}
+ }),
+ )
.await
}
diff --git a/moli/src/protocol_server/webdriver_classic/state.rs b/moli/src/protocol_server/webdriver_classic/state.rs
index fffeb2c2b..bafea6821 100644
--- a/moli/src/protocol_server/webdriver_classic/state.rs
+++ b/moli/src/protocol_server/webdriver_classic/state.rs
@@ -850,8 +850,12 @@ struct ClassicAttachedBidiSocket {
}
impl ClassicAttachedBidiSocket {
- async fn release_session(&mut self, scheduler: &mut CdpScheduler) {
- self.actor.release_event_sources(scheduler).await;
+ async fn release_session(
+ &mut self,
+ scheduler: &mut CdpScheduler,
+ receivers: &mut CdpSchedulerEventReceivers,
+ ) {
+ self.actor.release_event_sources(scheduler, receivers).await;
self.actor
.release_session(&mut self.session_registry.lock());
}
@@ -1317,13 +1321,17 @@ async fn classic_session_runtime_loop(
{
ClassicSessionRuntimeRequestOutcome::Continue => {}
ClassicSessionRuntimeRequestOutcome::AttachedBidi(mut duplicate) => {
- duplicate.release_session(&mut scheduler).await;
+ duplicate
+ .release_session(&mut scheduler, &mut receivers)
+ .await;
}
ClassicSessionRuntimeRequestOutcome::DetachBidi => {
detach_bidi = true;
}
ClassicSessionRuntimeRequestOutcome::Shutdown(cookies) => {
- attached.release_session(&mut scheduler).await;
+ attached
+ .release_session(&mut scheduler, &mut receivers)
+ .await;
shutdown_cookies = Some(cookies);
}
}
@@ -1334,7 +1342,9 @@ async fn classic_session_runtime_loop(
return cookies;
}
if detach_bidi && let Some(mut attached) = attached_bidi.take() {
- attached.release_session(&mut scheduler).await;
+ attached
+ .release_session(&mut scheduler, &mut receivers)
+ .await;
}
} else {
let page_javascript_blocked = scheduler.has_pending_javascript_dialog();