format

islandryu · islandryu · commit 141ec5a4a6f5 · 2025-01-29T23:23:19.000+09:00
diff --git a/deps/v8/tools/lldb_commands.py b/deps/v8/tools/lldb_commands.py
@@ -213,15 +213,15 @@ def bta(debugger, *args):
       print("%s -> %s %s (%s)\033[0m" % (
           color, prefix, match.group(2), match.group(1)))
 
-def setup_source_map_for_relative_paths(debugger):
-  # Copied from Chromium's tools/lldb/lldbinit.py.
-  # When relative paths are used for debug symbols, lldb cannot find source
-  # files. Set up a source map to point to V8's root.
-  this_dir = os.path.dirname(os.path.abspath(__file__))
-  source_dir = os.path.join(this_dir, os.pardir)
-
-  debugger.HandleCommand(
-    'settings set target.source-map ../.. ' + source_dir)
+# def setup_source_map_for_relative_paths(debugger):
+#   # Copied from Chromium's tools/lldb/lldbinit.py.
+#   # When relative paths are used for debug symbols, lldb cannot find source
+#   # files. Set up a source map to point to V8's root.
+#   this_dir = os.path.dirname(os.path.abspath(__file__))
+#   source_dir = os.path.join(this_dir, os.pardir)
+
+#   debugger.HandleCommand(
+#     'settings set target.source-map ../.. ' + source_dir)
 
 
 def __lldb_init_module(debugger, dict):
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>>();
 
 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,34 +4,35 @@
 #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_;
@@ -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 "env-inl.h"
 #include "inspector/main_thread_interface.h"
@@ -20,7 +19,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"
 
@@ -217,11 +215,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(),
@@ -238,7 +235,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);
@@ -256,7 +253,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();
     }
   }
@@ -343,16 +340,17 @@ 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(
-                protocol::StringUtil::parseJSON(raw_message));
-        std::string target_session_id_str = std::to_string(*target_session_id);
-        value->setString("sessionId", target_session_id_str);
-       delegate_->SendMessageToFrontend(Utf8ToStringView(value->serializeToJSON())->string());
+      std::string raw_message = protocol::StringUtil::StringViewToUtf8(message);
+      std::unique_ptr<protocol::DictionaryValue> value =
+          protocol::DictionaryValue::cast(
+              protocol::StringUtil::parseJSON(raw_message));
+      std::string target_session_id_str = std::to_string(*target_session_id);
+      value->setString("sessionId", target_session_id_str);
+      delegate_->SendMessageToFrontend(
+        Utf8ToStringView(value->serializeToJSON())->string());
+    } else {
+      delegate_->SendMessageToFrontend(message);
     }
-
-    delegate_->SendMessageToFrontend(message);
   }
 
   void sendMessageToFrontend(const std::string& message) {
diff --git a/src/inspector_io.cc b/src/inspector_io.cc
@@ -5,6 +5,7 @@
 #include "debug_utils-inl.h"
 #include "inspector/main_thread_interface.h"
 #include "inspector/node_string.h"
+#include "inspector/target_agent.h"
 #include "inspector_socket_server.h"
 #include "ncrypto.h"
 #include "node.h"
@@ -13,7 +14,6 @@
 #include "util-inl.h"
 #include "v8-inspector.h"
 #include "zlib.h"
-#include "inspector/target_agent.h"
 
 #include <deque>
 #include <cstring>
@@ -68,9 +68,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_) {
@@ -99,7 +99,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);
@@ -342,11 +342,11 @@ void InspectorIoDelegate::StartSession(int session_id,
   fprintf(stderr, "Debugger attached.\n");
 }
 
-std::optional<std::string> InspectorIoDelegate::GetTargetSessionId(const std::string& message) {
+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(
-          protocol::StringUtil::parseJSON(view));
+      protocol::DictionaryValue::cast(protocol::StringUtil::parseJSON(view));
   protocol::String target_session_id;
   protocol::Value* target_session_id_value = value->get("sessionId");
   if (target_session_id_value) {
@@ -361,34 +361,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");
     }
@@ -419,11 +424,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
