feat: Support custom host objects in ValueSerializer (#1322)

Add v8::ValueSerializerImpl::{has_custom_host_object,is_host_object} 
equivalents for v8::ValueSerializer::Delegate::{HasCustomHostObject,IsCustomHostObject}.

This enables serializing custom host objects without embedder fields.

src/binding.cc

@@ -3197,6 +3197,13 @@ extern "C" {
 void v8__ValueSerializer__Delegate__ThrowDataCloneError(
  v8::ValueSerializer::Delegate* self, v8::Local<v8::String> message);
 
+bool v8__ValueSerializer__Delegate__HasCustomHostObject(
+ v8::ValueSerializer::Delegate* self, v8::Isolate* isolate);
+
+MaybeBool v8__ValueSerializer__Delegate__IsHostObject(
+ v8::ValueSerializer::Delegate* self, v8::Isolate* isolate,
+ v8::Local<v8::Object> object);
+
 MaybeBool v8__ValueSerializer__Delegate__WriteHostObject(
  v8::ValueSerializer::Delegate* self, v8::Isolate* isolate,
  v8::Local<v8::Object> object);
@@ -3222,6 +3229,16 @@ struct v8__ValueSerializer__Delegate : public v8::ValueSerializer::Delegate {
  v8__ValueSerializer__Delegate__ThrowDataCloneError(this, message);
  }
 
+ bool HasCustomHostObject(v8::Isolate* isolate) override {
+ return v8__ValueSerializer__Delegate__HasCustomHostObject(this, isolate);
+ }
+
+ v8::Maybe<bool> IsHostObject(v8::Isolate* isolate,
+ v8::Local<v8::Object> object) override {
+ return maybe_bool_to_maybe(
+ v8__ValueSerializer__Delegate__IsHostObject(this, isolate, object));
+ }
+
  v8::Maybe<bool> WriteHostObject(v8::Isolate* isolate,
  v8::Local<v8::Object> object) override {
  return maybe_bool_to_maybe(

src/value_serializer.rs

@@ -45,6 +45,32 @@ pub unsafe extern "C" fn v8__ValueSerializer__Delegate__ThrowDataCloneError(
  .throw_data_clone_error(scope, message)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn v8__ValueSerializer__Delegate__HasCustomHostObject(
+ this: &mut CxxValueSerializerDelegate,
+ isolate: *mut Isolate,
+) -> bool {
+ let value_serializer_heap = ValueSerializerHeap::dispatch_mut(this);
+ value_serializer_heap
+ .value_serializer_impl
+ .as_mut()
+ .has_custom_host_object(&mut *isolate)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn v8__ValueSerializer__Delegate__IsHostObject(
+ this: &mut CxxValueSerializerDelegate,
+ _isolate: *mut Isolate,
+ object: Local<Object>,
+) -> MaybeBool {
+ let value_serializer_heap = ValueSerializerHeap::dispatch_mut(this);
+ let scope =
+ &mut crate::scope::CallbackScope::new(value_serializer_heap.context);
+ let value_serializer_impl =
+ value_serializer_heap.value_serializer_impl.as_mut();
+ MaybeBool::from(value_serializer_impl.is_host_object(scope, object))
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn v8__ValueSerializer__Delegate__WriteHostObject(
  this: &mut CxxValueSerializerDelegate,
@@ -211,6 +237,23 @@ pub trait ValueSerializerImpl {
  message: Local<'s, String>,
  );
 
+ fn has_custom_host_object(&mut self, _isolate: &mut Isolate) -> bool {
+ false
+ }
+
+ fn is_host_object<'s>(
+ &mut self,
+ scope: &mut HandleScope<'s>,
+ _object: Local<'s, Object>,
+ ) -> Option<bool> {
+ let msg =
+ String::new(scope, "Deno serializer: is_host_object not implemented")
+ .unwrap();
+ let exc = Exception::error(scope, msg);
+ scope.throw_exception(exc);
+ None
+ }
+
  fn write_host_object<'s>(
  &mut self,
  scope: &mut HandleScope<'s>,

tests/test_api.rs

@@ -7731,12 +7731,18 @@ impl<'a> v8::ValueSerializerImpl for Custom1Value<'a> {
 
  fn write_host_object<'s>(
  &mut self,
- _scope: &mut v8::HandleScope<'s>,
- _object: v8::Local<'s, v8::Object>,
+ scope: &mut v8::HandleScope<'s>,
+ object: v8::Local<'s, v8::Object>,
  value_serializer: &mut dyn v8::ValueSerializerHelper,
  ) -> Option<bool> {
- value_serializer.write_uint64(1);
- None
+ let key = v8::String::new(scope, "hostObject").unwrap();
+ let value = object
+ .get(scope, key.into())
+ .unwrap()
+ .uint32_value(scope)
+ .unwrap();
+ value_serializer.write_uint32(value);
+ Some(true)
  }
 }
 
@@ -7756,12 +7762,18 @@ impl<'a> v8::ValueDeserializerImpl for Custom1Value<'a> {
 
  fn read_host_object<'s>(
  &mut self,
- _scope: &mut v8::HandleScope<'s>,
+ scope: &mut v8::HandleScope<'s>,
  value_deserializer: &mut dyn v8::ValueDeserializerHelper,
  ) -> Option<v8::Local<'s, v8::Object>> {
  let mut value = 0;
- value_deserializer.read_uint64(&mut value);
- None
+ value_deserializer.read_uint32(&mut value);
+ let template = v8::ObjectTemplate::new(scope);
+ template.set_internal_field_count(1);
+ let host_object = template.new_instance(scope).unwrap();
+ let key = v8::String::new(scope, "readHostObject").unwrap();
+ let value = v8::Integer::new_from_unsigned(scope, value);
+ host_object.set(scope, key.into(), value.into());
+ Some(host_object)
  }
 }
 
@@ -7985,6 +7997,64 @@ fn value_serializer_and_deserializer_array_buffers() {
  }
 }
 
+#[test]
+fn value_serializer_and_deserializer_embedder_host_object() {
+ let buffer;
+ let expected: u32 = 123;
+ let mut array_buffers = ArrayBuffers::new();
+ {
+ let _setup_guard = setup::parallel_test();
+ let isolate = &mut v8::Isolate::new(Default::default());
+
+ let scope = &mut v8::HandleScope::new(isolate);
+
+ let context = v8::Context::new(scope);
+ let scope = &mut v8::ContextScope::new(scope, context);
+
+ let template = v8::ObjectTemplate::new(scope);
+ template.set_internal_field_count(1);
+ let host_object = template.new_instance(scope).unwrap();
+ let key = v8::String::new(scope, "hostObject").unwrap();
+ let value = v8::Integer::new_from_unsigned(scope, expected);
+ host_object.set(scope, key.into(), value.into());
+
+ let mut value_serializer =
+ Custom1Value::serializer(scope, &mut array_buffers);
+ assert_eq!(
+ value_serializer.write_value(context, host_object.into()),
+ Some(true)
+ );
+
+ buffer = value_serializer.release();
+ }
+
+ {
+ let _setup_guard = setup::parallel_test();
+ let isolate = &mut v8::Isolate::new(Default::default());
+
+ let scope = &mut v8::HandleScope::new(isolate);
+
+ let context = v8::Context::new(scope);
+ let scope = &mut v8::ContextScope::new(scope, context);
+
+ let mut value_deserializer =
+ Custom1Value::deserializer(scope, &buffer, &mut array_buffers);
+ let host_object_out = value_deserializer
+ .read_value(context)
+ .unwrap()
+ .to_object(scope)
+ .unwrap();
+ drop(value_deserializer);
+ let key = v8::String::new(scope, "readHostObject").unwrap();
+ let value = host_object_out
+ .get(scope, key.into())
+ .unwrap()
+ .uint32_value(scope)
+ .unwrap();
+ assert_eq!(value, expected);
+ }
+}
+
 struct Custom2Value {}
 
 impl<'a> Custom2Value {
@@ -8044,6 +8114,135 @@ fn value_serializer_not_implemented() {
  );
 }
 
+struct Custom3Value {}
+
+impl<'a> Custom3Value {
+ fn serializer<'s>(
+ scope: &mut v8::HandleScope<'s>,
+ ) -> v8::ValueSerializer<'a, 's> {
+ v8::ValueSerializer::new(scope, Box::new(Self {}))
+ }
+
+ fn deserializer<'s>(
+ scope: &mut v8::HandleScope<'s>,
+ data: &[u8],
+ ) -> v8::ValueDeserializer<'a, 's> {
+ v8::ValueDeserializer::new(scope, Box::new(Self {}), data)
+ }
+}
+
+impl v8::ValueSerializerImpl for Custom3Value {
+ #[allow(unused_variables)]
+ fn throw_data_clone_error<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ message: v8::Local<'s, v8::String>,
+ ) {
+ let error = v8::Exception::error(scope, message);
+ scope.throw_exception(error);
+ }
+
+ fn has_custom_host_object(&mut self, _isolate: &mut v8::Isolate) -> bool {
+ true
+ }
+
+ fn is_host_object<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ object: v8::Local<'s, v8::Object>,
+ ) -> Option<bool> {
+ let key = v8::String::new(scope, "hostObject").unwrap();
+ object.has_own_property(scope, key.into())
+ }
+
+ fn write_host_object<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ object: v8::Local<'s, v8::Object>,
+ value_serializer: &mut dyn v8::ValueSerializerHelper,
+ ) -> Option<bool> {
+ let key = v8::String::new(scope, "hostObject").unwrap();
+ let value = object
+ .get(scope, key.into())
+ .unwrap()
+ .uint32_value(scope)
+ .unwrap();
+ value_serializer.write_uint32(value);
+ Some(true)
+ }
+}
+
+impl v8::ValueDeserializerImpl for Custom3Value {
+ fn read_host_object<'s>(
+ &mut self,
+ scope: &mut v8::HandleScope<'s>,
+ value_deserializer: &mut dyn v8::ValueDeserializerHelper,
+ ) -> Option<v8::Local<'s, v8::Object>> {
+ let mut value = 0;
+ value_deserializer.read_uint32(&mut value);
+ let host_object = v8::Object::new(scope);
+ let key = v8::String::new(scope, "readHostObject").unwrap();
+ let value = v8::Integer::new_from_unsigned(scope, value);
+ host_object.set(scope, key.into(), value.into());
+ Some(host_object)
+ }
+}
+
+#[test]
+fn value_serializer_and_deserializer_custom_host_object() {
+ let buffer;
+ let expected: u32 = 123;
+ {
+ let _setup_guard = setup::parallel_test();
+ let isolate = &mut v8::Isolate::new(Default::default());
+
+ let scope = &mut v8::HandleScope::new(isolate);
+
+ let context = v8::Context::new(scope);
+ let scope = &mut v8::ContextScope::new(scope, context);
+
+ let host_object = v8::Object::new(scope);
+ let key = v8::String::new(scope, "hostObject").unwrap();
+ let value = v8::Integer::new_from_unsigned(scope, expected);
+ host_object.set(scope, key.into(), value.into());
+
+ let mut value_serializer = Custom3Value::serializer(scope);
+ assert_eq!(
+ value_serializer.write_value(context, host_object.into()),
+ Some(true)
+ );
+
+ buffer = value_serializer.release();
+ }
+
+ {
+ let _setup_guard = setup::parallel_test();
+ let isolate = &mut v8::Isolate::new(Default::default());
+
+ let scope = &mut v8::HandleScope::new(isolate);
+
+ let context = v8::Context::new(scope);
+ let scope = &mut v8::ContextScope::new(scope, context);
+
+ let mut value_deserializer = Custom3Value::deserializer(scope, &buffer);
+ let host_object_out = value_deserializer
+ .read_value(context)
+ .unwrap()
+ .to_object(scope)
+ .unwrap();
+ drop(value_deserializer);
+ let key = v8::String::new(scope, "readHostObject").unwrap();
+ let has_prop = host_object_out.has_own_property(scope, key.into()).unwrap();
+ assert!(has_prop);
+ let value = host_object_out
+ .get(scope, key.into())
+ .unwrap()
+ .uint32_value(scope)
+ .unwrap();
+ assert_eq!(value, expected);
+ }
+}
+
 #[test]
 fn memory_pressure_notification() {
  let _setup_guard = setup::parallel_test();