fix(worker): let a heap-limit terminate re-enter the inspector lock from console.log

A worker's console.log holds inspectorMutex_ across the inspector's consoleLog, which captures a stack trace and so allocates. When that allocation hits the worker's heap cap, the near-heap-limit callback calls Terminate(), which takes the same non-recursive mutex on the same thread and deadlocks the worker. The mutex is recursive now, so that re-entry proceeds while other threads stay excluded as before.

Author: adrian-niculescu

test-app/runtime/src/main/cpp/WorkerWrapper.cpp

@@ -170,7 +170,7 @@ void WorkerWrapper::Terminate() {
         // A worker paused at a breakpoint sits in the inspector's nested pause
         // loop, not in Looper.loop() - kick it loose so TerminateExecution and
         // the looper quit below can take effect.
-        std::lock_guard<std::mutex> lock(inspectorMutex_);
+        std::lock_guard<std::recursive_mutex> lock(inspectorMutex_);
         if (inspector_ != nullptr) {
             inspector_->NotifyTerminating();
         }
@@ -810,7 +810,7 @@ void WorkerWrapper::CreateInspector(Isolate* isolate) {
 
     auto* client = new WorkerInspectorClient(workerId_, isolate, ALooper_forThread(), url);
     {
-        std::lock_guard<std::mutex> lock(inspectorMutex_);
+        std::lock_guard<std::recursive_mutex> lock(inspectorMutex_);
         inspector_ = client;
     }
 
@@ -822,7 +822,7 @@ void WorkerWrapper::CreateInspector(Isolate* isolate) {
 void WorkerWrapper::DestroyInspector() {
     WorkerInspectorClient* client = nullptr;
     {
-        std::lock_guard<std::mutex> lock(inspectorMutex_);
+        std::lock_guard<std::recursive_mutex> lock(inspectorMutex_);
         client = inspector_;
         inspector_ = nullptr;
     }
@@ -843,7 +843,7 @@ void WorkerWrapper::DestroyInspector() {
 
 void WorkerWrapper::ConsoleLog(v8_inspector::ConsoleAPIType method,
                                const std::vector<Local<Value>>& args) {
-    std::lock_guard<std::mutex> lock(inspectorMutex_);
+    std::lock_guard<std::recursive_mutex> lock(inspectorMutex_);
     if (inspector_ != nullptr) {
         inspector_->consoleLog(method, args);
     }

test-app/runtime/src/main/cpp/WorkerWrapper.h

@@ -238,7 +238,10 @@ class WorkerWrapper : public std::enable_shared_from_this<WorkerWrapper> {
     void DestroyInspector();
 
     WorkerInspectorClient* inspector_ = nullptr;
-    std::mutex inspectorMutex_;
+    // Recursive: ConsoleLog holds it across consoleLog, whose stack capture
+    // allocates, and a near-heap-limit callback raised by that allocation
+    // calls Terminate(), which takes it again on the same thread.
+    std::recursive_mutex inspectorMutex_;
 #endif
 
     static std::mutex registryMutex_;