inspector: report all workers

src/inspector/worker_inspector.h

@@ -55,6 +55,13 @@ class ParentInspectorHandle {
                         std::shared_ptr<MainThreadHandle> parent_thread,
                         bool wait_for_connect);
   ~ParentInspectorHandle();
+  std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
+      int thread_id, const std::string& url) {
+    return std::make_unique<ParentInspectorHandle>(thread_id,
+                                                   url,
+                                                   parent_thread_,
+                                                   wait_);
+  }
   void WorkerStarted(std::shared_ptr<MainThreadHandle> worker_thread,
                      bool waiting);
   bool WaitForConnect() {

src/inspector_agent.cc

@@ -237,17 +237,21 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     tracing_agent_ =
         std::make_unique<protocol::TracingAgent>(env, main_thread_);
     tracing_agent_->Wire(node_dispatcher_.get());
-    worker_agent_ = std::make_unique<protocol::WorkerAgent>(worker_manager);
-    worker_agent_->Wire(node_dispatcher_.get());
+    if (worker_manager) {
+      worker_agent_ = std::make_unique<protocol::WorkerAgent>(worker_manager);
+      worker_agent_->Wire(node_dispatcher_.get());
+    }
     runtime_agent_ = std::make_unique<protocol::RuntimeAgent>();
     runtime_agent_->Wire(node_dispatcher_.get());
   }
 
   ~ChannelImpl() override {
     tracing_agent_->disable();
     tracing_agent_.reset();  // Dispose before the dispatchers
-    worker_agent_->disable();
-    worker_agent_.reset();  // Dispose before the dispatchers
+    if (worker_agent_) {
+      worker_agent_->disable();
+      worker_agent_.reset();  // Dispose before the dispatchers
+    }
     runtime_agent_->disable();
     runtime_agent_.reset();  // Dispose before the dispatchers
   }
@@ -670,6 +674,9 @@ class NodeInspectorClient : public V8InspectorClient {
   }
 
   std::shared_ptr<WorkerManager> getWorkerManager() {
+    if (!is_main_) {
+      return nullptr;
+    }
     if (worker_manager_ == nullptr) {
       worker_manager_ =
           std::make_shared<WorkerManager>(getThreadHandle());
@@ -968,7 +975,11 @@ void Agent::SetParentHandle(
 
 std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
     int thread_id, const std::string& url) {
-  return client_->getWorkerManager()->NewParentHandle(thread_id, url);
+  if (!parent_handle_) {
+    return client_->getWorkerManager()->NewParentHandle(thread_id, url);
+  } else {
+    return parent_handle_->NewParentInspectorHandle(thread_id, url);
+  }
 }
 
 void Agent::WaitForConnect() {

test/parallel/test-inspector-workers-flat-list.js

@@ -0,0 +1,70 @@
+'use strict';
+const common = require('../common');
+common.skipIfInspectorDisabled();
+
+const { Session } = require('inspector');
+const { Worker, isMainThread, parentPort } = require('worker_threads');
+
+const MAX_DEPTH = 3;
+
+let rootWorker = null;
+
+function runTest() {
+  let reportedWorkersCount = 0;
+  const session = new Session();
+  session.connect();
+  session.on('NodeWorker.attachedToWorker', ({ params: { workerInfo } }) => {
+    console.log(`Worker ${workerInfo.title} was reported`);
+    if (++reportedWorkersCount === MAX_DEPTH) {
+      rootWorker.postMessage({ done: true });
+    }
+  });
+  session.post('NodeWorker.enable', { waitForDebuggerOnStart: false });
+}
+
+function processMessage({ child }) {
+  console.log(`Worker ${child} is running`);
+  if (child === MAX_DEPTH) {
+    runTest();
+  }
+}
+
+function workerCallback(message) {
+  parentPort.postMessage(message);
+}
+
+function startWorker(depth, messageCallback) {
+  const worker = new Worker(__filename);
+  worker.on('message', messageCallback);
+  worker.postMessage({ depth });
+  return worker;
+}
+
+function runMainThread() {
+  rootWorker = startWorker(1, processMessage);
+}
+
+function runWorkerThread() {
+  let worker = null;
+  parentPort.on('message', ({ child, depth, done }) => {
+    if (done) {
+      if (worker) {
+        worker.postMessage({ done: true });
+      }
+      parentPort.close();
+    } else if (depth) {
+      parentPort.postMessage({ child: depth });
+      if (depth < MAX_DEPTH) {
+        worker = startWorker(depth + 1, workerCallback);
+      }
+    } else if (child) {
+      parentPort.postMessage({ child });
+    }
+  });
+}
+
+if (isMainThread) {
+  runMainThread();
+} else {
+  runWorkerThread();
+}