@kungfu-tech/libnode-win32-x64 22.22.3-kf.0 → 22.22.3-kf.1

package/dist/node/include/inspector/network_agent.h

@@ -0,0 +1,94 @@
+#ifndef SRC_INSPECTOR_NETWORK_AGENT_H_
+#define SRC_INSPECTOR_NETWORK_AGENT_H_
+
+#include "env.h"
+#include "io_agent.h"
+#include "network_requests_buffer.h"
+#include "network_resource_manager.h"
+#include "node/inspector/protocol/Network.h"
+
+#include <map>
+#include <memory>
+#include <unordered_map>
+
+namespace node {
+namespace inspector {
+
+class NetworkInspector;
+
+class NetworkAgent : public protocol::Network::Backend {
+ public:
+  explicit NetworkAgent(
+      NetworkInspector* inspector,
+      v8_inspector::V8Inspector* v8_inspector,
+      Environment* env,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
+
+  void Wire(protocol::UberDispatcher* dispatcher);
+
+  protocol::DispatchResponse enable(
+      std::optional<int> in_maxTotalBufferSize,
+      std::optional<int> in_maxResourceBufferSize) override;
+
+  protocol::DispatchResponse disable() override;
+
+  protocol::DispatchResponse getRequestPostData(
+      const protocol::String& in_requestId,
+      protocol::String* out_postData) override;
+
+  protocol::DispatchResponse getResponseBody(
+      const protocol::String& in_requestId,
+      protocol::String* out_body,
+      bool* out_base64Encoded) override;
+
+  protocol::DispatchResponse streamResourceContent(
+      const protocol::String& in_requestId,
+      protocol::Binary* out_bufferedData) override;
+
+  protocol::DispatchResponse loadNetworkResource(
+      const protocol::String& in_url,
+      std::unique_ptr<protocol::Network::LoadNetworkResourcePageResult>*
+          out_resource) override;
+
+  void emitNotification(v8::Local<v8::Context> context,
+                        const protocol::String& event,
+                        v8::Local<v8::Object> params);
+
+  void requestWillBeSent(v8::Local<v8::Context> context,
+                         v8::Local<v8::Object> params);
+
+  void responseReceived(v8::Local<v8::Context> context,
+                        v8::Local<v8::Object> params);
+
+  void loadingFailed(v8::Local<v8::Context> context,
+                     v8::Local<v8::Object> params);
+
+  void loadingFinished(v8::Local<v8::Context> context,
+                       v8::Local<v8::Object> params);
+
+  void dataSent(v8::Local<v8::Context> context, v8::Local<v8::Object> params);
+
+  void dataReceived(v8::Local<v8::Context> context,
+                    v8::Local<v8::Object> params);
+
+ private:
+  NetworkInspector* inspector_;
+  v8_inspector::V8Inspector* v8_inspector_;
+  std::shared_ptr<protocol::Network::Frontend> frontend_;
+
+  using EventNotifier = void (NetworkAgent::*)(v8::Local<v8::Context> context,
+                                               v8::Local<v8::Object>);
+  std::unordered_map<protocol::String, EventNotifier> event_notifier_map_;
+  Environment* env_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+
+  // Per-resource buffer size in bytes to use when preserving network payloads
+  // (XHRs, etc).
+  size_t max_resource_buffer_size_ = 5 * 1024 * 1024;  // 5MB
+  RequestsBuffer requests_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_AGENT_H_

package/dist/node/include/inspector/network_inspector.h

@@ -0,0 +1,45 @@
+#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;
+
+namespace inspector {
+
+class NetworkInspector {
+ public:
+  explicit NetworkInspector(
+      Environment* env,
+      v8_inspector::V8Inspector* v8_inspector,
+      std::shared_ptr<NetworkResourceManager> network_resource_manager);
+  ~NetworkInspector();
+
+  void Wire(protocol::UberDispatcher* dispatcher);
+
+  bool canEmit(const std::string& domain);
+
+  void emitNotification(v8::Local<v8::Context> context,
+                        const std::string& domain,
+                        const std::string& method,
+                        v8::Local<v8::Object> params);
+
+  void Enable();
+  void Disable();
+  bool IsEnabled() const { return enabled_; }
+
+ private:
+  bool enabled_;
+  Environment* env_;
+  std::unique_ptr<NetworkAgent> network_agent_;
+  std::shared_ptr<NetworkResourceManager> network_resource_manager_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_INSPECTOR_H_

package/dist/node/include/inspector/network_requests_buffer.h

@@ -0,0 +1,195 @@
+#ifndef SRC_INSPECTOR_NETWORK_REQUESTS_BUFFER_H_
+#define SRC_INSPECTOR_NETWORK_REQUESTS_BUFFER_H_
+
+#include <list>
+#include <map>
+#include <vector>
+
+#include "inspector/node_string.h"
+
+namespace node {
+namespace inspector {
+
+// Supported charsets for devtools frontend on request/response data.
+// If the charset is kUTF8, the data is expected to be text and can be
+// formatted on the frontend.
+enum class Charset {
+  kUTF8,
+  kBinary,
+};
+
+struct RequestEntry {
+  double timestamp;
+  bool is_request_finished = false;
+  bool is_response_finished = false;
+  bool is_streaming = false;
+  Charset request_charset;
+  Charset response_charset = Charset::kBinary;
+
+  size_t max_resource_buffer_size;
+  size_t buffer_size() const {
+    return request_data_size_ + response_data_size_;
+  }
+
+  const std::vector<protocol::Binary> request_data_blobs() const {
+    return request_data_blobs_;
+  }
+  const std::vector<protocol::Binary> response_data_blobs() const {
+    return response_data_blobs_;
+  }
+
+  void push_request_data_blob(const protocol::Binary& blob) {
+    if (buffer_size() + blob.size() > max_resource_buffer_size) {
+      // Exceed the per-resource buffer size limit, ignore the blob.
+      return;
+    }
+    request_data_blobs_.push_back(blob);
+    request_data_size_ += blob.size();
+  }
+  void push_response_data_blob(const protocol::Binary& blob) {
+    if (buffer_size() + blob.size() > max_resource_buffer_size) {
+      // Exceed the per-resource buffer size limit, ignore the blob.
+      return;
+    }
+    response_data_blobs_.push_back(blob);
+    response_data_size_ += blob.size();
+  }
+
+  void clear_response_data_blobs() {
+    response_data_blobs_.clear();
+    response_data_size_ = 0;
+  }
+
+  RequestEntry(double timestamp,
+               Charset request_charset,
+               bool has_request_body,
+               size_t max_resource_buffer_size)
+      : timestamp(timestamp),
+        is_request_finished(!has_request_body),
+        request_charset(request_charset),
+        max_resource_buffer_size(max_resource_buffer_size) {}
+
+ private:
+  size_t request_data_size_ = 0;
+  std::vector<protocol::Binary> request_data_blobs_;
+  size_t response_data_size_ = 0;
+  std::vector<protocol::Binary> response_data_blobs_;
+};
+
+class RequestsBuffer {
+  using key_value_pair_t = typename std::pair<protocol::String, RequestEntry>;
+  using list_iterator = typename std::list<key_value_pair_t>::iterator;
+  using const_list_iterator =
+      typename std::list<key_value_pair_t>::const_iterator;
+
+ public:
+  struct mutable_iterator {
+    list_iterator it;
+    size_t buffer_size;
+    RequestsBuffer* parent;
+
+    key_value_pair_t& operator*() { return *it; }
+    key_value_pair_t* operator->() { return &(*it); }
+    bool operator==(const const_list_iterator& other) const {
+      return it == other;
+    }
+    bool operator!=(const const_list_iterator& other) const {
+      return it != other;
+    }
+
+    mutable_iterator(std::nullptr_t, RequestsBuffer* parent)
+        : it(parent->list_.end()), buffer_size(0), parent(parent) {}
+
+    mutable_iterator(list_iterator it, RequestsBuffer* parent)
+        : it(it), buffer_size(it->second.buffer_size()), parent(parent) {}
+    ~mutable_iterator() {
+      if (it == parent->list_.end()) return;
+      // The entry must not have been erased.
+      DCHECK(parent->lookup_map_.contains(it->first));
+      // Update the total buffer size if the buffer size has changed.
+      if (buffer_size == it->second.buffer_size()) {
+        return;
+      }
+      parent->total_buffer_size_ += it->second.buffer_size();
+      DCHECK_GE(parent->total_buffer_size_, buffer_size);
+      parent->total_buffer_size_ -= buffer_size;
+      parent->enforceBufferLimits();
+    }
+  };
+
+  explicit RequestsBuffer(size_t max_total_buffer_size)
+      : max_total_buffer_size_(max_total_buffer_size) {}
+
+  size_t max_total_buffer_size() const { return max_total_buffer_size_; }
+  size_t total_buffer_size() const { return total_buffer_size_; }
+
+  const_list_iterator begin() const { return list_.begin(); }
+  const_list_iterator end() const { return list_.end(); }
+
+  // Get a mutable iterator to the entry with the given key.
+  // The iterator will update the total buffer size when it is destroyed.
+  mutable_iterator find(const protocol::String& key) {
+    auto it = lookup_map_.find(key);
+    if (it == lookup_map_.end()) {
+      return mutable_iterator(nullptr, this);
+    }
+    return mutable_iterator(it->second, this);
+  }
+  const_list_iterator cfind(const protocol::String& key) const {
+    auto it = lookup_map_.find(key);
+    if (it == lookup_map_.end()) {
+      return list_.end();
+    }
+    return it->second;
+  }
+
+  bool contains(const protocol::String& key) const {
+    return lookup_map_.contains(key);
+  }
+
+  bool emplace(const protocol::String& key, RequestEntry&& value) {
+    if (lookup_map_.contains(key)) {
+      return false;
+    }
+    list_.emplace_front(key, std::move(value));
+    lookup_map_[key] = list_.begin();
+    // No buffer yet.
+    DCHECK_EQ(begin()->second.buffer_size(), 0u);
+    return true;
+  }
+
+  void erase(const protocol::String& key) {
+    auto it = lookup_map_.find(key);
+    if (it == lookup_map_.end()) {
+      return;
+    }
+    erase(it->second);
+  }
+
+  void erase(const_list_iterator it) {
+    DCHECK(it != list_.end());
+    DCHECK_GE(total_buffer_size_, it->second.buffer_size());
+    total_buffer_size_ -= it->second.buffer_size();
+    lookup_map_.erase(it->first);
+    list_.erase(it);
+  }
+
+ private:
+  void enforceBufferLimits() {
+    while (total_buffer_size_ > max_total_buffer_size_ && !list_.empty()) {
+      auto last_it = --list_.end();
+      erase(last_it);
+    }
+  }
+
+  size_t max_total_buffer_size_;
+  size_t total_buffer_size_ = 0;
+
+  std::list<key_value_pair_t> list_;
+  std::map<protocol::String, list_iterator> lookup_map_;
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_REQUESTS_BUFFER_H_

package/dist/node/include/inspector/network_resource_manager.h

@@ -0,0 +1,29 @@
+// network_resource_manager.h
+#ifndef SRC_INSPECTOR_NETWORK_RESOURCE_MANAGER_H_
+#define SRC_INSPECTOR_NETWORK_RESOURCE_MANAGER_H_
+
+#include <atomic>
+#include <string>
+#include <unordered_map>
+#include "node_mutex.h"
+
+namespace node {
+namespace inspector {
+
+class NetworkResourceManager {
+ public:
+  void Put(const std::string& url, const std::string& data);
+  std::string Get(const std::string& url);
+
+  // Erase resource and mapping by stream id
+  void Erase(const std::string& stream_id);
+
+ private:
+  std::unordered_map<std::string, std::string> resources_;
+  Mutex mutex_;  // Protects access to resources_
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NETWORK_RESOURCE_MANAGER_H_

package/dist/node/include/inspector/node_json.h

@@ -0,0 +1,24 @@
+#ifndef SRC_INSPECTOR_NODE_JSON_H_
+#define SRC_INSPECTOR_NODE_JSON_H_
+
+#include "node/inspector/protocol/Protocol.h"
+
+namespace node {
+namespace inspector {
+
+struct JsonUtil {
+  // Parse s JSON string into protocol::Value.
+  static std::unique_ptr<protocol::Value> ParseJSON(const uint8_t* chars,
+                                                    size_t size);
+  static std::unique_ptr<protocol::Value> ParseJSON(const uint16_t* chars,
+                                                    size_t size);
+
+  static std::unique_ptr<protocol::Value> parseJSON(const std::string_view);
+  static std::unique_ptr<protocol::Value> parseJSON(
+      v8_inspector::StringView view);
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NODE_JSON_H_

package/dist/node/include/inspector/node_string.h

@@ -0,0 +1,101 @@
+// Bridges V8 Inspector generated code with the std::string used by the Node
+// Compare to V8 counterpart - deps/v8/src/inspector/string-util.h
+#ifndef SRC_INSPECTOR_NODE_STRING_H_
+#define SRC_INSPECTOR_NODE_STRING_H_
+
+#include <cstring>
+#include <sstream>
+#include <string>
+#include "crdtp/protocol_core.h"
+#include "util.h"
+#include "v8-inspector.h"
+
+namespace node::inspector::protocol {
+class Binary;
+}
+
+namespace crdtp {
+
+template <>
+struct ProtocolTypeTraits<std::string> {
+  static bool Deserialize(DeserializerState* state, std::string* value);
+  static void Serialize(const std::string& value, std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct ProtocolTypeTraits<node::inspector::protocol::Binary> {
+  static bool Deserialize(DeserializerState* state,
+                          node::inspector::protocol::Binary* value);
+  static void Serialize(const node::inspector::protocol::Binary& value,
+                        std::vector<uint8_t>* bytes);
+};
+
+}  // namespace crdtp
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+class Value;
+
+using String = std::string;
+using StringBuilder = std::ostringstream;
+using ProtocolMessage = std::string;
+
+// Implements StringUtil methods used in `inspector_protocol/lib/`.
+// Refer to
+// https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/inspector/v8_inspector_string.h;l=40;drc=2b15d6974a49d3a14d3d67ae099a649d523a828d
+// for more details about the interface.
+struct StringUtil {
+  // Convert Utf16 in local endianness to Utf8 if needed.
+  static String StringViewToUtf8(v8_inspector::StringView view);
+  static String fromUTF16(const uint16_t* data, size_t length);
+
+  static String fromUTF8(const uint8_t* data, size_t length);
+  static String fromUTF16LE(const uint16_t* data, size_t length);
+  static const uint8_t* CharactersUTF8(const std::string_view s);
+  static size_t CharacterCount(const std::string_view s);
+
+  // Unimplemented. The generated code will fall back to CharactersUTF8().
+  inline static uint8_t* CharactersLatin1(const std::string_view s) {
+    return nullptr;
+  }
+  inline static const uint16_t* CharactersUTF16(const std::string_view s) {
+    return nullptr;
+  }
+};
+
+// A read-only sequence of uninterpreted bytes with reference-counted storage.
+class Binary {
+ public:
+  Binary() : bytes_(std::make_shared<std::vector<uint8_t>>()) {}
+
+  const uint8_t* data() const { return bytes_->data(); }
+  size_t size() const { return bytes_->size(); }
+
+  String toBase64() const;
+
+  static Binary concat(const std::vector<Binary>& binaries);
+
+  static Binary fromBase64(const String& base64, bool* success);
+  static Binary fromUint8Array(v8::Local<v8::Uint8Array> data);
+  static Binary fromSpan(const uint8_t* data, size_t size) {
+    return Binary::fromSpan(crdtp::span<uint8_t>(data, size));
+  }
+  static Binary fromSpan(crdtp::span<uint8_t> span) {
+    return Binary(
+        std::make_shared<std::vector<uint8_t>>(span.begin(), span.end()));
+  }
+
+ private:
+  std::shared_ptr<std::vector<uint8_t>> bytes_;
+
+  explicit Binary(std::shared_ptr<std::vector<uint8_t>> bytes)
+      : bytes_(bytes) {}
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NODE_STRING_H_

package/dist/node/include/inspector/protocol_helper.h

@@ -0,0 +1,27 @@
+#ifndef SRC_INSPECTOR_PROTOCOL_HELPER_H_
+#define SRC_INSPECTOR_PROTOCOL_HELPER_H_
+
+#include "node/inspector/protocol/Protocol.h"
+#include "util.h"
+#include "v8-inspector.h"
+
+namespace node::inspector {
+
+// Convert a V8 string to v8_inspector StringBuffer, encoded in UTF16.
+inline std::unique_ptr<v8_inspector::StringBuffer> ToInspectorString(
+    v8::Isolate* isolate, v8::Local<v8::Value> value) {
+  TwoByteValue buffer(isolate, value);
+  return v8_inspector::StringBuffer::create(
+      v8_inspector::StringView(*buffer, buffer.length()));
+}
+
+// Convert a V8 string to node::inspector::protocol::String, encoded in UTF8.
+inline protocol::String ToProtocolString(v8::Isolate* isolate,
+                                         v8::Local<v8::Value> value) {
+  Utf8Value buffer(isolate, value);
+  return buffer.ToString();
+}
+
+}  // namespace node::inspector
+
+#endif  // SRC_INSPECTOR_PROTOCOL_HELPER_H_

package/dist/node/include/inspector/runtime_agent.h

@@ -0,0 +1,41 @@
+#ifndef SRC_INSPECTOR_RUNTIME_AGENT_H_
+#define SRC_INSPECTOR_RUNTIME_AGENT_H_
+
+#include "node/inspector/protocol/NodeRuntime.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+
+namespace inspector {
+namespace protocol {
+
+class RuntimeAgent : public NodeRuntime::Backend {
+ public:
+  RuntimeAgent();
+
+  void Wire(UberDispatcher* dispatcher);
+
+  DispatchResponse notifyWhenWaitingForDisconnect(bool enabled) override;
+
+  DispatchResponse enable() override;
+
+  DispatchResponse disable() override;
+
+  bool notifyWaitingForDisconnect();
+
+  void setWaitingForDebugger();
+
+  void unsetWaitingForDebugger();
+
+ private:
+  std::shared_ptr<NodeRuntime::Frontend> frontend_;
+  bool notify_when_waiting_for_disconnect_;
+  bool enabled_;
+  bool is_waiting_for_debugger_;
+};
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_RUNTIME_AGENT_H_

package/dist/node/include/inspector/target_agent.h

@@ -0,0 +1,75 @@
+#ifndef SRC_INSPECTOR_TARGET_AGENT_H_
+#define SRC_INSPECTOR_TARGET_AGENT_H_
+
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+#include "inspector/worker_inspector.h"
+#include "node/inspector/protocol/Target.h"
+
+namespace node {
+
+namespace inspector {
+class TargetInspector;
+
+namespace protocol {
+
+struct TargetInfo {
+  std::string target_id;
+  std::string type;
+  std::string title;
+  std::string url;
+  std::shared_ptr<MainThreadHandle> worker;
+  bool attached;
+};
+
+class TargetAgent : public Target::Backend,
+                    public std::enable_shared_from_this<TargetAgent> {
+ public:
+  void Wire(UberDispatcher* dispatcher);
+
+  void createAndAttachIfNecessary(std::shared_ptr<MainThreadHandle> worker,
+                                  const std::string& title,
+                                  const std::string& url);
+
+  DispatchResponse setAutoAttach(bool auto_attach,
+                                 bool wait_for_debugger_on_start) override;
+
+  void listenWorker(std::weak_ptr<WorkerManager> worker_manager);
+  void reset();
+  static std::unordered_map<int, std::shared_ptr<MainThreadHandle>>
+      target_session_id_worker_map_;
+
+  bool isThisThread(MainThreadHandle* worker) { return worker == main_thread_; }
+
+ private:
+  int getNextTargetId();
+  int getNextSessionId();
+  void targetCreated(const std::string_view target_id,
+                     const std::string_view type,
+                     const std::string_view title,
+                     const std::string_view 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);
+
+  std::shared_ptr<Target::Frontend> frontend_;
+  std::weak_ptr<WorkerManager> worker_manager_;
+  static int next_session_id_;
+  int next_target_id_ = 1;
+  std::unique_ptr<WorkerManagerEventHandle> worker_event_handle_ = nullptr;
+  bool auto_attach_ = false;
+  // TODO(islandryu): If false, implement it so that each thread does not wait
+  // for the worker to execute.
+  bool wait_for_debugger_on_start_ = true;
+  std::vector<TargetInfo> targets_;
+  MainThreadHandle* main_thread_;
+};
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TARGET_AGENT_H_

package/dist/node/include/inspector/tracing_agent.h

@@ -0,0 +1,43 @@
+#ifndef SRC_INSPECTOR_TRACING_AGENT_H_
+#define SRC_INSPECTOR_TRACING_AGENT_H_
+
+#include "node/inspector/protocol/NodeTracing.h"
+#include "tracing/agent.h"
+#include "v8.h"
+
+
+namespace node {
+class Environment;
+
+namespace inspector {
+class MainThreadHandle;
+
+namespace protocol {
+
+class TracingAgent : public NodeTracing::Backend {
+ public:
+  explicit TracingAgent(Environment*, std::shared_ptr<MainThreadHandle>);
+  ~TracingAgent() override;
+
+  void Wire(UberDispatcher* dispatcher);
+
+  DispatchResponse start(
+      std::unique_ptr<protocol::NodeTracing::TraceConfig> traceConfig) override;
+  DispatchResponse stop() override;
+  DispatchResponse getCategories(
+      std::unique_ptr<protocol::Array<String>>* categories) override;
+
+ private:
+  Environment* env_;
+  std::shared_ptr<MainThreadHandle> main_thread_;
+  tracing::AgentWriterHandle trace_writer_;
+  int frontend_object_id_ = 0;
+  std::shared_ptr<NodeTracing::Frontend> frontend_;
+};
+
+
+}  // namespace protocol
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_TRACING_AGENT_H_