Add ArrayBuffer::set_detach_key (#1127)

This method, introduced in V8 10.9, makes it so an `ArrayBuffer`
object is impossible to detach unless a specific detach key is passed
to the `detach` method. Such `ArrayBuffer`s still count as detachable
as per the `ArrayBuffer::is_detachable` method, but otherwise behave
much like WebAssembly memories.

src/array_buffer.rs

@@ -41,6 +41,7 @@ extern "C" {
     this: *const ArrayBuffer,
     key: *const Value,
   ) -> MaybeBool;
+  fn v8__ArrayBuffer__SetDetachKey(this: *const ArrayBuffer, key: *const Value);
   fn v8__ArrayBuffer__Data(this: *const ArrayBuffer) -> *mut c_void;
   fn v8__ArrayBuffer__IsDetachable(this: *const ArrayBuffer) -> bool;
   fn v8__ArrayBuffer__WasDetached(this: *const ArrayBuffer) -> bool;
@@ -408,7 +409,7 @@ impl ArrayBuffer {
   /// Detaching sets the byte length of the buffer and all typed arrays to zero,
   /// preventing JavaScript from ever accessing underlying backing store.
   /// ArrayBuffer should have been externalized and must be detachable. Returns
-  /// `None` if the key didn't pass the [[ArrayBufferDetachKey]] check,
+  /// `None` if the key didn't pass the `[[ArrayBufferDetachKey]]` check,
   /// and `Some(true)` otherwise.
   #[inline(always)]
   pub fn detach(&self, key: Local<Value>) -> Option<bool> {
@@ -421,6 +422,12 @@ impl ArrayBuffer {
     }
   }
 
+  /// Sets the `[[ArrayBufferDetachKey]]`.
+  #[inline(always)]
+  pub fn set_detach_key(&self, key: Local<Value>) {
+    unsafe { v8__ArrayBuffer__SetDetachKey(self, &*key) };
+  }
+
   /// More efficient shortcut for GetBackingStore()->Data().
   /// The returned pointer is valid as long as the ArrayBuffer is alive.
   #[inline(always)]

src/binding.cc

@@ -835,6 +835,11 @@ bool v8__ArrayBuffer__WasDetached(const v8::ArrayBuffer& self) {
   return v8::Utils::OpenHandle(&self)->was_detached();
 }
 
+void v8__ArrayBuffer__SetDetachKey(const v8::ArrayBuffer& self,
+                                   const v8::Value* key) {
+  return ptr_to_local(&self)->SetDetachKey(ptr_to_local(key));
+}
+
 void* v8__BackingStore__Data(const v8::BackingStore& self) {
   return self.Data();
 }

tests/test_api.rs

@@ -8524,3 +8524,50 @@ fn test_fast_calls_callback_options_data() {
   eval(scope, source).unwrap();
   assert!(unsafe { DATA });
 }
+
+#[test]
+fn test_detach_key() {
+  let _setup_guard = setup();
+  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);
+
+  // Object detach key
+  {
+    let detach_key = eval(scope, "({})").unwrap();
+    assert!(detach_key.is_object());
+    let buffer = v8::ArrayBuffer::new(scope, 1024);
+    buffer.set_detach_key(detach_key);
+    assert!(buffer.is_detachable());
+    assert_eq!(buffer.detach(v8::undefined(scope).into()), None);
+    assert!(!buffer.was_detached());
+    assert_eq!(buffer.detach(detach_key), Some(true));
+    assert!(buffer.was_detached());
+  }
+
+  // External detach key
+  {
+    let mut rust_detach_key = Box::new(42usize);
+    let v8_detach_key = v8::External::new(
+      scope,
+      &mut *rust_detach_key as *mut usize as *mut c_void,
+    );
+    let buffer = v8::ArrayBuffer::new(scope, 1024);
+    buffer.set_detach_key(v8_detach_key.into());
+    assert!(buffer.is_detachable());
+    assert_eq!(buffer.detach(v8::undefined(scope).into()), None);
+    assert!(!buffer.was_detached());
+    assert_eq!(buffer.detach(v8_detach_key.into()), Some(true));
+    assert!(buffer.was_detached());
+  }
+
+  // Undefined detach key
+  {
+    let buffer = v8::ArrayBuffer::new(scope, 1024);
+    buffer.set_detach_key(v8::undefined(scope).into());
+    assert!(buffer.is_detachable());
+    assert_eq!(buffer.detach(v8::undefined(scope).into()), Some(true));
+    assert!(buffer.was_detached());
+  }
+}