fix(ffi): stabilize direct block callback reuse

Author: DjDeveloperr

NativeScript/ffi/shared/jsi/NativeApiJsiBridge.h

@@ -508,6 +508,7 @@ class NativeApiJsiBridge {
     if (native == nullptr) {
       return;
     }
+    std::lock_guard<std::mutex> lock(roundTripValuesMutex_);
     roundTripValues_[normalizeRuntimePointer(
         reinterpret_cast<uintptr_t>(native))] =
         std::make_shared<Value>(runtime, value);
@@ -517,6 +518,7 @@ class NativeApiJsiBridge {
     if (native == nullptr) {
       return Value::undefined();
     }
+    std::lock_guard<std::mutex> lock(roundTripValuesMutex_);
     auto it = roundTripValues_.find(
         normalizeRuntimePointer(reinterpret_cast<uintptr_t>(native)));
     if (it == roundTripValues_.end() || it->second == nullptr) {
@@ -529,6 +531,7 @@ class NativeApiJsiBridge {
     if (native == nullptr) {
       return;
     }
+    std::lock_guard<std::mutex> lock(roundTripValuesMutex_);
     roundTripValues_.erase(
         normalizeRuntimePointer(reinterpret_cast<uintptr_t>(native)));
   }
@@ -1506,6 +1509,7 @@ class NativeApiJsiBridge {
   std::unordered_map<std::string, NativeApiSymbol> protocolSymbolsByRuntimeName_;
   std::unordered_map<uintptr_t, NativeApiSymbol> classSymbolsByRuntimePointer_;
   std::unordered_map<uintptr_t, NativeApiSymbol> protocolSymbolsByRuntimePointer_;
+  mutable std::mutex roundTripValuesMutex_;
   std::unordered_map<uintptr_t, std::shared_ptr<Value>> roundTripValues_;
   std::unordered_map<uintptr_t, std::shared_ptr<Value>> classValues_;
   std::unordered_map<uintptr_t, std::shared_ptr<Value>> classPrototypes_;

NativeScript/ffi/shared/jsi/NativeApiJsiCallbacks.h

@@ -413,15 +413,15 @@ class NativeApiJsiCallback final
     retainedBlockCopies_.push_back({blockPointer, std::move(self)});
   }
 
-  void releaseBlockCopy(const void* blockPointer) {
+  bool releaseBlockCopy(const void* blockPointer) {
     if (!block_) {
-      return;
+      return false;
     }
     std::shared_ptr<NativeApiJsiCallback> keepAlive;
     try {
       keepAlive = shared_from_this();
     } catch (const std::bad_weak_ptr&) {
-      return;
+      return false;
     }
     std::lock_guard<std::mutex> lock(retainedBlockCopiesMutex_);
     auto it = retainedBlockCopies_.end();
@@ -432,15 +432,14 @@ class NativeApiJsiCallback final
             return retained.blockPointer == blockPointer;
           });
     }
-    if (it == retainedBlockCopies_.end() && !retainedBlockCopies_.empty()) {
-      it = retainedBlockCopies_.end() - 1;
-    }
     if (it != retainedBlockCopies_.end()) {
       if (bridge_ != nullptr && it->blockPointer != nullptr) {
         bridge_->forgetRoundTripValue(it->blockPointer);
       }
       retainedBlockCopies_.erase(it);
+      return true;
     }
+    return false;
   }
 
   void invoke(void* ret, void* args[]) {
@@ -751,8 +750,11 @@ void nativeApiJsiBlockDispose(void* src) {
   if (block == nullptr || block->callback == nullptr) {
     return;
   }
-  static_cast<NativeApiJsiCallback*>(block->callback)->releaseBlockCopy(block);
-  block->callback = nullptr;
+  bool released =
+      static_cast<NativeApiJsiCallback*>(block->callback)->releaseBlockCopy(block);
+  if (released) {
+    block->callback = nullptr;
+  }
 }
 
 void nativeApiJsiCallbackTrampoline(ffi_cif*, void* ret, void* args[],

NativeScript/ffi/shared/jsi/NativeApiJsiConversion.h

@@ -751,15 +751,20 @@ void convertJsiArgument(Runtime& runtime,
       if (value.isObject()) {
         Object object = value.asObject(runtime);
         void* nativePointer = nullptr;
-        if (readNativePointerProperty(runtime, object, &nativePointer)) {
-          *static_cast<void**>(target) = nativePointer;
-          break;
-        }
         if (object.isFunction(runtime)) {
+          std::string functionKind = stringPropertyOrEmpty(runtime, object, "kind");
+          if (functionKind == "block" || functionKind == "functionPointer" ||
+              functionKind == "functionReference") {
+            if (readNativePointerProperty(runtime, object, &nativePointer)) {
+              *static_cast<void**>(target) = nativePointer;
+              break;
+            }
+          }
+
           auto threadPolicy = readJsiCallbackThreadPolicy(runtime, object);
-          auto callback = createJsiCallback(
-              runtime, bridge, type, object.asFunction(runtime),
-              type.kind == metagen::mdTypeBlock, threadPolicy);
+          auto callback =
+              createJsiCallback(runtime, bridge, type, object.asFunction(runtime),
+                                type.kind == metagen::mdTypeBlock, threadPolicy);
           void* pointer = callback->functionPointer();
           if (type.kind == metagen::mdTypeBlock) {
             frame.addLifetime(callback);

NativeScript/ffi/v8/NativeApiV8.mm

@@ -108,7 +108,9 @@ void NativeApiV8LazyGlobalGetter(v8::Local<v8::Name>,
     }
     return;
   }
-  global->DefineOwnProperty(context, nameValue, result, v8::DontEnum).FromMaybe(false);
+  if (global->Delete(context, nameValue).FromMaybe(false)) {
+    global->DefineOwnProperty(context, nameValue, result, v8::DontEnum).FromMaybe(false);
+  }
   info.GetReturnValue().Set(result);
 }