avoid making networkResourceManager a static class.

Co-authored-by: Chengzhong Wu <legendecas@gmail.com>
nodejs · nodejs-github-bot · Jul 10, 2025 · Apr 29, 2025 · Jun 29, 2025 · Jun 30, 2025
commit fbdcdccd8e89b77f4114537c12fdfe1b1d69cbf8
diff --git a/src/inspector/io_agent.cc b/src/inspector/io_agent.cc
@@ -29,13 +29,13 @@ DispatchResponse IoAgent::read(const String& in_handle,
   }
   stream_id = std::stoull(in_handle_str);
 
-  std::string url = NetworkResourceManager::GetUrlForStreamId(stream_id);
+  std::string url = network_resource_manager_->GetUrlForStreamId(stream_id);
   if (url.empty()) {
     *out_data = "";
     *out_eof = true;
     return DispatchResponse::Success();
   }
-  std::string txt = NetworkResourceManager::Get(url);
+  std::string txt = network_resource_manager_->Get(url);
   std::string_view txt_view(txt);
 
   int offset = 0;
@@ -73,7 +73,7 @@ DispatchResponse IoAgent::close(const String& in_handle) {
   if (is_number) {
     stream_id = std::stoull(in_handle_str);
     // Use accessor to erase resource and mapping by stream id
-    NetworkResourceManager::EraseByStreamId(stream_id);
+    network_resource_manager_->EraseByStreamId(stream_id);
   }
   return DispatchResponse::Success();
 }

diff --git a/src/inspector/io_agent.h b/src/inspector/io_agent.h
@@ -1,13 +1,17 @@
 #ifndef SRC_INSPECTOR_IO_AGENT_H_
 #define SRC_INSPECTOR_IO_AGENT_H_
 
+#include <memory>
+#include "inspector/network_resource_manager.h"
 #include "node/inspector/protocol/IO.h"
 
 namespace node::inspector::protocol {
 
 class IoAgent : public IO::Backend {
  public:
-  IoAgent() {}
+  explicit IoAgent(
+      std::shared_ptr<NetworkResourceManager> network_resource_manager)
+      : network_resource_manager_(std::move(network_resource_manager)) {}
   void Wire(UberDispatcher* dispatcher);
   DispatchResponse read(const String& in_handle,
                         Maybe<int> in_offset,
@@ -19,6 +23,7 @@ class IoAgent : public IO::Backend {
  private:
   std::shared_ptr<IO::Frontend> frontend_;
   std::unordered_map<int, int> offset_map_ = {};  // Maps stream_id to offset
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 }  // namespace node::inspector::protocol
 #endif  // SRC_INSPECTOR_IO_AGENT_H_
diff --git a/src/inspector/network_agent.cc b/src/inspector/network_agent.cc
@@ -208,10 +208,15 @@ std::unique_ptr<protocol::Network::Response> createResponseFromObject(
       .build();
 }
 
-NetworkAgent::NetworkAgent(NetworkInspector* inspector,
-                           v8_inspector::V8Inspector* v8_inspector,
-                           Environment* env)
-    : inspector_(inspector), v8_inspector_(v8_inspector), env_(env) {
+NetworkAgent::NetworkAgent(
+    NetworkInspector* inspector,
+    v8_inspector::V8Inspector* v8_inspector,
+    Environment* env,
+    std::shared_ptr<NetworkResourceManager> network_resource_manager)
+    : inspector_(inspector),
+      v8_inspector_(v8_inspector),
+      env_(env),
+      network_resource_manager_(std::move(network_resource_manager)) {
   event_notifier_map_["requestWillBeSent"] = &NetworkAgent::requestWillBeSent;
   event_notifier_map_["responseReceived"] = &NetworkAgent::responseReceived;
   event_notifier_map_["loadingFailed"] = &NetworkAgent::loadingFailed;
@@ -349,10 +354,11 @@ protocol::DispatchResponse NetworkAgent::loadNetworkResource(
         "experimental and requires --experimental-inspector-network-resource "
         "flag to be set.");
   }
-  std::string data = NetworkResourceManager::Get(in_url);
+  CHECK_NOT_NULL(network_resource_manager_);
+  std::string data = network_resource_manager_->Get(in_url);
   bool found = !data.empty();
   if (found) {
-    uint64_t stream_id = NetworkResourceManager::GetStreamId(in_url);
+    uint64_t stream_id = network_resource_manager_->GetStreamId(in_url);
     auto result = protocol::Network::LoadNetworkResourcePageResult::create()
                       .setSuccess(true)
                       .setStream(std::to_string(stream_id))

diff --git a/src/inspector/network_agent.h b/src/inspector/network_agent.h
@@ -3,9 +3,11 @@
 
 #include "env.h"
 #include "io_agent.h"
+#include "network_resource_manager.h"
 #include "node/inspector/protocol/Network.h"
 
 #include <map>
+#include <memory>
 #include <unordered_map>
 
 namespace node {
@@ -40,9 +42,11 @@ struct RequestEntry {
 
 class NetworkAgent : public protocol::Network::Backend {
  public:
-  explicit NetworkAgent(NetworkInspector* inspector,
-                        v8_inspector::V8Inspector* v8_inspector,
-                        Environment* env);
+  explicit NetworkAgent(
+      NetworkInspector* inspector,
+      v8_inspector::V8Inspector* v8_inspector,
+      Environment* env,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
 
   void Wire(protocol::UberDispatcher* dispatcher);
 
@@ -98,6 +102,7 @@ class NetworkAgent : public protocol::Network::Backend {
   std::unordered_map<protocol::String, EventNotifier> event_notifier_map_;
   std::map<protocol::String, RequestEntry> requests_;
   Environment* env_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 
 }  // namespace inspector

diff --git a/src/inspector/network_inspector.cc b/src/inspector/network_inspector.cc
@@ -3,10 +3,15 @@
 namespace node {
 namespace inspector {
 
-NetworkInspector::NetworkInspector(Environment* env,
-                                   v8_inspector::V8Inspector* v8_inspector)
-    : enabled_(false), env_(env) {
-  network_agent_ = std::make_unique<NetworkAgent>(this, v8_inspector, env);
+NetworkInspector::NetworkInspector(
+    Environment* env,
+    v8_inspector::V8Inspector* v8_inspector,
+    std::shared_ptr<NetworkResourceManager> network_resource_manager)
+    : enabled_(false),
+      env_(env),
+      network_resource_manager_(std::move(network_resource_manager)) {
+  network_agent_ = std::make_unique<NetworkAgent>(
+      this, v8_inspector, env, network_resource_manager_);
 }
 NetworkInspector::~NetworkInspector() {
   network_agent_.reset();

diff --git a/src/inspector/network_inspector.h b/src/inspector/network_inspector.h
@@ -1,8 +1,10 @@
 #ifndef SRC_INSPECTOR_NETWORK_INSPECTOR_H_
 #define SRC_INSPECTOR_NETWORK_INSPECTOR_H_
 
+#include <memory>
 #include "env.h"
 #include "network_agent.h"
+#include "network_resource_manager.h"
 
 namespace node {
 class Environment;
@@ -11,8 +13,10 @@ namespace inspector {
 
 class NetworkInspector {
  public:
-  explicit NetworkInspector(Environment* env,
-                            v8_inspector::V8Inspector* v8_inspector);
+  explicit NetworkInspector(
+      Environment* env,
+      v8_inspector::V8Inspector* v8_inspector,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
   ~NetworkInspector();
 
   void Wire(protocol::UberDispatcher* dispatcher);
@@ -32,6 +36,7 @@ class NetworkInspector {
   bool enabled_;
   Environment* env_;
   std::unique_ptr<NetworkAgent> network_agent_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 
 }  // namespace inspector

diff --git a/src/inspector/network_resource_manager.cc b/src/inspector/network_resource_manager.cc
@@ -7,18 +7,15 @@
 namespace node {
 namespace inspector {
 
-std::unordered_map<std::string, std::string> NetworkResourceManager::resources_;
-std::unordered_map<std::string, uint64_t>
-    NetworkResourceManager::url_to_stream_id_;
-std::atomic<uint64_t> NetworkResourceManager::stream_id_counter_{1};
-
 void NetworkResourceManager::Put(const std::string& url,
                                  const std::string& data) {
+  Mutex::ScopedLock lock(mutex_);
   resources_[url] = data;
   url_to_stream_id_[url] = ++stream_id_counter_;
 }
 
 std::string NetworkResourceManager::Get(const std::string& url) {
+  Mutex::ScopedLock lock(mutex_);
   auto it = resources_.find(url);
   if (it != resources_.end()) return it->second;
   return {};
@@ -29,6 +26,7 @@ uint64_t NetworkResourceManager::NextStreamId() {
 }
 
 std::string NetworkResourceManager::GetUrlForStreamId(uint64_t stream_id) {
+  Mutex::ScopedLock lock(mutex_);
   for (const auto& pair : url_to_stream_id_) {
     if (pair.second == stream_id) {
       return pair.first;
@@ -38,6 +36,7 @@ std::string NetworkResourceManager::GetUrlForStreamId(uint64_t stream_id) {
 }
 
 void NetworkResourceManager::EraseByStreamId(uint64_t stream_id) {
+  Mutex::ScopedLock lock(mutex_);
   for (auto it = url_to_stream_id_.begin(); it != url_to_stream_id_.end();
        ++it) {
     if (it->second == stream_id) {
@@ -49,6 +48,7 @@ void NetworkResourceManager::EraseByStreamId(uint64_t stream_id) {
 }
 
 uint64_t NetworkResourceManager::GetStreamId(const std::string& url) {
+  Mutex::ScopedLock lock(mutex_);
   auto it = url_to_stream_id_.find(url);
   if (it != url_to_stream_id_.end()) return it->second;
   return 0;

diff --git a/src/inspector/network_resource_manager.h b/src/inspector/network_resource_manager.h
@@ -5,27 +5,29 @@
 #include <atomic>
 #include <string>
 #include <unordered_map>
+#include "node_mutex.h"
 
 namespace node {
 namespace inspector {
 
 class NetworkResourceManager {
  public:
-  static void Put(const std::string& url, const std::string& data);
-  static std::string Get(const std::string& url);
+  void Put(const std::string& url, const std::string& data);
+  std::string Get(const std::string& url);
 
   // Accessor to get URL for a given stream id
-  static std::string GetUrlForStreamId(uint64_t stream_id);
+  std::string GetUrlForStreamId(uint64_t stream_id);
   // Erase resource and mapping by stream id
-  static void EraseByStreamId(uint64_t stream_id);
+  void EraseByStreamId(uint64_t stream_id);
   // Returns the stream id for a given url, or 0 if not found
-  static uint64_t GetStreamId(const std::string& url);
+  uint64_t GetStreamId(const std::string& url);
 
  private:
-  static uint64_t NextStreamId();
-  static std::unordered_map<std::string, std::string> resources_;
-  static std::unordered_map<std::string, uint64_t> url_to_stream_id_;
-  static std::atomic<uint64_t> stream_id_counter_;
+  uint64_t NextStreamId();
+  std::unordered_map<std::string, std::string> resources_;
+  std::unordered_map<std::string, uint64_t> url_to_stream_id_;
+  std::atomic<uint64_t> stream_id_counter_{1};
+  Mutex mutex_;  // Protects access to resources_ and url_to_stream_id_
 };
 
 }  // namespace inspector

diff --git a/src/inspector/worker_inspector.cc b/src/inspector/worker_inspector.cc
@@ -60,12 +60,14 @@ ParentInspectorHandle::ParentInspectorHandle(
     const std::string& url,
     std::shared_ptr<MainThreadHandle> parent_thread,
     bool wait_for_connect,
-    const std::string& name)
+    const std::string& name,
+    std::shared_ptr<NetworkResourceManager> network_resource_manager)
     : id_(id),
       url_(url),
       parent_thread_(parent_thread),
       wait_(wait_for_connect),
-      name_(name) {}
+      name_(name),
+      network_resource_manager_(network_resource_manager) {}
 
 ParentInspectorHandle::~ParentInspectorHandle() {
   parent_thread_->Post(
@@ -101,10 +103,13 @@ void WorkerManager::WorkerStarted(uint64_t session_id,
 }
 
 std::unique_ptr<ParentInspectorHandle> WorkerManager::NewParentHandle(
-    uint64_t thread_id, const std::string& url, const std::string& name) {
+    uint64_t thread_id,
+    const std::string& url,
+    const std::string& name,
+    std::shared_ptr<NetworkResourceManager> network_resource_manager) {
   bool wait = !delegates_waiting_on_start_.empty();
   return std::make_unique<ParentInspectorHandle>(
-      thread_id, url, thread_, wait, name);
+      thread_id, url, thread_, wait, name, network_resource_manager);
 }
 
 void WorkerManager::RemoveAttachDelegate(int id) {

diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
@@ -1,6 +1,7 @@
 #ifndef SRC_INSPECTOR_WORKER_INSPECTOR_H_
 #define SRC_INSPECTOR_WORKER_INSPECTOR_H_
 
+#include "inspector/network_resource_manager.h"
 #if !HAVE_INSPECTOR
 #error("This header can only be used when inspector is enabled")
 #endif
@@ -54,16 +55,18 @@ struct WorkerInfo {
 
 class ParentInspectorHandle {
  public:
-  ParentInspectorHandle(uint64_t id,
-                        const std::string& url,
-                        std::shared_ptr<MainThreadHandle> parent_thread,
-                        bool wait_for_connect,
-                        const std::string& name);
+  ParentInspectorHandle(
+      uint64_t id,
+      const std::string& url,
+      std::shared_ptr<MainThreadHandle> parent_thread,
+      bool wait_for_connect,
+      const std::string& name,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
   ~ParentInspectorHandle();
   std::unique_ptr<ParentInspectorHandle> NewParentInspectorHandle(
       uint64_t thread_id, const std::string& url, const std::string& name) {
     return std::make_unique<ParentInspectorHandle>(
-        thread_id, url, parent_thread_, wait_, name);
+        thread_id, url, parent_thread_, wait_, name, network_resource_manager_);
   }
   void WorkerStarted(std::shared_ptr<MainThreadHandle> worker_thread,
                      bool waiting);
@@ -74,13 +77,17 @@ class ParentInspectorHandle {
   std::unique_ptr<inspector::InspectorSession> Connect(
       std::unique_ptr<inspector::InspectorSessionDelegate> delegate,
       bool prevent_shutdown);
+  std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager() {
+    return network_resource_manager_;
+  }
 
  private:
   uint64_t id_;
   std::string url_;
   std::shared_ptr<MainThreadHandle> parent_thread_;
   bool wait_;
   std::string name_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 
 class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
@@ -89,7 +96,10 @@ class WorkerManager : public std::enable_shared_from_this<WorkerManager> {
                          : thread_(thread) {}
 
   std::unique_ptr<ParentInspectorHandle> NewParentHandle(
-      uint64_t thread_id, const std::string& url, const std::string& name);
+      uint64_t thread_id,
+      const std::string& url,
+      const std::string& name,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
   void WorkerStarted(uint64_t session_id, const WorkerInfo& info, bool waiting);
   void WorkerFinished(uint64_t session_id);
   std::unique_ptr<WorkerManagerEventHandle> SetAutoAttach(