use url as stream id

Author: islandryu

src/inspector/io_agent.cc

@@ -18,23 +18,7 @@ DispatchResponse IoAgent::read(const String& in_handle,
                                Maybe<int> in_size,
                                String* out_data,
                                bool* out_eof) {
-  std::string in_handle_str = in_handle;
-  uint64_t stream_id = 0;
-  bool is_number =
-      std::all_of(in_handle_str.begin(), in_handle_str.end(), ::isdigit);
-  if (!is_number) {
-    *out_data = "";
-    *out_eof = true;
-    return DispatchResponse::Success();
-  }
-  stream_id = std::stoull(in_handle_str);
-
-  std::string url = network_resource_manager_->GetUrlForStreamId(stream_id);
-  if (url.empty()) {
-    *out_data = "";
-    *out_eof = true;
-    return DispatchResponse::Success();
-  }
+  std::string url = in_handle;
   std::string txt = network_resource_manager_->Get(url);
   std::string_view txt_view(txt);
 
@@ -43,8 +27,8 @@ DispatchResponse IoAgent::read(const String& in_handle,
   if (in_offset.isJust()) {
     offset = in_offset.fromJust();
     offset_was_specified = true;
-  } else if (offset_map_.find(stream_id) != offset_map_.end()) {
-    offset = offset_map_[stream_id];
+  } else if (offset_map_.find(url) != offset_map_.end()) {
+    offset = offset_map_[url];
   }
   int size = 1 << 20;
   if (in_size.isJust()) {
@@ -55,7 +39,7 @@ DispatchResponse IoAgent::read(const String& in_handle,
     out_data->assign(out_view.data(), out_view.size());
     *out_eof = false;
     if (!offset_was_specified) {
-      offset_map_[stream_id] = offset + size;
+      offset_map_[url] = offset + size;
     }
   } else {
     *out_data = "";
@@ -66,15 +50,8 @@ DispatchResponse IoAgent::read(const String& in_handle,
 }
 
 DispatchResponse IoAgent::close(const String& in_handle) {
-  std::string in_handle_str = in_handle;
-  uint64_t stream_id = 0;
-  bool is_number =
-      std::all_of(in_handle_str.begin(), in_handle_str.end(), ::isdigit);
-  if (is_number) {
-    stream_id = std::stoull(in_handle_str);
-    // Use accessor to erase resource and mapping by stream id
-    network_resource_manager_->EraseByStreamId(stream_id);
-  }
+  std::string url = in_handle;
+  network_resource_manager_->Erase(url);
   return DispatchResponse::Success();
 }
 }  // namespace node::inspector::protocol

src/inspector/io_agent.h

@@ -22,7 +22,8 @@ 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::unordered_map<std::string, int> offset_map_ =
+      {};  // Maps stream_id to offset
   std::shared_ptr<NetworkResourceManager> network_resource_manager_;
 };
 }  // namespace node::inspector::protocol

src/inspector/network_agent.cc

@@ -358,10 +358,9 @@ protocol::DispatchResponse NetworkAgent::loadNetworkResource(
   std::string data = network_resource_manager_->Get(in_url);
   bool found = !data.empty();
   if (found) {
-    uint64_t stream_id = network_resource_manager_->GetStreamId(in_url);
     auto result = protocol::Network::LoadNetworkResourcePageResult::create()
                       .setSuccess(true)
-                      .setStream(std::to_string(stream_id))
+                      .setStream(in_url)
                       .build();
     *out_resource = std::move(result);
     return protocol::DispatchResponse::Success();

src/inspector/network_resource_manager.cc

@@ -11,7 +11,6 @@ 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) {
@@ -21,37 +20,9 @@ std::string NetworkResourceManager::Get(const std::string& url) {
   return {};
 }
 
-uint64_t NetworkResourceManager::NextStreamId() {
-  return ++stream_id_counter_;
-}
-
-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;
-    }
-  }
-  return std::string();
-}
-
-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) {
-      resources_.erase(it->first);
-      url_to_stream_id_.erase(it);
-      break;
-    }
-  }
-}
-
-uint64_t NetworkResourceManager::GetStreamId(const std::string& url) {
+void NetworkResourceManager::Erase(const std::string& stream_id) {
   Mutex::ScopedLock lock(mutex_);
-  auto it = url_to_stream_id_.find(url);
-  if (it != url_to_stream_id_.end()) return it->second;
-  return 0;
+  resources_.erase(stream_id);
 }
 
 }  // namespace inspector

src/inspector/network_resource_manager.h

@@ -15,19 +15,12 @@ class NetworkResourceManager {
   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
-  std::string GetUrlForStreamId(uint64_t stream_id);
   // Erase resource and mapping by stream id
-  void EraseByStreamId(uint64_t stream_id);
-  // Returns the stream id for a given url, or 0 if not found
-  uint64_t GetStreamId(const std::string& url);
+  void Erase(const std::string& stream_id);
 
  private:
-  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_
+  Mutex mutex_;  // Protects access to resources_
 };
 
 }  // namespace inspector

test/parallel/test-inspector-network-resource.js

@@ -13,6 +13,7 @@ const fs = require('fs');
 const resourceUrl = 'http://localhost:3000/app.js';
 const resourcePath = path.join(__dirname, '../fixtures/inspector-network-resource/app.js.map');
 
+const resourceText = fs.readFileSync(resourcePath, 'utf8');
 const script = `
   const { NetworkResources } = require('node:inspector');
   const fs = require('fs');
@@ -55,8 +56,7 @@ test('should load and stream a static network resource using loadNetworkResource
     eof = result.eof;
   }
   content += data;
-  const expected = fs.readFileSync(resourcePath, 'utf8');
-  assert.strictEqual(content, expected);
+  assert.strictEqual(content, resourceText);
   await session.send({ method: 'IO.close', params: { handle: resource.stream } });
   await session.send({ method: 'Debugger.resume' });
   await session.waitForDisconnect();
@@ -98,13 +98,12 @@ test('should support IO.read with size and offset', async () => {
   });
   assert(resource.success);
   assert(resource.stream);
-  const expected = fs.readFileSync(resourcePath, 'utf8');
   let result = await session.send({ method: 'IO.read', params: { handle: resource.stream, size: 5 } });
-  assert.strictEqual(result.data, expected.slice(0, 5));
+  assert.strictEqual(result.data, resourceText.slice(0, 5));
   result = await session.send({ method: 'IO.read', params: { handle: resource.stream, offset: 5, size: 5 } });
-  assert.strictEqual(result.data, expected.slice(5, 10));
+  assert.strictEqual(result.data, resourceText.slice(5, 10));
   result = await session.send({ method: 'IO.read', params: { handle: resource.stream, offset: 10 } });
-  assert.strictEqual(result.data, expected.slice(10));
+  assert.strictEqual(result.data, resourceText.slice(10));
   await session.send({ method: 'IO.close', params: { handle: resource.stream } });
   await session.send({ method: 'Debugger.resume' });
   await session.waitForDisconnect();
@@ -131,12 +130,16 @@ test('should load resource put from another thread', async () => {
   await setupInspector(session);
   await session.waitForNotification('Debugger.paused');
   await session.send({ method: 'Debugger.resume' });
-  const sessionId = '1';
   await session.waitForNotification('Target.targetCreated');
   await session.send({ method: 'Target.setAutoAttach', params: { autoAttach: true, waitForDebuggerOnStart: true } });
+  let sessionId;
   await session.waitForNotification((notification) => {
-    return notification.method === 'Target.attachedToTarget' &&
-           notification.params.sessionId === sessionId;
+    if (notification.method === 'Target.attachedToTarget') {
+      sessionId = notification.params.sessionId;
+      return true;
+    }
+    return false;
+
   });
   await setupInspector(session, sessionId);
 
@@ -160,8 +163,7 @@ test('should load resource put from another thread', async () => {
     eof = result.eof;
   }
   content += data;
-  const expected = fs.readFileSync(resourcePath, 'utf8');
-  assert.strictEqual(content, expected);
+  assert.strictEqual(content, resourceText);
   await session.send({ method: 'IO.close', params: { handle: resource.stream, sessionId } });
 
   await session.send({ method: 'Debugger.resume', sessionId });