@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{18 → 22}/stream_base.h

@@ -51,7 +51,7 @@ class StreamReq {
 
   // TODO(RaisinTen): Update the return type to a Maybe, so that we can indicate
   // if there is a pending exception/termination.
-  inline void Done(int status, const char* error_str = nullptr);
+  void Done(int status, const char* error_str = nullptr);
   inline void Dispose();
 
   StreamBase* stream() const { return stream_; }
@@ -225,7 +225,7 @@ class StreamResource {
   // These need to be implemented on the readable side of this stream:
 
   // Start reading from the underlying resource. This is called by the consumer
-  // when more data is desired. Use `EmitAlloc()` and `EmitData()` to
+  // when more data is desired. Use `EmitAlloc()` and `EmitRead()` to
   // pass data along to the consumer.
   virtual int ReadStart() = 0;
   // Stop reading from the underlying resource. This is called by the
@@ -244,14 +244,21 @@ class StreamResource {
   // `*bufs` and `*count` accordingly. This is a no-op by default.
   // Return 0 for success and a libuv error code for failures.
   virtual int DoTryWrite(uv_buf_t** bufs, size_t* count);
-  // Initiate a write of data. If the write completes synchronously, return 0 on
-  // success (with bufs modified to indicate how much data was consumed) or a
-  // libuv error code on failure. If the write will complete asynchronously,
-  // return 0. When the write completes asynchronously, call req_wrap->Done()
-  // with 0 on success (with bufs modified to indicate how much data was
-  // consumed) or a libuv error code on failure. Do not call req_wrap->Done() if
-  // the write completes synchronously, that is, it should never be called
-  // before DoWrite() has returned.
+  // Indicates whether this subclass overrides the DoTryWrite
+  virtual inline bool HasDoTryWrite() const { return false; }
+  // Initiate a write of data.
+  // Upon an immediate failure, a libuv error code is returned,
+  // w->Done() will never be called and caller should free `bufs`.
+  // Otherwise, 0 is returned and w->Done(status) will be called
+  // with status set to either
+  //  (1) 0 after all data are written, or
+  //  (2) a libuv error code when an error occurs
+  // in either case, w->Done() will never be called before DoWrite() returns.
+  // When 0 is returned:
+  //  (1) memory specified by `bufs` and `count` must remain valid until
+  //      w->Done() gets called.
+  //  (2) `bufs` might or might not be changed, caller should not rely on this.
+  //  (3) `bufs` should be freed after w->Done() gets called.
   virtual int DoWrite(WriteWrap* w,
                       uv_buf_t* bufs,
                       size_t count,
@@ -271,7 +278,7 @@ class StreamResource {
   inline void PushStreamListener(StreamListener* listener);
   // Remove a listener, and, if this was the currently active one,
   // transfer ownership back to the previous listener.
-  inline void RemoveStreamListener(StreamListener* listener);
+  void RemoveStreamListener(StreamListener* listener);
 
  protected:
   // Call the current listener's OnStreamAlloc() method.
@@ -308,6 +315,8 @@ class StreamBase : public StreamResource {
     kInternalFieldCount
   };
 
+  static void AddMethods(IsolateData* isolate_data,
+                         v8::Local<v8::FunctionTemplate> target);
   static void AddMethods(Environment* env,
                          v8::Local<v8::FunctionTemplate> target);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
@@ -334,8 +343,7 @@ class StreamBase : public StreamResource {
   // ShutdownWrap object (that was created in JS), or a new one will be created.
   // Returns 1 in case of a synchronous completion, 0 in case of asynchronous
   // completion, and a libuv error case in case of synchronous failure.
-  inline int Shutdown(
-      v8::Local<v8::Object> req_wrap_obj = v8::Local<v8::Object>());
+  int Shutdown(v8::Local<v8::Object> req_wrap_obj = v8::Local<v8::Object>());
 
   // TODO(RaisinTen): Update the return type to a Maybe, so that we can indicate
   // if there is a pending exception/termination.
@@ -343,13 +351,17 @@ class StreamBase : public StreamResource {
   // WriteWrap object (that was created in JS), or a new one will be created.
   // This will first try to write synchronously using `DoTryWrite()`, then
   // asynchronously using `DoWrite()`.
+  // Caller can pass `skip_try_write` as true if it has already called
+  // `DoTryWrite()` and ends up with a partial write, or it knows that the
+  // write is too large to finish synchronously.
   // If the return value indicates a synchronous completion, no callback will
   // be invoked.
-  inline StreamWriteResult Write(
+  StreamWriteResult Write(
       uv_buf_t* bufs,
       size_t count,
       uv_stream_t* send_handle = nullptr,
-      v8::Local<v8::Object> req_wrap_obj = v8::Local<v8::Object>());
+      v8::Local<v8::Object> req_wrap_obj = v8::Local<v8::Object>(),
+      bool skip_try_write = false);
 
   // These can be overridden by subclasses to get more specific wrap instances.
   // For example, a subclass Foo could create a FooWriteWrap or FooShutdownWrap
@@ -401,7 +413,14 @@ class StreamBase : public StreamResource {
   EmitToJSStreamListener default_listener_;
 
   void SetWriteResult(const StreamWriteResult& res);
-  static void AddMethod(Environment* env,
+  static void AddAccessor(v8::Isolate* isolate,
+                          v8::Local<v8::Signature> sig,
+                          enum v8::PropertyAttribute attributes,
+                          v8::Local<v8::FunctionTemplate> t,
+                          JSMethodFunction* getter,
+                          JSMethodFunction* setter,
+                          v8::Local<v8::String> str);
+  static void AddMethod(v8::Isolate* isolate,
                         v8::Local<v8::Signature> sig,
                         enum v8::PropertyAttribute attributes,
                         v8::Local<v8::FunctionTemplate> t,

package/src/headers/{18 → 22}/stream_pipe.h

@@ -13,10 +13,9 @@ class StreamPipe : public AsyncWrap {
 
   void Unpipe(bool is_in_deletion = false);
 
-  // TODO(RaisinTen): Just like MessagePort, add the following overload:
-  // static StreamPipe* New(StreamBase* source, StreamBase* sink,
-  //                        v8::Local<v8::Object> obj);
-  // so that we can indicate if there is a pending exception/termination.
+  static v8::Maybe<StreamPipe*> New(StreamBase* source,
+                                    StreamBase* sink,
+                                    v8::Local<v8::Object> obj);
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Unpipe(const v8::FunctionCallbackInfo<v8::Value>& args);

package/src/headers/{16 → 22}/stream_wrap.h

@@ -52,6 +52,7 @@ class LibuvStreamWrap : public HandleWrap, public StreamBase {
   // Resource implementation
   int DoShutdown(ShutdownWrap* req_wrap) override;
   int DoTryWrite(uv_buf_t** bufs, size_t* count) override;
+  inline bool HasDoTryWrite() const override { return true; }
   int DoWrite(WriteWrap* w,
               uv_buf_t* bufs,
               size_t count,
@@ -105,7 +106,7 @@ class LibuvStreamWrap : public HandleWrap, public StreamBase {
 
   // Callbacks for libuv
   void OnUvAlloc(size_t suggested_size, uv_buf_t* buf);
-  void OnUvRead(ssize_t nread, const uv_buf_t* buf);
+  v8::Maybe<void> OnUvRead(ssize_t nread, const uv_buf_t* buf);
 
   static void AfterUvWrite(uv_write_t* req, int status);
   static void AfterUvShutdown(uv_shutdown_t* req, int status);

package/src/headers/{18 → 22}/string_bytes.h

@@ -37,19 +37,19 @@ class StringBytes {
  public:
   class InlineDecoder : public MaybeStackBuffer<char> {
    public:
-    inline v8::Maybe<bool> Decode(Environment* env,
+    inline v8::Maybe<void> Decode(Environment* env,
                                   v8::Local<v8::String> string,
                                   enum encoding enc) {
       size_t storage;
       if (!StringBytes::StorageSize(env->isolate(), string, enc).To(&storage))
-        return v8::Nothing<bool>();
+        return v8::Nothing<void>();
       AllocateSufficientStorage(storage);
       const size_t length =
           StringBytes::Write(env->isolate(), out(), storage, string, enc);
 
       // No zero terminator is included when using this method.
       SetLength(length);
-      return v8::Just(true);
+      return v8::JustVoid();
     }
 
     inline size_t size() const { return length(); }
@@ -75,8 +75,7 @@ class StringBytes {
                       char* buf,
                       size_t buflen,
                       v8::Local<v8::Value> val,
-                      enum encoding enc,
-                      int* chars_written = nullptr);
+                      enum encoding enc);
 
   // Take the bytes in the src, and turn it into a Buffer or String.
   static v8::MaybeLocal<v8::Value> Encode(v8::Isolate* isolate,
@@ -99,20 +98,12 @@ class StringBytes {
                                           enum encoding encoding,
                                           v8::Local<v8::Value>* error);
 
-  static size_t hex_encode(const char* src,
-                           size_t slen,
-                           char* dst,
-                           size_t dlen);
-
-  static std::string hex_encode(const char* src, size_t slen);
-
  private:
   static size_t WriteUCS2(v8::Isolate* isolate,
                           char* buf,
                           size_t buflen,
                           v8::Local<v8::String> str,
-                          int flags,
-                          size_t* chars_written);
+                          int flags);
 };
 
 }  // namespace node

package/src/headers/{14 → 22}/string_decoder-inl.h

@@ -7,12 +7,6 @@
 
 namespace node {
 
-void StringDecoder::SetEncoding(enum encoding encoding) {
-  state_[kBufferedBytes] = 0;
-  state_[kMissingBytes] = 0;
-  state_[kEncodingField] = encoding;
-}
-
 enum encoding StringDecoder::Encoding() const {
   return static_cast<enum encoding>(state_[kEncodingField]);
 }

package/src/headers/{16 → 22}/string_decoder.h

@@ -10,7 +10,6 @@ namespace node {
 class StringDecoder {
  public:
   StringDecoder() { state_[kEncodingField] = BUFFER; }
-  inline void SetEncoding(enum encoding encoding);
   inline enum encoding Encoding() const;
 
   inline char* IncompleteCharacterBuffer();

package/src/headers/{18 → 22}/tcp_wrap.h

@@ -50,7 +50,7 @@ class TCPWrap : public ConnectionWrap<TCPWrap, uv_tcp_t> {
 
   SET_NO_MEMORY_INFO()
   SET_SELF_SIZE(TCPWrap)
-  std::string MemoryInfoName() const override {
+  const char* MemoryInfoName() const override {
     switch (provider_type()) {
       case ProviderType::PROVIDER_TCPWRAP:
         return "TCPSocketWrap";

package/src/headers/{18 → 22}/threadpoolwork-inl.h

@@ -24,23 +24,36 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
-#include "util-inl.h"
 #include "node_internals.h"
+#include "tracing/trace_event.h"
+#include "util-inl.h"
 
 namespace node {
 
 void ThreadPoolWork::ScheduleWork() {
   env_->IncreaseWaitingRequestCounter();
+  TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(
+      TRACING_CATEGORY_NODE2(threadpoolwork, async), type_, this);
   int status = uv_queue_work(
       env_->event_loop(),
       &work_req_,
       [](uv_work_t* req) {
         ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
+        TRACE_EVENT_BEGIN0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                           self->type_);
         self->DoThreadPoolWork();
+        TRACE_EVENT_END0(TRACING_CATEGORY_NODE2(threadpoolwork, sync),
+                         self->type_);
       },
       [](uv_work_t* req, int status) {
         ThreadPoolWork* self = ContainerOf(&ThreadPoolWork::work_req_, req);
         self->env_->DecreaseWaitingRequestCounter();
+        TRACE_EVENT_NESTABLE_ASYNC_END1(
+            TRACING_CATEGORY_NODE2(threadpoolwork, async),
+            self->type_,
+            self,
+            "result",
+            status);
         self->AfterThreadPoolWork(status);
       });
   CHECK_EQ(status, 0);

package/src/headers/22/timers.h

@@ -0,0 +1,76 @@
+#ifndef SRC_TIMERS_H_
+#define SRC_TIMERS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "node_snapshotable.h"
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace timers {
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* env, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SET_BINDING_ID(timers_binding_data)
+  SERIALIZABLE_OBJECT_METHODS()
+
+  SET_NO_MEMORY_INFO()
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void SetupTimers(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void SlowGetLibuvNow(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static double FastGetLibuvNow(v8::Local<v8::Object> unused,
+                                v8::Local<v8::Object> receiver);
+  static double GetLibuvNowImpl(BindingData* data);
+
+  static void SlowScheduleTimer(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastScheduleTimer(v8::Local<v8::Object> unused,
+                                v8::Local<v8::Object> receiver,
+                                int64_t duration);
+  static void ScheduleTimerImpl(BindingData* data, int64_t duration);
+
+  static void SlowToggleTimerRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleTimerRef(v8::Local<v8::Object> unused,
+                                 v8::Local<v8::Object> receiver,
+                                 bool ref);
+  static void ToggleTimerRefImpl(BindingData* data, bool ref);
+
+  static void SlowToggleImmediateRef(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastToggleImmediateRef(v8::Local<v8::Object> unused,
+                                     v8::Local<v8::Object> receiver,
+                                     bool ref);
+  static void ToggleImmediateRefImpl(BindingData* data, bool ref);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> target);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterTimerExternalReferences(
+      ExternalReferenceRegistry* registry);
+
+ private:
+  static v8::CFunction fast_get_libuv_now_;
+  static v8::CFunction fast_schedule_timers_;
+  static v8::CFunction fast_toggle_timer_ref_;
+  static v8::CFunction fast_toggle_immediate_ref_;
+};
+
+}  // namespace timers
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_TIMERS_H_

package/src/headers/{18 → 22}/tracing/trace_event.h

@@ -321,7 +321,9 @@ class TraceEventHelper {
   static inline const uint8_t* GetCategoryGroupEnabled(const char* group) {
     v8::TracingController* controller = GetTracingController();
     static const uint8_t disabled = 0;
-    if (UNLIKELY(controller == nullptr)) return &disabled;
+    if (controller == nullptr) [[unlikely]] {
+      return &disabled;
+    }
     return controller->GetCategoryGroupEnabled(group);
   }
 };
@@ -483,13 +485,13 @@ static V8_INLINE uint64_t AddTraceEventWithTimestampImpl(
     const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
     const char** arg_names, const uint8_t* arg_types,
     const uint64_t* arg_values, unsigned int flags, int64_t timestamp) {
-  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertables[2];
+  std::unique_ptr<v8::ConvertableToTraceFormat> arg_convertibles[2];
   if (num_args > 0 && arg_types[0] == TRACE_VALUE_TYPE_CONVERTABLE) {
-    arg_convertables[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
+    arg_convertibles[0].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
         static_cast<intptr_t>(arg_values[0])));
   }
   if (num_args > 1 && arg_types[1] == TRACE_VALUE_TYPE_CONVERTABLE) {
-    arg_convertables[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
+    arg_convertibles[1].reset(reinterpret_cast<v8::ConvertableToTraceFormat*>(
         static_cast<intptr_t>(arg_values[1])));
   }
   // DCHECK_LE(num_args, 2);
@@ -498,7 +500,7 @@ static V8_INLINE uint64_t AddTraceEventWithTimestampImpl(
   if (controller == nullptr) return 0;
   return controller->AddTraceEventWithTimestamp(
       phase, category_group_enabled, name, scope, id, bind_id, num_args,
-      arg_names, arg_types, arg_values, arg_convertables, flags, timestamp);
+      arg_names, arg_types, arg_values, arg_convertibles, flags, timestamp);
 }
 
 static V8_INLINE void AddMetadataEventImpl(

package/src/headers/{16 → 22}/udp_wrap.h

@@ -32,6 +32,7 @@
 
 namespace node {
 
+class ExternalReferenceRegistry;
 class UDPWrapBase;
 
 // A listener that can be attached to an `UDPWrapBase` object and generally
@@ -110,6 +111,7 @@ class UDPWrapBase {
   static void RecvStart(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void RecvStop(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void AddMethods(Environment* env, v8::Local<v8::FunctionTemplate> t);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
  private:
   UDPListener* listener_ = nullptr;
@@ -126,6 +128,7 @@ class UDPWrap final : public HandleWrap,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context,
                          void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static void GetFD(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Open(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -144,12 +147,10 @@ class UDPWrap final : public HandleWrap,
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetMulticastInterface(
       const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetMulticastTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetMulticastLoopback(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetBroadcast(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetTTL(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void BufferSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSendQueueSize(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetSendQueueCount(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // UDPListener implementation
   uv_buf_t OnAlloc(size_t suggested_size) override;
@@ -172,6 +173,8 @@ class UDPWrap final : public HandleWrap,
 
   AsyncWrap* GetAsyncWrap() override;
 
+  inline uv_udp_t* GetLibuvHandle() { return &handle_; }
+
   static v8::MaybeLocal<v8::Object> Instantiate(Environment* env,
                                                 AsyncWrap* parent,
                                                 SocketType type);

package/src/headers/22/undici_version.h

@@ -0,0 +1,6 @@
+// This is an auto generated file, please do not edit.
+// Refer to tools/dep_updaters/update-undici.sh
+#ifndef SRC_UNDICI_VERSION_H_
+#define SRC_UNDICI_VERSION_H_
+#define UNDICI_VERSION "6.21.0"
+#endif  // SRC_UNDICI_VERSION_H_