feat: add create_response, create_notification, and DomainDispatcher bindings

bartlomieju · claude · bartlomieju · commit f53d5ef2decc · 2026-03-07T16:14:34.000+01:00
- Add Rust wrappers for crdtp::CreateResponse and crdtp::CreateNotification
- Add DomainDispatcher C++/Rust bindings allowing Rust code to implement
  domain-specific protocol handlers and wire them to UberDispatcher
- Apply reviewer feedback: replace std::string_view with const String&amp; in
  string_util.h/cc for consistency with protocol type aliases

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/crdtp.rs b/src/crdtp.rs
@@ -3,6 +3,7 @@
 use crate::support::CxxVTable;
 use crate::support::Opaque;
 use std::cell::UnsafeCell;
+use std::ffi::CString;
 use std::mem::MaybeUninit;
 use std::pin::Pin;
 
@@ -124,12 +125,29 @@ unsafe extern "C" {
     params: *mut RawSerializable,
   ) -> *mut RawSerializable;
   fn crdtp__CreateNotification(
-    method: *const u8,
+    method: *const std::ffi::c_char,
     params: *mut RawSerializable,
   ) -> *mut RawSerializable;
   fn crdtp__CreateErrorNotification(
     response: *mut DispatchResponseWrapper,
   ) -> *mut RawSerializable;
+
+  fn crdtp__DomainDispatcher__new(
+    channel: *mut RawFrontendChannel,
+    rust_dispatcher: *mut std::ffi::c_void,
+  ) -> *mut RawDomainDispatcher;
+  fn crdtp__DomainDispatcher__sendResponse(
+    this: *mut RawDomainDispatcher,
+    call_id: i32,
+    response: *mut DispatchResponseWrapper,
+    result: *mut RawSerializable,
+  );
+  fn crdtp__UberDispatcher__WireBackend(
+    uber: *mut UberDispatcher,
+    domain_data: *const u8,
+    domain_len: usize,
+    dispatcher: *mut RawDomainDispatcher,
+  );
 }
 
 #[repr(C)]
@@ -150,6 +168,9 @@ struct CppVecU8(Opaque);
 #[repr(C)]
 struct RawSerializable(Opaque);
 
+#[repr(C)]
+struct RawDomainDispatcher(Opaque);
+
 pub struct Serializable {
   ptr: *mut RawSerializable,
 }
@@ -582,3 +603,152 @@ pub fn create_error_notification(response: DispatchResponse) -> Serializable {
     Serializable { ptr }
   }
 }
+
+/// Create a success response message with optional result params.
+pub fn create_response(
+  call_id: i32,
+  params: Option<Serializable>,
+) -> Serializable {
+  unsafe {
+    let params_ptr = match params {
+      Some(p) => p.into_raw(),
+      None => std::ptr::null_mut(),
+    };
+    let ptr = crdtp__CreateResponse(call_id, params_ptr);
+    Serializable { ptr }
+  }
+}
+
+/// Create a notification message with a method name and optional params.
+pub fn create_notification(
+  method: &str,
+  params: Option<Serializable>,
+) -> Serializable {
+  unsafe {
+    let method_cstr =
+      CString::new(method).expect("method name must not contain null bytes");
+    let params_ptr = match params {
+      Some(p) => p.into_raw(),
+      None => std::ptr::null_mut(),
+    };
+    let ptr = crdtp__CreateNotification(method_cstr.as_ptr(), params_ptr);
+    Serializable { ptr }
+  }
+}
+
+/// Trait for implementing a domain-specific protocol dispatcher.
+///
+/// The `dispatch` method is called in two phases:
+/// 1. **Probe phase** (`dispatchable` is `None`): Return `true` if this
+///    domain handles the given command name.
+/// 2. **Execute phase** (`dispatchable` is `Some`): Handle the command
+///    and send a response via the `DomainDispatcherHandle`.
+pub trait DomainDispatcherImpl {
+  fn dispatch(
+    &mut self,
+    command: &[u8],
+    dispatchable: Option<&Dispatchable>,
+    handle: &DomainDispatcherHandle,
+  ) -> bool;
+}
+
+/// Handle to the C++ DomainDispatcher, used to send responses.
+pub struct DomainDispatcherHandle {
+  ptr: *mut RawDomainDispatcher,
+}
+
+impl DomainDispatcherHandle {
+  /// Send a response for a dispatched command.
+  pub fn send_response(
+    &self,
+    call_id: i32,
+    response: DispatchResponse,
+    result: Option<Serializable>,
+  ) {
+    unsafe {
+      let result_ptr = match result {
+        Some(r) => r.into_raw(),
+        None => std::ptr::null_mut(),
+      };
+      crdtp__DomainDispatcher__sendResponse(
+        self.ptr,
+        call_id,
+        response.into_raw(),
+        result_ptr,
+      );
+    }
+  }
+}
+
+/// A domain dispatcher that delegates to a Rust `DomainDispatcherImpl`.
+pub struct DomainDispatcher {
+  ptr: *mut RawDomainDispatcher,
+  _imp: Box<dyn DomainDispatcherImpl>,
+}
+
+impl DomainDispatcher {
+  /// Create a new DomainDispatcher for the given domain, backed by a Rust
+  /// implementation. The dispatcher is immediately wired to the
+  /// UberDispatcher.
+  pub fn wire(
+    uber: &mut UberDispatcher,
+    domain: &str,
+    imp: Box<dyn DomainDispatcherImpl>,
+  ) {
+    let mut dd = Box::new(DomainDispatcher {
+      ptr: std::ptr::null_mut(),
+      _imp: imp,
+    });
+
+    // The domain name must outlive the UberDispatcher since it's stored
+    // as a span (pointer + length) internally. We leak it to ensure this.
+    let domain_bytes = domain.as_bytes().to_vec().leak();
+
+    unsafe {
+      let rust_ptr = &mut *dd as *mut DomainDispatcher as *mut std::ffi::c_void;
+      let channel = crdtp__UberDispatcher__channel(uber);
+      let raw = crdtp__DomainDispatcher__new(channel, rust_ptr);
+      dd.ptr = raw;
+
+      crdtp__UberDispatcher__WireBackend(
+        uber,
+        domain_bytes.as_ptr(),
+        domain_bytes.len(),
+        raw,
+      );
+    }
+
+    // Leak the DomainDispatcher - it's now owned by the UberDispatcher via
+    // the C++ side. The UberDispatcher will destroy the C++ DomainDispatcher
+    // when it's dropped, but we need the Rust side to live as long.
+    // We store it as a leaked Box; the UberDispatcher's drop will handle
+    // the C++ side.
+    Box::leak(dd);
+  }
+
+  unsafe fn from_raw<'a>(
+    ptr: *mut std::ffi::c_void,
+  ) -> &'a mut DomainDispatcher {
+    &mut *(ptr as *mut DomainDispatcher)
+  }
+}
+
+#[unsafe(no_mangle)]
+unsafe extern "C" fn crdtp__DomainDispatcher__BASE__Dispatch(
+  rust_dispatcher: *mut std::ffi::c_void,
+  command_data: *const u8,
+  command_len: usize,
+  dispatchable: *const Dispatchable,
+) -> bool {
+  unsafe {
+    let dd = DomainDispatcher::from_raw(rust_dispatcher);
+    let command = std::slice::from_raw_parts(command_data, command_len);
+    let handle = DomainDispatcherHandle { ptr: dd.ptr };
+    let dispatchable_ref = if dispatchable.is_null() {
+      None
+    } else {
+      Some(&*dispatchable)
+    };
+    dd._imp.dispatch(command, dispatchable_ref, &handle)
+  }
+}
diff --git a/src/crdtp_binding.cc b/src/crdtp_binding.cc
@@ -291,3 +291,69 @@ Serializable* crdtp__CreateErrorNotification(
 }
 
 }  // extern "C"
+
+// DomainDispatcher binding - allows Rust to implement domain dispatchers.
+
+extern "C" {
+// Rust callback: given a domain dispatcher pointer and a command name,
+// returns a bool indicating if the command was found. If found, the
+// dispatcher should handle the dispatchable when
+// crdtp__DomainDispatcher__BASE__Run is called.
+bool crdtp__DomainDispatcher__BASE__Dispatch(void* rust_dispatcher,
+                                             const uint8_t* command_data,
+                                             size_t command_len,
+                                             const Dispatchable* dispatchable);
+}
+
+struct crdtp__DomainDispatcher__BASE : public DomainDispatcher {
+  void* rust_dispatcher_;
+
+  crdtp__DomainDispatcher__BASE(FrontendChannel* channel, void* rust_dispatcher)
+      : DomainDispatcher(channel), rust_dispatcher_(rust_dispatcher) {}
+
+  std::function<void(const Dispatchable&)> Dispatch(
+      span<uint8_t> command_name) override {
+    // We need to probe whether the Rust side handles this command.
+    // We pass a nullptr dispatchable for the probe phase.
+    bool found = crdtp__DomainDispatcher__BASE__Dispatch(
+        rust_dispatcher_, command_name.data(), command_name.size(), nullptr);
+    if (!found) {
+      return nullptr;
+    }
+    // Return a closure that will call the Rust side with the actual
+    // dispatchable.
+    return [this, command_name](const Dispatchable& dispatchable) {
+      crdtp__DomainDispatcher__BASE__Dispatch(
+          rust_dispatcher_, command_name.data(), command_name.size(),
+          &dispatchable);
+    };
+  }
+};
+
+extern "C" {
+
+crdtp__DomainDispatcher__BASE* crdtp__DomainDispatcher__new(
+    FrontendChannel* channel, void* rust_dispatcher) {
+  return new crdtp__DomainDispatcher__BASE(channel, rust_dispatcher);
+}
+
+void crdtp__DomainDispatcher__sendResponse(crdtp__DomainDispatcher__BASE* self,
+                                           int call_id,
+                                           DispatchResponseWrapper* response,
+                                           Serializable* result) {
+  std::unique_ptr<Serializable> result_ptr(result);
+  self->sendResponse(call_id, std::move(response->inner),
+                     std::move(result_ptr));
+  delete response;
+}
+
+void crdtp__UberDispatcher__WireBackend(
+    UberDispatcher* uber, const uint8_t* domain_data, size_t domain_len,
+    crdtp__DomainDispatcher__BASE* dispatcher) {
+  std::unique_ptr<DomainDispatcher> dispatcher_ptr(dispatcher);
+  uber->WireBackend(span<uint8_t>(domain_data, domain_len),
+                    std::vector<std::pair<span<uint8_t>, span<uint8_t>>>(),
+                    std::move(dispatcher_ptr));
+}
+
+}  // extern "C"
diff --git a/src/deno_inspector/string_util.cc b/src/deno_inspector/string_util.cc
@@ -1,6 +1,7 @@
 // String utilities for Deno inspector protocol
 
 #include "src/deno_inspector/string_util.h"
+
 #include "v8/third_party/inspector_protocol/crdtp/json.h"
 
 namespace v8_crdtp {
@@ -35,7 +36,7 @@ bool ProtocolTypeTraits<deno_inspector::protocol::Binary>::Deserialize(
   }
   span<uint8_t> cbor_span = state->tokenizer()->GetBinary();
   *value = deno_inspector::protocol::Binary::fromSpan(cbor_span.data(),
-                                                       cbor_span.size());
+                                                      cbor_span.size());
   return true;
 }
 
@@ -101,13 +102,11 @@ String StringUtil::fromUTF16LE(const uint16_t* data, size_t length) {
   return fromUTF16(data, length);  // Assuming host is little-endian
 }
 
-const uint8_t* StringUtil::CharactersUTF8(const std::string_view s) {
+const uint8_t* StringUtil::CharactersUTF8(const String& s) {
   return reinterpret_cast<const uint8_t*>(s.data());
 }
 
-size_t StringUtil::CharacterCount(const std::string_view s) {
-  return s.length();
-}
+size_t StringUtil::CharacterCount(const String& s) { return s.length(); }
 
 // Base64 encoding table
 static const char kBase64Chars[] =
@@ -148,22 +147,24 @@ Binary Binary::concat(const std::vector<Binary>& binaries) {
 
 // Base64 decoding table
 static const uint8_t kBase64DecodeTable[256] = {
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,  62, 255, 255, 255,  63,
-     52,  53,  54,  55,  56,  57,  58,  59,  60,  61, 255, 255, 255, 255, 255, 255,
-    255,   0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
-     15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25, 255, 255, 255, 255, 255,
-    255,  26,  27,  28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,
-     41,  42,  43,  44,  45,  46,  47,  48,  49,  50,  51, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62,  255,
+    255, 255, 63,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  255, 255,
+    255, 255, 255, 255, 255, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,
+    10,  11,  12,  13,  14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+    25,  255, 255, 255, 255, 255, 255, 26,  27,  28,  29,  30,  31,  32,  33,
+    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+    49,  50,  51,  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    255,
 };
 
 Binary Binary::fromBase64(const String& base64, bool* success) {
diff --git a/src/deno_inspector/string_util.h b/src/deno_inspector/string_util.h
@@ -4,13 +4,14 @@
 
 #include <cassert>
 #include <cstring>
+#include <memory>
 #include <sstream>
 #include <string>
-#include <memory>
 #include <vector>
+
+#include "v8-inspector.h"
 #include "v8/third_party/inspector_protocol/crdtp/protocol_core.h"
 #include "v8/third_party/inspector_protocol/crdtp/span.h"
-#include "v8-inspector.h"
 
 // Provide DCHECK macros that the generated protocol code expects
 #ifndef DCHECK
@@ -56,13 +57,11 @@ struct StringUtil {
   static String fromUTF16(const uint16_t* data, size_t length);
   static String fromUTF8(const uint8_t* data, size_t length);
   static String fromUTF16LE(const uint16_t* data, size_t length);
-  static const uint8_t* CharactersUTF8(const std::string_view s);
-  static size_t CharacterCount(const std::string_view s);
+  static const uint8_t* CharactersUTF8(const String& s);
+  static size_t CharacterCount(const String& s);
 
-  inline static uint8_t* CharactersLatin1(const std::string_view s) {
-    return nullptr;
-  }
-  inline static const uint16_t* CharactersUTF16(const std::string_view s) {
+  inline static uint8_t* CharactersLatin1(const String& s) { return nullptr; }
+  inline static const uint16_t* CharactersUTF16(const String& s) {
     return nullptr;
   }
 };
@@ -80,8 +79,7 @@ class Binary {
   static Binary concat(const std::vector<Binary>& binaries);
   static Binary fromBase64(const String& base64, bool* success);
   static Binary fromSpan(const uint8_t* data, size_t size) {
-    return Binary(
-        std::make_shared<std::vector<uint8_t>>(data, data + size));
+    return Binary(std::make_shared<std::vector<uint8_t>>(data, data + size));
   }
   // Overload for v8_crdtp::span used by generated protocol code
   static Binary fromSpan(v8_crdtp::span<uint8_t> bytes) {
diff --git a/tests/test_api.rs b/tests/test_api.rs
