Add ArrayBuffer::detached method

Summary:
X-link: facebook/react-native#55944

Add a `ArrayBuffer::detached` method that returns true if the
ArrayBuffer is detached, false otherwise.

Default implementation just checks for the `detached` property

Changelog: [Internal]

Reviewed By: lavenzg

Differential Revision: D92993088

fbshipit-source-id: 77d7055ddc35c21e915915daa2415b44017f81bb

Author: tsaichien

API/jsi/jsi/decorator.h

@@ -392,6 +392,9 @@ class RuntimeDecorator : public Base, private jsi::Instrumentation {
   uint8_t* data(const ArrayBuffer& ab) override {
     return plain_.data(ab);
   }
+  bool detached(const ArrayBuffer& ab) override {
+    return plain_.detached(ab);
+  }
   Value getValueAtIndex(const Array& a, size_t i) override {
     return plain_.getValueAtIndex(a, i);
   }
@@ -969,6 +972,10 @@ class WithRuntimeDecorator : public RuntimeDecorator<Plain, Base> {
     Around around{with_};
     return RD::data(ab);
   }
+  bool detached(const ArrayBuffer& ab) override {
+    Around around{with_};
+    return RD::detached(ab);
+  }
   Value getValueAtIndex(const Array& a, size_t i) override {
     Around around{with_};
     return RD::getValueAtIndex(a, i);

API/jsi/jsi/jsi.cpp

@@ -557,6 +557,15 @@ std::shared_ptr<MutableBuffer> Runtime::tryGetMutableBuffer(
   return nullptr;
 }
 
+bool Runtime::detached(const ArrayBuffer& buffer) {
+  Value prop = buffer.getProperty(*this, "detached");
+  if (!prop.isBool()) {
+    throw JSINativeException(
+        "ArrayBuffer.detached is not supported by this runtime");
+  }
+  return prop.getBool();
+}
+
 Pointer& Pointer::operator=(Pointer&& other) noexcept {
   if (ptr_) {
     ptr_->invalidate();

API/jsi/jsi/jsi.h

@@ -563,6 +563,7 @@ class JSI_EXPORT IRuntime : public ICast {
   virtual size_t size(const Array&) = 0;
   virtual size_t size(const ArrayBuffer&) = 0;
   virtual uint8_t* data(const ArrayBuffer&) = 0;
+  virtual bool detached(const ArrayBuffer&) = 0;
   virtual Value getValueAtIndex(const Array&, size_t i) = 0;
   virtual void
   setValueAtIndexImpl(const Array&, size_t i, const Value& value) = 0;
@@ -724,6 +725,8 @@ class JSI_EXPORT Runtime : public IRuntime {
   std::shared_ptr<MutableBuffer> tryGetMutableBuffer(
       const jsi::ArrayBuffer& arrayBuffer) override;
 
+  bool detached(const ArrayBuffer&) override;
+
  protected:
   friend class Pointer;
   friend class PropNameID;
@@ -1471,6 +1474,11 @@ class JSI_EXPORT ArrayBuffer : public Object {
     return runtime.tryGetMutableBuffer(*this);
   }
 
+  /// \return true if the ArrayBuffer is detached, false otherwise.
+  bool detached(IRuntime& runtime) const {
+    return runtime.detached(*this);
+  }
+
  private:
   friend class Object;
   friend class Value;

API/jsi/jsi/test/testlib.cpp

@@ -2121,6 +2121,46 @@ TEST_P(JSITest, ArrayPush) {
   EXPECT_TRUE(arr.getValueAtIndex(rd, 3).isUndefined());
 }
 
+TEST_P(JSITest, ArrayBufferDetachedTest) {
+  // This Runtime Decorator is used to test the default implementation of
+  // Runtime::detached
+  class RD : public RuntimeDecorator<Runtime, Runtime> {
+   public:
+    explicit RD(Runtime& rt) : RuntimeDecorator(rt) {}
+
+    bool detached(const ArrayBuffer& ab) override {
+      return Runtime::detached(ab);
+    }
+  };
+  RD rd = RD(rt);
+
+  // Test that a normal ArrayBuffer is not detached.
+  auto ab = eval("var buf = new ArrayBuffer(10); buf")
+                .getObject(rd)
+                .getArrayBuffer(rd);
+
+  // The default Runtime::detached reads the JS "detached" property. If the
+  // runtime doesn't support ArrayBuffer.prototype.detached, it will throw
+  // JSINativeException.
+  try {
+    EXPECT_FALSE(ab.detached(rd));
+  } catch (const JSINativeException&) {
+    // Runtime doesn't support ArrayBuffer.prototype.detached, skip the rest.
+    return;
+  }
+
+  // Detach the ArrayBuffer. Use transfer() if available, otherwise fall back
+  // to HermesInternal.detach for Hermes runtime.
+  eval(
+      "if (typeof buf.transfer === 'function') {"
+      "  buf.transfer();"
+      "} else if (typeof HermesInternal !== 'undefined' && "
+      "           typeof HermesInternal.detachArrayBuffer === 'function') {"
+      "  HermesInternal.detachArrayBuffer(buf);"
+      "}");
+  EXPECT_TRUE(ab.detached(rd));
+}
+
 INSTANTIATE_TEST_CASE_P(
     Runtimes,
     JSITest,