fix(ios): check static invalid mutex crash

driver/js/include/driver/napi/jsc/jsc_ctx.h

@@ -28,6 +28,7 @@
 
 #include <mutex>
 #include <vector>
+#include <set>
 
 #include "footstone/logging.h"
 #include "footstone/string_view.h"
@@ -63,6 +64,27 @@ struct ConstructorData {
   }
 };
 
+class ConstructorDataManager {
+public:
+  void SaveConstructorDataPtr(void* ptr) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    constructor_data_ptr_set_.insert(ptr);
+  }
+
+  void ClearConstructorDataPtr(void* ptr) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    constructor_data_ptr_set_.erase(ptr);
+  }
+
+  bool IsValidConstructorDataPtr(void* ptr) {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return constructor_data_ptr_set_.find(ptr) != constructor_data_ptr_set_.end();
+  }
+private:
+  std::set<void*> constructor_data_ptr_set_;
+  std::mutex mutex_;
+};
+
 class JSCCtx : public Ctx {
 public:
   using string_view = footstone::string_view;

driver/js/include/driver/vm/jsc/jsc_vm.h

@@ -47,13 +47,6 @@ class JSCVM : public VM, public std::enable_shared_from_this<JSCVM> {
   }
 
   JSContextGroupRef vm_;
-
-  static void SaveConstructorDataPtr(void* ptr);
-  static void ClearConstructorDataPtr(void* ptr);
-  static bool IsValidConstructorDataPtr(void* ptr);
-
-  static std::set<void*> constructor_data_ptr_set_;
-  static std::mutex mutex_;
 
   virtual std::shared_ptr<CtxValue> ParseJson(const std::shared_ptr<Ctx>& ctx, const string_view& json) override;
   virtual std::shared_ptr<Ctx> CreateContext() override;

driver/js/src/napi/jsc/jsc_ctx.cc

@@ -49,11 +49,13 @@ constexpr char16_t kSetStr[] = u"set";
 
 static std::once_flag global_class_flag;
 static JSClassRef global_class;
+static std::shared_ptr<ConstructorDataManager> global_constructor_data_mgr = nullptr;
 
 JSCCtx::JSCCtx(JSContextGroupRef group, std::weak_ptr<VM> vm): vm_(vm) {
   std::call_once(global_class_flag, []() {
     JSClassDefinition global = kJSClassDefinitionEmpty;
     global_class = JSClassCreate(&global);
+    global_constructor_data_mgr = std::make_shared<ConstructorDataManager>();
   });
 
   context_ = JSGlobalContextCreateInGroup(group, global_class);
@@ -67,7 +69,9 @@ JSCCtx::~JSCCtx() {
   JSGlobalContextRelease(context_);
   for (auto& [key, item] : constructor_data_holder_) {
     item->prototype = nullptr;
-    JSCVM::ClearConstructorDataPtr(item.get());
+    if (global_constructor_data_mgr) {
+      global_constructor_data_mgr->ClearConstructorDataPtr(item.get());
+    }
   }
 }
 
@@ -260,7 +264,7 @@ std::shared_ptr<CtxValue> JSCCtx::DefineClass(const string_view& name,
     if (!private_data) {
       return;
     }
-    if (!JSCVM::IsValidConstructorDataPtr(private_data)) {
+    if (!global_constructor_data_mgr || !global_constructor_data_mgr->IsValidConstructorDataPtr(private_data)) {
       return;
     }
     auto constructor_data = reinterpret_cast<ConstructorData*>(private_data);
@@ -965,7 +969,9 @@ void* JSCCtx::GetPrivateData(const std::shared_ptr<CtxValue>& object) {
 }
 
 void JSCCtx::SaveConstructorData(std::unique_ptr<ConstructorData> constructor_data) {
-  JSCVM::SaveConstructorDataPtr(constructor_data.get());
+  if (global_constructor_data_mgr) {
+    global_constructor_data_mgr->SaveConstructorDataPtr(constructor_data.get());
+  }
   constructor_data_holder_[constructor_data->class_ref] = std::move(constructor_data);
 }
 

driver/js/src/vm/jsc/jsc_vm.cc

@@ -37,9 +37,6 @@ namespace hippy {
 inline namespace driver {
 inline namespace vm {
 
-std::set<void*> JSCVM::constructor_data_ptr_set_;
-std::mutex JSCVM::mutex_;
-
 std::shared_ptr<CtxValue> JSCVM::ParseJson(const std::shared_ptr<Ctx>& ctx, const string_view& json) {
   if (footstone::StringViewUtils::IsEmpty(json)) {
     return nullptr;
@@ -93,21 +90,6 @@ JSStringRef JSCVM::CreateJSCString(const string_view& str_view) {
   return ret;
 }
 
-void JSCVM::SaveConstructorDataPtr(void* ptr) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  constructor_data_ptr_set_.insert(ptr);
-}
-
-void JSCVM::ClearConstructorDataPtr(void* ptr) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  constructor_data_ptr_set_.erase(ptr);
-}
-
-bool JSCVM::IsValidConstructorDataPtr(void* ptr) {
-  std::lock_guard<std::mutex> lock(mutex_);
-  return constructor_data_ptr_set_.find(ptr) != constructor_data_ptr_set_.end();
-}
-
 }
 }
 }