format

islandryu · islandryu · commit 984f640c4ea7 · 2025-01-30T19:04:34.000+09:00
diff --git a/src/inspector/node_protocol.pdl b/src/inspector/node_protocol.pdl
@@ -241,4 +241,3 @@ experimental domain Target
       SessionID sessionId
       TargetInfo targetInfo
       boolean waitingForDebugger
-      
diff --git a/src/inspector/target_agent.cc b/src/inspector/target_agent.cc
@@ -1,47 +1,39 @@
 #include "target_agent.h"
-#include <iostream>
-#include <memory>
-#include <set>
-#include <string>
-#include <tuple>
-#include <utility>
-#include "inspector/node_string.h"
 #include "inspector/worker_inspector.h"
 #include "main_thread_interface.h"
 
 namespace node {
 namespace inspector {
 namespace protocol {
 
-std::unordered_map<int,std::shared_ptr<MainThreadHandle>> TargetAgent::target_session_id_worker_map_ = std::unordered_map<int, std::shared_ptr<MainThreadHandle>>();
-
-
+std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+    TargetAgent::target_session_id_worker_map_ =
+        std::unordered_map<int, std::shared_ptr<MainThreadHandle>>();
+int TargetAgent::next_session_id_ = 1;
 class WorkerTargetDelegate : public WorkerDelegate {
  public:
   explicit WorkerTargetDelegate(std::shared_ptr<TargetAgent> target_agent)
       : target_agent_(target_agent) {}
 
-
   void WorkerCreated(const std::string& title,
                      const std::string& url,
                      bool waiting,
                      std::shared_ptr<MainThreadHandle> worker) override {
     std::string target_id = std::to_string(target_agent_->getNextTargetId());
     std::string type = "worker";
-    
+
     target_agent_->targetCreated(target_id, type, title, url);
-    target_agent_->attachedToTarget(worker,target_id, type, title, url);
+    target_agent_->attachedToTarget(worker, target_id, type, title, url);
   }
 
  private:
   const std::shared_ptr<TargetAgent> target_agent_;
 };
 
-std::unique_ptr<Target::TargetInfo> createTargetInfo(
-    const String& target_id,
-    const String& type,
-    const String& title,
-    const String& url) {
+std::unique_ptr<Target::TargetInfo> createTargetInfo(const String& target_id,
+                                                     const String& type,
+                                                     const String& title,
+                                                     const String& url) {
   return Target::TargetInfo::create()
       .setTargetId(target_id)
       .setType(type)
@@ -62,7 +54,8 @@ void TargetAgent::listenWorker(std::weak_ptr<WorkerManager> worker_manager) {
   if (!manager) {
     return;
   }
-  std::unique_ptr<WorkerDelegate> delegate(new WorkerTargetDelegate(shared_from_this()));
+  std::unique_ptr<WorkerDelegate> delegate(
+      new WorkerTargetDelegate(shared_from_this()));
   worker_event_handle_ = manager->SetAutoAttach(std::move(delegate));
 }
 
@@ -72,7 +65,10 @@ void TargetAgent::reset() {
   }
 }
 
-void TargetAgent::targetCreated(const std::string &target_id,const std::string &type,const std::string &title,const std::string &url) {
+void TargetAgent::targetCreated(const std::string& target_id,
+                                const std::string& type,
+                                const std::string& title,
+                                const std::string& url) {
   frontend_->targetCreated(createTargetInfo(target_id, type, title, url));
 }
 
@@ -84,13 +80,19 @@ int TargetAgent::getNextTargetId() {
   return next_target_id_++;
 }
 
-void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url) {
+void TargetAgent::attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                                   const std::string& target_id,
+                                   const std::string& type,
+                                   const std::string& title,
+                                   const std::string& url) {
   int session_id = getNextSessionId();
   target_session_id_worker_map_[session_id] = worker;
   worker->SetTargetSessionId(session_id);
-  frontend_->attachedToTarget(std::to_string(session_id), createTargetInfo(target_id, type, title, url), true);
+  frontend_->attachedToTarget(std::to_string(session_id),
+                              createTargetInfo(target_id, type, title, url),
+                              true);
 }
 
-} // namespace protocol
+}  // namespace protocol
 }  // namespace inspector
 }  // namespace node
diff --git a/src/inspector/target_agent.h b/src/inspector/target_agent.h
@@ -4,39 +4,40 @@
 #include "inspector/worker_inspector.h"
 #include "node/inspector/protocol/Target.h"
 
-#include <memory>
-#include <string>
-#include <thread>
-#include <unordered_map>
-
 namespace node {
 
 namespace inspector {
 class TargetInspector;
 
 namespace protocol {
 
-class TargetAgent : public Target::Backend, public std::enable_shared_from_this<TargetAgent> 
-{
+class TargetAgent : public Target::Backend,
+                    public std::enable_shared_from_this<TargetAgent> {
  public:
-  explicit TargetAgent() {}
-
   void Wire(UberDispatcher* dispatcher);
 
-
-  void targetCreated(const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url);
-  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,const std::string &target_id, const std::string &type,const  std::string &title,const  std::string &url);
+  void targetCreated(const std::string& target_id,
+                     const std::string& type,
+                     const std::string& title,
+                     const std::string& url);
+  void attachedToTarget(std::shared_ptr<MainThreadHandle> worker,
+                        const std::string& target_id,
+                        const std::string& type,
+                        const std::string& title,
+                        const std::string& url);
 
   int getNextTargetId();
 
   void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
   void reset();
-  static std::unordered_map<int,std::shared_ptr<MainThreadHandle>> target_session_id_worker_map_;
+  static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+      target_session_id_worker_map_;
+
  private:
   int getNextSessionId();
   std::shared_ptr<Target::Frontend> frontend_;
   std::weak_ptr<WorkerManager> worker_manager_;
-  int next_session_id_ = 1;
+  static int next_session_id_;
   int next_target_id_ = 1;
   std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
 };
@@ -46,4 +47,3 @@ class TargetAgent : public Target::Backend, public std::enable_shared_from_this<
 }  // namespace node
 
 #endif  // SRC_INSPECTOR_TARGET_AGENT_H_
-
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
@@ -1,5 +1,4 @@
 #include "inspector_agent.h"
-#include <string>
 
 #include "crdtp/json.h"
 #include "env-inl.h"
@@ -22,7 +21,6 @@
 #include "permission/permission.h"
 #include "timer_wrap-inl.h"
 #include "util-inl.h"
-#include "util.h"
 #include "v8-inspector.h"
 #include "v8-platform.h"
 
@@ -224,11 +222,10 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
                        const std::unique_ptr<V8Inspector>& inspector,
                        std::shared_ptr<WorkerManager> worker_manager,
                        std::unique_ptr<InspectorSessionDelegate> delegate,
-                       std::shared_ptr<MainThreadHandle> main_thread_,
+                       std::shared_ptr<MainThreadHandle> main_thread,
                        bool prevent_shutdown)
-      : delegate_(std::move(delegate)), main_thread_(main_thread_),
-        prevent_shutdown_(prevent_shutdown), retaining_context_(false)
-         {
+      : delegate_(std::move(delegate)), main_thread_(main_thread),
+        prevent_shutdown_(prevent_shutdown), retaining_context_(false) {
     session_ = inspector->connect(CONTEXT_GROUP_ID,
                                   this,
                                   StringView(),
@@ -245,7 +242,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_->Wire(node_dispatcher_.get());
     network_inspector_ = std::make_unique<NetworkInspector>(env);
     network_inspector_->Wire(node_dispatcher_.get());
-    if(env->options()->experimental_worker_inspection) {
+    if (env->options()->experimental_worker_inspection) {
       target_agent_ = std::make_shared<protocol::TargetAgent>();
       target_agent_->Wire(node_dispatcher_.get());
       target_agent_->listenWorker(worker_manager);
@@ -263,7 +260,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_.reset();  // Dispose before the dispatchers
     network_inspector_->Disable();
     network_inspector_.reset();  // Dispose before the dispatchers
-    if(target_agent_) {
+    if (target_agent_) {
       target_agent_->reset();
     }
   }
@@ -369,17 +366,18 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     }
     std::optional<int> target_session_id = main_thread_->GetTargetSessionId();
     if (target_session_id.has_value()) {
+      std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);
       std::unique_ptr<protocol::DictionaryValue> value =
           protocol::DictionaryValue::cast(
-              JsonUtil::parseJSON(message));
+              JsonUtil::parseJSON(raw_message));
       std::string target_session_id_str = std::to_string(*target_session_id);
       value->setString("sessionId", target_session_id_str);
       std::string json = serializeToJSON(std::move(value));
-
-      delegate_->SendMessageToFrontend(Utf8ToStringView(json)->string());
+      delegate_->SendMessageToFrontend(
+        Utf8ToStringView(json)->string());
+    } else {
+      delegate_->SendMessageToFrontend(message);
     }
-
-    delegate_->SendMessageToFrontend(message);
   }
 
   void sendMessageToFrontend(const std::string& message) {
@@ -414,7 +412,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   std::unique_ptr<NetworkInspector> network_inspector_;
   std::unique_ptr<InspectorSessionDelegate> delegate_;
   std::unique_ptr<v8_inspector::V8InspectorSession> session_;
-  std::unique_ptr<protocol::UberDispatcher> node_dispatcher_;
+  std::unique_ptr<UberDispatcher> node_dispatcher_;
   std::shared_ptr<MainThreadHandle> main_thread_;
   bool prevent_shutdown_;
   bool retaining_context_;
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
@@ -6,6 +6,7 @@
 #include "inspector/main_thread_interface.h"
 #include "inspector/node_json.h"
 #include "inspector/node_string.h"
+#include "inspector/target_agent.h"
 #include "inspector_socket_server.h"
 #include "ncrypto.h"
 #include "node.h"
@@ -14,7 +15,6 @@
 #include "util-inl.h"
 #include "v8-inspector.h"
 #include "zlib.h"
-#include "inspector/target_agent.h"
 
 #include <deque>
 #include <cstring>
@@ -69,9 +69,9 @@ class RequestToServer {
   RequestToServer(TransportAction action,
                   int session_id,
                   std::unique_ptr<v8_inspector::StringBuffer> message)
-                  : action_(action),
-                    session_id_(session_id),
-                    message_(std::move(message)) {}
+      : action_(action),
+        session_id_(session_id),
+        message_(std::move(message)) {}
 
   void Dispatch(InspectorSocketServer* server) const {
     switch (action_) {
@@ -100,7 +100,7 @@ class RequestQueueData {
   using MessageQueue = std::deque<RequestToServer>;
 
   explicit RequestQueueData(uv_loop_t* loop)
-                            : handle_(std::make_shared<RequestQueue>(this)) {
+      : handle_(std::make_shared<RequestQueue>(this)) {
     int err = uv_async_init(loop, &async_, [](uv_async_t* async) {
       RequestQueueData* wrapper =
           node::ContainerOf(&RequestQueueData::async_, async);
@@ -343,11 +343,11 @@ void InspectorIoDelegate::StartSession(int session_id,
   fprintf(stderr, "Debugger attached.\n");
 }
 
-std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(const std::string& message) {
-  const std::string_view view(message.data(), message.size());
+std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(
+    const std::string& message) {
+  std::string_view view(message.data(), message.size());
   std::unique_ptr<protocol::DictionaryValue> value =
-      protocol::DictionaryValue::cast(
-          JsonUtil::parseJSON(view));
+      protocol::DictionaryValue::cast(JsonUtil::parseJSON(view));
   protocol::String target_session_id;
   protocol::Value* target_session_id_value = value->get("sessionId");
   if (target_session_id_value) {
@@ -362,34 +362,39 @@ std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(const std::st
 
 void InspectorIoDelegate::MessageReceived(int session_id,
                                           const std::string& message) {
-  std::optional<std::string> target_session_id_str = GetTargetSessionId(message);
+  std::optional<std::string> target_session_id_str =
+      GetTargetSessionId(message);
   std::shared_ptr<MainThreadHandle> worker = nullptr;
   int merged_session_id = session_id;
-  if(!target_session_id_str->empty()) {
+  if (!target_session_id_str->empty()) {
     int target_session_id = std::stoi(*target_session_id_str);
-    worker = protocol::TargetAgent::target_session_id_worker_map_[target_session_id];
-    if(worker) {
+    worker =
+        protocol::TargetAgent::target_session_id_worker_map_[target_session_id];
+    if (worker) {
       merged_session_id += target_session_id << 16;
     }
   }
 
   auto session = sessions_.find(merged_session_id);
 
-  if(session == sessions_.end()) {
+  if (session == sessions_.end()) {
     std::unique_ptr<InspectorSession> session;
-    if(worker) {
+    if (worker) {
       session = worker->Connect(
-        std::unique_ptr<InspectorSessionDelegate>(
-            new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+          std::unique_ptr<InspectorSessionDelegate>(
+              new IoSessionDelegate(request_queue_->handle(), session_id)),
+          true);
     } else {
       session = main_thread_->Connect(
-        std::unique_ptr<InspectorSessionDelegate>(
-            new IoSessionDelegate(request_queue_->handle(), session_id)), true);
+          std::unique_ptr<InspectorSessionDelegate>(
+              new IoSessionDelegate(request_queue_->handle(), session_id)),
+          true);
     }
 
     if (session) {
       sessions_[merged_session_id] = std::move(session);
-      sessions_[merged_session_id]->Dispatch(Utf8ToStringView(message)->string());
+      sessions_[merged_session_id]->Dispatch(
+          Utf8ToStringView(message)->string());
     } else {
       fprintf(stderr, "Failed to connect to inspector session.\n");
     }
@@ -420,11 +425,11 @@ void RequestQueueData::CloseAndFree(RequestQueueData* queue) {
   queue->handle_.reset();
   uv_close(reinterpret_cast<uv_handle_t*>(&queue->async_),
            [](uv_handle_t* handle) {
-    uv_async_t* async = reinterpret_cast<uv_async_t*>(handle);
-    RequestQueueData* wrapper =
-        node::ContainerOf(&RequestQueueData::async_, async);
-    delete wrapper;
-  });
+             uv_async_t* async = reinterpret_cast<uv_async_t*>(handle);
+             RequestQueueData* wrapper =
+                 node::ContainerOf(&RequestQueueData::async_, async);
+             delete wrapper;
+           });
 }
 }  // namespace inspector
 }  // namespace node
diff --git a/test/parallel/test-inspector-worker-target.js b/test/parallel/test-inspector-worker-target.js
@@ -1,4 +1,4 @@
-// Flags: --experimental-worker-inspection
+// Flags: --inspect=0 --experimental-worker-inspection
 'use strict';
 
 const common = require('../common');
@@ -14,14 +14,14 @@ const session = new Session();
 
 session.connect();
 
-new Worker(fixtures.path("worker-script.mjs"), { type: 'module' });
-session.on("Target.targetCreated", common.mustCall(({ params }) => {
+new Worker(fixtures.path('worker-script.mjs'), { type: 'module' });
+session.on('Target.targetCreated', common.mustCall(({ params }) => {
   const targetInfo = params.targetInfo;
-  assert.strictEqual(targetInfo.type, "worker");
-  assert.ok(targetInfo.url.includes("worker-script.mjs"));
-  assert.strictEqual(targetInfo.targetId, "1");
+  assert.strictEqual(targetInfo.type, 'worker');
+  assert.ok(targetInfo.url.includes('worker-script.mjs'));
+  assert.strictEqual(targetInfo.targetId, '1');
 }));
 
-session.on("Target.attachedToTarget", common.mustCall(({ params }) => {
-  assert.strictEqual(params.sessionId, "1");
+session.on('Target.attachedToTarget', common.mustCall(({ params }) => {
+  assert.strictEqual(params.sessionId, '1');
 }));
