Struct CDPClient 

pub struct CDPClient { /* private fields */ }

Core CDP client that manages WebSocket connection and message routing.

Concurrency model:

• Outgoing writes go through an unbounded mpsc channel feeding a dedicated writer task (spawn_writer_task). Many callers can send concurrently without contending on a lock.
• Incoming reads are dispatched by Connection::run calling handle_message, which only briefly holds a sync mutex on pending_responses, with no awaits while the lock is held.

Implementations

impl CDPClient

pub fn new(ws_url: String) -> Self

Create a new CDP client

pub fn set_writer(&self, tx: UnboundedSender<Message>)

Install the writer-task mailbox. Called once by Browser::connect_internal right after the writer task is spawned.

pub fn next_id(&self) -> u32

Generate the next message ID

pub async fn connect( &self, ) -> Result<WebSocketStream<MaybeTlsStream<TcpStream>>>

Connect to the Chrome DevTools Protocol WebSocket

pub fn send_raw(&self, msg: String) -> Result<()>

Send raw message through the writer task. Synchronous and (modulo one brief sync-mutex acquire) lock-free, because the mpsc channel fan-in is the contention point now, not a per-call lock.

pub fn subscribe_events(&self) -> Receiver<CDPMessage>

Subscribe to all CDP events (unfiltered broadcast receiver).

Callers are responsible for filtering by msg.method and msg.session_id as needed.

IMPORTANT: Subscribe before sending the CDP command that triggers the event to avoid the race where Chrome replies before the receiver is registered.

pub async fn send_command( &self, method: String, params: Option<Value>, ) -> Result<Value>

Send a command and wait for response with timeout.

The response handler is registered before the message is sent so that fast Chrome replies are never dropped.

pub async fn send_command_with_session( &self, session_id: &str, method: String, params: Option<Value>, ) -> Result<Value>

Send a command to a specific page session.

The response handler is registered before the message is sent.

pub fn register_response_handler(&self, id: u32, tx: Sender<Value>)

Register a pending response handler. Synchronous: the sync mutex only protects the HashMap insert.

pub fn fail_all_pending(&self, reason: &str)

Drop every pending response sender. Any send_command currently awaiting one of these will see its oneshot close immediately and return BrowserError::command_failed("…", "response channel closed…"), instead of waiting out the 30-second timeout. Call this when the underlying WebSocket dies.

pub fn handle_message(&self, msg: CDPMessage) -> Result<()>

Handle an incoming CDP message; called by Connection::run. Synchronous: no .await happens while the pending-responses mutex is held.