Function handle_socket_inner

packages/server/src/devtools.rs:1250–1314

(
    socket: WebSocket,
    target: ChromeDevToolsTargetRuntime,
    query: DevToolsQuery,
)

}

async fn handle_socket_inner(
    socket: WebSocket,
    target: ChromeDevToolsTargetRuntime,
    query: DevToolsQuery,
) -> Result<(), String> {
    let (mut writer, mut reader) = socket.split();
    let mut state = CdpState::default();

    while let Some(message) = reader.next().await {
        let text = match message {
            Ok(Message::Text(text)) => text.to_string(),
            Ok(Message::Binary(bytes)) => String::from_utf8(bytes.to_vec())
                .map_err(|error| format!("Invalid UTF-8 DevTools frame: {error}"))?,
            Ok(Message::Close(_)) => break,
            Ok(Message::Ping(_)) | Ok(Message::Pong(_)) => continue,
            Err(error) => return Err(format!("WebSocket client error: {error}")),
        };

        let request = serde_json::from_str::<Value>(&text)
            .map_err(|error| format!("Malformed DevTools JSON: {error}"))?;
        let id = request.get("id").cloned();
        let method = request
            .get("method")
            .and_then(Value::as_str)
            .unwrap_or_default()
            .to_owned();
        let params = request.get("params").cloned().unwrap_or(Value::Null);
        let outcome =
            match handle_cdp_method(&mut state, &target, query.clone(), &method, params).await {
                Ok(outcome) => outcome,
                Err(message) => {
                    let response = json!({
                        "id": id.unwrap_or(Value::Null),
                        "error": {
                            "code": -32000,
                            "message": message,
                        },
                    });
                    writer
                        .send(Message::Text(response.to_string().into()))
                        .await
                        .map_err(|error| format!("Unable to send DevTools response: {error}"))?;
                    continue;
                }
            };
        let response = json!({
            "id": id.unwrap_or(Value::Null),
            "result": outcome.result,
        });

        writer
            .send(Message::Text(response.to_string().into()))
            .await
            .map_err(|error| format!("Unable to send DevTools response: {error}"))?;

        for event in outcome.events {
            writer
                .send(Message::Text(event.to_string().into()))