avoid making networkResourceManager a static class.

islandryu · islandryu · commit 688e313bad97 · 2025-06-30T00:41:00.000+09:00
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,16 @@
 #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 +22,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,10 @@ protocol::DispatchResponse NetworkAgent::loadNetworkResource(
         "experimental and requires --experimental-inspector-network-resource "
         "flag to be set.");
   }
-  std::string data = NetworkResourceManager::Get(in_url);
+  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,11 +7,6 @@
 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) {
   resources_[url] = data;
diff --git a/src/inspector/network_resource_manager.h b/src/inspector/network_resource_manager.h
@@ -11,21 +11,21 @@ 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};
 };
 
 }  // 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(
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
@@ -13,6 +13,7 @@
 #include "inspector/worker_agent.h"
 #include "inspector/worker_inspector.h"
 #include "inspector_io.h"
+#include "node.h"
 #include "node/inspector/protocol/Protocol.h"
 #include "node_errors.h"
 #include "node_internals.h"
@@ -240,11 +241,17 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     runtime_agent_ = std::make_unique<protocol::RuntimeAgent>();
     runtime_agent_->Wire(node_dispatcher_.get());
     if (env->options()->experimental_inspector_network_resource) {
-      io_agent_ = std::make_unique<protocol::IoAgent>();
+      io_agent_ = std::make_unique<protocol::IoAgent>(
+          env->inspector_agent()->GetNetworkResourceManager());
       io_agent_->Wire(node_dispatcher_.get());
+      network_inspector_ = std::make_unique<NetworkInspector>(
+          env,
+          inspector.get(),
+          env->inspector_agent()->GetNetworkResourceManager());
+    } else {
+      network_inspector_ =
+          std::make_unique<NetworkInspector>(env, inspector.get(), nullptr);
     }
-    network_inspector_ =
-        std::make_unique<NetworkInspector>(env, inspector.get());
     network_inspector_->Wire(node_dispatcher_.get());
     if (env->options()->experimental_worker_inspection) {
       target_agent_ = std::make_shared<protocol::TargetAgent>();
@@ -1159,7 +1166,8 @@ std::unique_ptr<ParentInspectorHandle> Agent::GetParentHandle(
 
   CHECK_NOT_NULL(client_);
   if (!parent_handle_) {
-    return client_->getWorkerManager()->NewParentHandle(thread_id, url, name);
+    return client_->getWorkerManager()->NewParentHandle(
+        thread_id, url, name, GetNetworkResourceManager());
   } else {
     return parent_handle_->NewParentInspectorHandle(thread_id, url, name);
   }
@@ -1225,6 +1233,17 @@ std::shared_ptr<WorkerManager> Agent::GetWorkerManager() {
   return client_->getWorkerManager();
 }
 
+std::shared_ptr<NetworkResourceManager> Agent::GetNetworkResourceManager() {
+  if (parent_handle_) {
+    return parent_handle_->GetNetworkResourceManager();
+  } else if (network_resource_manager_) {
+    return network_resource_manager_;
+  } else {
+    network_resource_manager_ = std::make_shared<NetworkResourceManager>();
+    return network_resource_manager_;
+  }
+}
+
 std::string Agent::GetWsUrl() const {
   if (io_ == nullptr)
     return "";
diff --git a/src/inspector_agent.h b/src/inspector_agent.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "inspector/network_resource_manager.h"
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #if !HAVE_INSPECTOR
@@ -127,6 +128,7 @@ class Agent {
   std::shared_ptr<WorkerManager> GetWorkerManager();
 
   inline Environment* env() const { return parent_env_; }
+  std::shared_ptr<NetworkResourceManager> GetNetworkResourceManager();
 
  private:
   void ToggleAsyncHook(v8::Isolate* isolate, v8::Local<v8::Function> fn);
@@ -153,6 +155,7 @@ class Agent {
   bool network_tracking_enabled_ = false;
   bool pending_enable_network_tracking = false;
   bool pending_disable_network_tracking = false;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 
 }  // namespace inspector
diff --git a/src/inspector_js_api.cc b/src/inspector_js_api.cc
@@ -344,7 +344,7 @@ void PutNetworkResource(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Utf8Value url(env->isolate(), args[0].As<String>());
   Utf8Value data(env->isolate(), args[1].As<String>());
 
-  NetworkResourceManager::Put(*url, *data);
+  env->inspector_agent()->GetNetworkResourceManager()->Put(*url, *data);
 }
 
 void Initialize(Local<Object> target, Local<Value> unused,
diff --git a/test/parallel/test-inspector-network-resource.js b/test/parallel/test-inspector-network-resource.js

Original file line number	Diff line number	Diff line change
`@@ -29,13 +29,13 @@ DispatchResponse IoAgent::read(const String& in_handle,`
`29`	`29`	`}`
`30`	`30`	`stream_id = std::stoull(in_handle_str);`
`31`	`31`
`32`		`- std::string url = NetworkResourceManager::GetUrlForStreamId(stream_id);`
	`32`	`+ std::string url = network_resource_manager_->GetUrlForStreamId(stream_id);`
`33`	`33`	`if (url.empty()) {`
`34`	`34`	`*out_data = "";`
`35`	`35`	`*out_eof = true;`
`36`	`36`	`return DispatchResponse::Success();`
`37`	`37`	`}`
`38`		`- std::string txt = NetworkResourceManager::Get(url);`
	`38`	`+ std::string txt = network_resource_manager_->Get(url);`
`39`	`39`	`std::string_view txt_view(txt);`
`40`	`40`
`41`	`41`	`int offset = 0;`
`@@ -73,7 +73,7 @@ DispatchResponse IoAgent::close(const String& in_handle) {`
`73`	`73`	`if (is_number) {`
`74`	`74`	`stream_id = std::stoull(in_handle_str);`
`75`	`75`	`// Use accessor to erase resource and mapping by stream id`
`76`		`- NetworkResourceManager::EraseByStreamId(stream_id);`
	`76`	`+ network_resource_manager_->EraseByStreamId(stream_id);`
`77`	`77`	`}`
`78`	`78`	`return DispatchResponse::Success();`
`79`	`79`	`}`