fix(worker): leave the inspector pause loop when the worker is terminating

A breakpoint hit while console.log converts its arguments pauses the worker inside ConsoleLog, which holds the worker's inspector mutex. terminate() could only end that pause through NotifyTerminating, which takes the same mutex, so the parent's terminate() blocked until the debugger resumed. The pause loop now also leaves on the worker's own termination flag, which terminate() sets before it takes the mutex.

Author: adrian-niculescu

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

@@ -34,13 +34,15 @@ std::string ToUtf8String(const StringView& view) {
 }  // namespace
 
 WorkerInspectorClient::WorkerInspectorClient(int workerId, Isolate* isolate, ALooper* workerLooper,
-                                             const std::string& url)
+                                             const std::string& url,
+                                             const std::atomic_bool& workerTerminating)
     : workerId_(workerId),
       sessionId_("NS_WORKER_" + std::to_string(workerId)),
       targetId_("ns-worker-" + std::to_string(workerId)),
       url_(url),
       isolate_(isolate),
-      workerLooper_(workerLooper) {
+      workerLooper_(workerLooper),
+      workerTerminating_(workerTerminating) {
     // Wakes the worker looper when CDP messages arrive on the socket thread;
     // same mechanism as the worker's message inbox (ConcurrentQueue).
     eventFd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
@@ -206,13 +208,13 @@ void WorkerInspectorClient::MaybeResetSession() {
 }
 
 void WorkerInspectorClient::runMessageLoopOnPause(int contextGroupId) {
-    if (runningPauseLoop_.load(std::memory_order_acquire) || dying_) {
+    if (runningPauseLoop_.load(std::memory_order_acquire) || dying_ || workerTerminating_) {
         return;
     }
     runningPauseLoop_.store(true, std::memory_order_release);
     pauseTerminated_ = false;
 
-    while (!pauseTerminated_ && !dying_) {
+    while (!pauseTerminated_ && !dying_ && !workerTerminating_) {
         std::string message = this->PopMessage();
         bool shouldWait = message.empty();
         if (!shouldWait) {
@@ -225,7 +227,7 @@ void WorkerInspectorClient::runMessageLoopOnPause(int contextGroupId) {
                 ->GetEventLoop(isolate_)
                 ->RunNestableV8Tasks();
 
-        if (shouldWait && !pauseTerminated_ && !dying_) {
+        if (shouldWait && !pauseTerminated_ && !dying_ && !workerTerminating_) {
             std::unique_lock<std::mutex> lock(messageArrivedMutex_);
             messageArrived_.wait_for(lock, std::chrono::milliseconds(1));
         }

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

@@ -35,8 +35,10 @@ class WorkerInspectorClient final : public v8_inspector::V8InspectorClient,
                                     public v8_inspector::V8Inspector::Channel {
     public:
         // Worker thread, with the worker isolate locked and its context created.
+        // `workerTerminating` is the worker's own termination flag; the
+        // worker outlives this client.
         WorkerInspectorClient(int workerId, v8::Isolate* isolate, ALooper* workerLooper,
-                              const std::string& url);
+                              const std::string& url, const std::atomic_bool& workerTerminating);
         ~WorkerInspectorClient() override;
 
         int WorkerId() const {
@@ -126,6 +128,10 @@ class WorkerInspectorClient final : public v8_inspector::V8InspectorClient,
 
         std::atomic<bool> dying_{false};
         std::atomic<bool> pauseTerminated_{false};
+        // Read by the pause loop, which leaves on it without NotifyTerminating:
+        // a pause entered while the worker holds its inspector mutex, inside
+        // console.log, would otherwise keep Terminate() waiting for that mutex.
+        const std::atomic_bool& workerTerminating_;
         std::atomic<bool> runningPauseLoop_{false};  // written on the worker thread only
         bool pendingReset_ = false;                  // worker thread only
 };

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

@@ -818,7 +818,8 @@ void WorkerWrapper::CreateInspector(Isolate* isolate) {
                               ? workerPath_
                               : "file://" + workerPath_;
 
-    auto* client = new WorkerInspectorClient(workerId_, isolate, ALooper_forThread(), url);
+    auto* client = new WorkerInspectorClient(workerId_, isolate, ALooper_forThread(), url,
+                                             isTerminating_);
     {
         std::lock_guard<std::mutex> lock(inspectorMutex_);
         inspector_ = client;