Struct Channel 

pub struct Channel { /* private fields */ }

Channel provides RPC communication for a ChannelOwner.

Every ChannelOwner has a Channel that sends method calls to the Playwright server and receives responses.

Architecture

In the JavaScript implementation, Channel is a Proxy object that intercepts method calls and forwards them to the connection.

In Python, Channel is a class with explicit method forwarding.

In Rust, we provide an explicit send method that handles:

• Serialization of parameters
• Sending to connection with object’s GUID
• Waiting for response
• Deserialization of result

Example

// Example of using Channel to send RPC calls
use playwright_core::channel::Channel;
use serde::{Serialize, Deserialize};

#[derive(Serialize)]
struct LaunchParams {
    headless: bool,
}

#[derive(Deserialize)]
struct LaunchResult {
    browser: BrowserRef,
}

// Protocol response references use Arc<str> for performance
#[derive(Deserialize)]
struct BrowserRef {
    guid: String, // Simplified for example; actual implementation uses Arc<str>
}

async fn example(channel: &Channel) -> Result<(), Box<dyn std::error::Error>> {
    let params = LaunchParams { headless: true };
    let result: LaunchResult = channel.send("launch", params).await?;
    println!("Browser GUID: {}", result.browser.guid);
    Ok(())
}

Implementations

impl Channel

pub fn new(guid: Arc<str>, connection: Arc<dyn ConnectionLike>) -> Self

Creates a new Channel for the given object GUID.

Arguments

• guid - The GUID of the ChannelOwner this channel represents
• connection - The connection to send messages through

pub async fn send<P: Serialize, R: DeserializeOwned>( &self, method: &str, params: P, ) -> Result<R>

Sends a method call to the Playwright server and awaits the response.

This method:

1. Serializes params to JSON
2. Sends a JSON-RPC request to the server via the connection
3. Waits for the response (correlated by request ID)
4. Deserializes the response to type R
5. Returns the result or an error

Type Parameters

• P - Parameter type (must be serializable)
• R - Result type (must be deserializable)

Arguments

• method - The method name to call (e.g., “launch”, “goto”)
• params - The parameters to send

Example

#[derive(Serialize)]
struct GotoParams<'a> {
    url: &'a str,
}

#[derive(Deserialize)]
struct GotoResult {}

let params = GotoParams { url: "https://example.com" };
let _result: GotoResult = channel.send("goto", params).await?;

pub async fn send_no_params<R: DeserializeOwned>( &self, method: &str, ) -> Result<R>

Sends a method call with no parameters.

Convenience method for calls that don’t need parameters.

pub async fn send_no_result<P: Serialize>( &self, method: &str, params: P, ) -> Result<()>

Sends a method call that returns no result (void).

Convenience method for fire-and-forget calls.

pub fn guid(&self) -> &str

Returns the GUID this channel represents.

Trait Implementations

impl Clone for Channel

fn clone(&self) -> Channel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.