@encharm/cws 4.1.0 → 4.2.0

package/src/headers/{13 → 18}/node_messaging.h

@@ -5,7 +5,11 @@
 
 #include "env.h"
 #include "node_mutex.h"
-#include <list>
+#include "v8.h"
+#include <deque>
+#include <string>
+#include <unordered_map>
+#include <set>
 
 namespace node {
 namespace worker {
@@ -15,6 +19,29 @@ class MessagePort;
 
 typedef MaybeStackBuffer<v8::Local<v8::Value>, 8> TransferList;
 
+// Used to represent the in-flight structure of an object that is being
+// transferred or cloned using postMessage().
+class TransferData : public MemoryRetainer {
+ public:
+  // Deserialize this object on the receiving end after a .postMessage() call.
+  // - `context` may not be the same as `env->context()`. This method should
+  //    not produce JS objects coming from Contexts other than `context`.
+  // - `self` is a unique_ptr for the object that this is being called on.
+  // - The return value is treated like a `Maybe`, i.e. if `nullptr` is
+  //   returned, any further deserialization of the message is stopped and
+  //   control is returned to the event loop or JS as soon as possible.
+  virtual BaseObjectPtr<BaseObject> Deserialize(
+      Environment* env,
+      v8::Local<v8::Context> context,
+      std::unique_ptr<TransferData> self) = 0;
+  // FinalizeTransferWrite() is the counterpart to
+  // BaseObject::FinalizeTransferRead(). It is called right after the transfer
+  // data was created, and defaults to doing nothing. After this function,
+  // this object should not hold any more Isolate-specific data.
+  virtual v8::Maybe<bool> FinalizeTransferWrite(
+      v8::Local<v8::Context> context, v8::ValueSerializer* serializer);
+};
+
 // Represents a single communication message.
 class Message : public MemoryRetainer {
  public:
@@ -22,6 +49,7 @@ class Message : public MemoryRetainer {
   // V8 ValueSerializer API. If `payload` is empty, this message indicates
   // that the receiving message port should close itself.
   explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
+  ~Message() = default;
 
   Message(Message&& other) = default;
   Message& operator=(Message&& other) = default;
@@ -34,8 +62,10 @@ class Message : public MemoryRetainer {
 
   // Deserialize the contained JS value. May only be called once, and only
   // after Serialize() has been called (e.g. by another thread).
-  v8::MaybeLocal<v8::Value> Deserialize(Environment* env,
-                                        v8::Local<v8::Context> context);
+  v8::MaybeLocal<v8::Value> Deserialize(
+      Environment* env,
+      v8::Local<v8::Context> context,
+      v8::Local<v8::Value>* port_list = nullptr);
 
   // Serialize a JS value, and optionally transfer objects, into this message.
   // The Message object retains ownership of all transferred objects until
@@ -54,16 +84,20 @@ class Message : public MemoryRetainer {
   void AddSharedArrayBuffer(std::shared_ptr<v8::BackingStore> backing_store);
   // Internal method of Message that is called once serialization finishes
   // and that transfers ownership of `data` to this message.
-  void AddMessagePort(std::unique_ptr<MessagePortData>&& data);
+  void AddTransferable(std::unique_ptr<TransferData>&& data);
   // Internal method of Message that is called when a new WebAssembly.Module
   // object is encountered in the incoming value's structure.
-  uint32_t AddWASMModule(v8::WasmModuleObject::TransferrableModule&& mod);
+  uint32_t AddWASMModule(v8::CompiledWasmModule&& mod);
 
-  // The MessagePorts that will be transferred, as recorded by Serialize().
+  // The host objects that will be transferred, as recorded by Serialize()
+  // (e.g. MessagePorts).
   // Used for warning user about posting the target MessagePort to itself,
   // which will as a side effect destroy the communication channel.
-  const std::vector<std::unique_ptr<MessagePortData>>& message_ports() const {
-    return message_ports_;
+  const std::vector<std::unique_ptr<TransferData>>& transferables() const {
+    return transferables_;
+  }
+  bool has_transferables() const {
+    return !transferables_.empty() || !array_buffers_.empty();
   }
 
   void MemoryInfo(MemoryTracker* tracker) const override;
@@ -73,17 +107,65 @@ class Message : public MemoryRetainer {
 
  private:
   MallocedBuffer<char> main_message_buf_;
+  // TODO(addaleax): Make this a std::variant to save storage size in the common
+  // case (which is that all of these vectors are empty) once that is available
+  // with C++17.
   std::vector<std::shared_ptr<v8::BackingStore>> array_buffers_;
   std::vector<std::shared_ptr<v8::BackingStore>> shared_array_buffers_;
-  std::vector<std::unique_ptr<MessagePortData>> message_ports_;
-  std::vector<v8::WasmModuleObject::TransferrableModule> wasm_modules_;
+  std::vector<std::unique_ptr<TransferData>> transferables_;
+  std::vector<v8::CompiledWasmModule> wasm_modules_;
 
   friend class MessagePort;
 };
 
+class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
+ public:
+  // Named SiblingGroup, Used for one-to-many BroadcastChannels.
+  static std::shared_ptr<SiblingGroup> Get(const std::string& name);
+
+  // Anonymous SiblingGroup, Used for one-to-one MessagePort pairs.
+  SiblingGroup() = default;
+  explicit SiblingGroup(const std::string& name);
+  ~SiblingGroup();
+
+  // Dispatches the Message to the collection of associated
+  // ports. If there is more than one destination port and
+  // the Message contains transferables, Dispatch will fail.
+  // Returns Just(true) if successful and the message was
+  // dispatched to at least one destination. Returns Just(false)
+  // if there were no destinations. Returns Nothing<bool>()
+  // if there was an error. If error is not nullptr, it will
+  // be set to an error message or warning message as appropriate.
+  v8::Maybe<bool> Dispatch(
+      MessagePortData* source,
+      std::shared_ptr<Message> message,
+      std::string* error = nullptr);
+
+  void Entangle(MessagePortData* data);
+  void Entangle(std::initializer_list<MessagePortData*> data);
+  void Disentangle(MessagePortData* data);
+
+  const std::string& name() const { return name_; }
+
+  size_t size() const { return ports_.size(); }
+
+ private:
+  const std::string name_;
+  RwLock group_mutex_;  // Protects ports_.
+  std::set<MessagePortData*> ports_;
+
+  static void CheckSiblingGroup(const std::string& name);
+
+  using Map =
+      std::unordered_map<std::string, std::weak_ptr<SiblingGroup>>;
+
+  static Mutex groups_mutex_;
+  static Map groups_;
+};
+
 // This contains all data for a `MessagePort` instance that is not tied to
 // a specific Environment/Isolate/event loop, for easier transfer between those.
-class MessagePortData : public MemoryRetainer {
+class MessagePortData : public TransferData {
  public:
   explicit MessagePortData(MessagePort* owner);
   ~MessagePortData() override;
@@ -95,7 +177,10 @@ class MessagePortData : public MemoryRetainer {
 
   // Add a message to the incoming queue and notify the receiver.
   // This may be called from any thread.
-  void AddToIncomingQueue(Message&& message);
+  void AddToIncomingQueue(std::shared_ptr<Message> message);
+  v8::Maybe<bool> Dispatch(
+      std::shared_ptr<Message> message,
+      std::string* error = nullptr);
 
   // Turns `a` and `b` into siblings, i.e. connects the sending side of one
   // to the receiving side of the other. This is not thread-safe.
@@ -108,6 +193,10 @@ class MessagePortData : public MemoryRetainer {
   void Disentangle();
 
   void MemoryInfo(MemoryTracker* tracker) const override;
+  BaseObjectPtr<BaseObject> Deserialize(
+      Environment* env,
+      v8::Local<v8::Context> context,
+      std::unique_ptr<TransferData> self) override;
 
   SET_MEMORY_INFO_NAME(MessagePortData)
   SET_SELF_SIZE(MessagePortData)
@@ -116,15 +205,14 @@ class MessagePortData : public MemoryRetainer {
   // This mutex protects all fields below it, with the exception of
   // sibling_.
   mutable Mutex mutex_;
-  std::list<Message> incoming_messages_;
+  // TODO(addaleax): Make this a std::variant<std::shared_ptr, std::unique_ptr>
+  // once that is available with C++17, because std::shared_ptr comes with
+  // overhead that is only necessary for BroadcastChannel.
+  std::deque<std::shared_ptr<Message>> incoming_messages_;
   MessagePort* owner_ = nullptr;
-  // This mutex protects the sibling_ field and is shared between two entangled
-  // MessagePorts. If both mutexes are acquired, this one needs to be
-  // acquired first.
-  std::shared_ptr<Mutex> sibling_mutex_ = std::make_shared<Mutex>();
-  MessagePortData* sibling_ = nullptr;
-
+  std::shared_ptr<SiblingGroup> group_;
   friend class MessagePort;
+  friend class SiblingGroup;
 };
 
 // A message port that receives messages from other threads, including
@@ -147,12 +235,14 @@ class MessagePort : public HandleWrap {
   // `MessagePortData` object.
   static MessagePort* New(Environment* env,
                           v8::Local<v8::Context> context,
-                          std::unique_ptr<MessagePortData> data = nullptr);
+                          std::unique_ptr<MessagePortData> data = {},
+                          std::shared_ptr<SiblingGroup> sibling_group = {});
 
   // Send a message, i.e. deliver it into the sibling's incoming queue.
   // If this port is closed, or if there is no sibling, this message is
   // serialized with transfers, then silently discarded.
   v8::Maybe<bool> PostMessage(Environment* env,
+                              v8::Local<v8::Context> context,
                               v8::Local<v8::Value> message,
                               const TransferList& transfer);
 
@@ -167,6 +257,7 @@ class MessagePort : public HandleWrap {
   static void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void CheckType(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Drain(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ReceiveMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
 
@@ -195,16 +286,26 @@ class MessagePort : public HandleWrap {
   // NULL pointer to the C++ MessagePort object is also detached.
   inline bool IsDetached() const;
 
+  TransferMode GetTransferMode() const override;
+  std::unique_ptr<TransferData> TransferForMessaging() override;
+
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(MessagePort)
   SET_SELF_SIZE(MessagePort)
 
  private:
+  enum class MessageProcessingMode {
+    kNormalOperation,
+    kForceReadMessages
+  };
+
   void OnClose() override;
-  void OnMessage();
+  void OnMessage(MessageProcessingMode mode);
   void TriggerAsync();
-  v8::MaybeLocal<v8::Value> ReceiveMessage(v8::Local<v8::Context> context,
-                                           bool only_if_receiving);
+  v8::MaybeLocal<v8::Value> ReceiveMessage(
+      v8::Local<v8::Context> context,
+      MessageProcessingMode mode,
+      v8::Local<v8::Value>* port_list = nullptr);
 
   std::unique_ptr<MessagePortData> data_ = nullptr;
   bool receiving_messages_ = false;
@@ -214,6 +315,52 @@ class MessagePort : public HandleWrap {
   friend class MessagePortData;
 };
 
+// Provide a base class from which JS classes that should be transferable or
+// cloneable by postMesssage() can inherit.
+// See e.g. FileHandle in internal/fs/promises.js for an example.
+class JSTransferable : public BaseObject {
+ public:
+  JSTransferable(Environment* env, v8::Local<v8::Object> obj);
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  TransferMode GetTransferMode() const override;
+  std::unique_ptr<TransferData> TransferForMessaging() override;
+  std::unique_ptr<TransferData> CloneForMessaging() const override;
+  v8::Maybe<std::vector<BaseObjectPtr<BaseObject>>>
+      NestedTransferables() const override;
+  v8::Maybe<bool> FinalizeTransferRead(
+      v8::Local<v8::Context> context,
+      v8::ValueDeserializer* deserializer) override;
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(JSTransferable)
+  SET_SELF_SIZE(JSTransferable)
+
+ private:
+  std::unique_ptr<TransferData> TransferOrClone(TransferMode mode) const;
+
+  class Data : public TransferData {
+   public:
+    Data(std::string&& deserialize_info, v8::Global<v8::Value>&& data);
+
+    BaseObjectPtr<BaseObject> Deserialize(
+        Environment* env,
+        v8::Local<v8::Context> context,
+        std::unique_ptr<TransferData> self) override;
+    v8::Maybe<bool> FinalizeTransferWrite(
+        v8::Local<v8::Context> context,
+        v8::ValueSerializer* serializer) override;
+
+    SET_NO_MEMORY_INFO()
+    SET_MEMORY_INFO_NAME(JSTransferableTransferData)
+    SET_SELF_SIZE(Data)
+
+   private:
+    std::string deserialize_info_;
+    v8::Global<v8::Value> data_;
+  };
+};
+
 v8::Local<v8::FunctionTemplate> GetMessagePortConstructorTemplate(
     Environment* env);
 

package/src/headers/{12 → 18}/node_metadata.h

@@ -6,6 +6,13 @@
 #include <string>
 #include "node_version.h"
 
+#if HAVE_OPENSSL
+#include <openssl/crypto.h>
+#if NODE_OPENSSL_HAS_QUIC
+#include <openssl/quic.h>
+#endif
+#endif  // HAVE_OPENSSL
+
 namespace node {
 
 // if this is a release build and no explicit base has been set
@@ -31,7 +38,6 @@ namespace node {
   V(nghttp2)                                                                   \
   V(napi)                                                                      \
   V(llhttp)                                                                    \
-  V(http_parser)                                                               \
 
 #if HAVE_OPENSSL
 #define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl)
@@ -49,10 +55,19 @@ namespace node {
 #define NODE_VERSIONS_KEY_INTL(V)
 #endif  // NODE_HAVE_I18N_SUPPORT
 
+#ifdef OPENSSL_INFO_QUIC
+#define NODE_VERSIONS_KEY_QUIC(V)                                             \
+  V(ngtcp2)                                                                   \
+  V(nghttp3)
+#else
+#define NODE_VERSIONS_KEY_QUIC(V)
+#endif
+
 #define NODE_VERSIONS_KEYS(V)                                                  \
   NODE_VERSIONS_KEYS_BASE(V)                                                   \
   NODE_VERSIONS_KEY_CRYPTO(V)                                                  \
-  NODE_VERSIONS_KEY_INTL(V)
+  NODE_VERSIONS_KEY_INTL(V)                                                    \
+  NODE_VERSIONS_KEY_QUIC(V)
 
 class Metadata {
  public:
@@ -102,8 +117,6 @@ class Metadata {
 // Per-process global
 namespace per_process {
 extern Metadata metadata;
-extern const char* const llhttp_version;
-extern const char* const http_parser_version;
 }
 
 }  // namespace node

package/src/headers/{12 → 18}/node_mutex.h

@@ -14,9 +14,11 @@ namespace node {
 template <typename Traits> class ConditionVariableBase;
 template <typename Traits> class MutexBase;
 struct LibuvMutexTraits;
+struct LibuvRwlockTraits;
 
 using ConditionVariable = ConditionVariableBase<LibuvMutexTraits>;
 using Mutex = MutexBase<LibuvMutexTraits>;
+using RwLock = MutexBase<LibuvRwlockTraits>;
 
 template <typename T, typename MutexT = Mutex>
 class ExclusiveAccess {
@@ -32,7 +34,7 @@ class ExclusiveAccess {
 
   class Scoped {
    public:
-    // ExclusiveAccess will commonly be used in conjuction with std::shared_ptr
+    // ExclusiveAccess will commonly be used in conjunction with std::shared_ptr
     // and without this constructor it's too easy to forget to keep a reference
     // around to the shared_ptr while operating on the ExclusiveAccess object.
     explicit Scoped(const std::shared_ptr<ExclusiveAccess>& shared)
@@ -70,6 +72,8 @@ class MutexBase {
   inline ~MutexBase();
   inline void Lock();
   inline void Unlock();
+  inline void RdLock();
+  inline void RdUnlock();
 
   MutexBase(const MutexBase&) = delete;
   MutexBase& operator=(const MutexBase&) = delete;
@@ -92,6 +96,21 @@ class MutexBase {
     const MutexBase& mutex_;
   };
 
+  class ScopedReadLock {
+   public:
+    inline explicit ScopedReadLock(const MutexBase& mutex);
+    inline ~ScopedReadLock();
+
+    ScopedReadLock(const ScopedReadLock&) = delete;
+    ScopedReadLock& operator=(const ScopedReadLock&) = delete;
+
+   private:
+    template <typename> friend class ConditionVariableBase;
+    const MutexBase& mutex_;
+  };
+
+  using ScopedWriteLock = ScopedLock;
+
   class ScopedUnlock {
    public:
     inline explicit ScopedUnlock(const ScopedLock& scoped_lock);
@@ -167,6 +186,42 @@ struct LibuvMutexTraits {
   static inline void mutex_unlock(MutexT* mutex) {
     uv_mutex_unlock(mutex);
   }
+
+  static inline void mutex_rdlock(MutexT* mutex) {
+    uv_mutex_lock(mutex);
+  }
+
+  static inline void mutex_rdunlock(MutexT* mutex) {
+    uv_mutex_unlock(mutex);
+  }
+};
+
+struct LibuvRwlockTraits {
+  using MutexT = uv_rwlock_t;
+
+  static inline int mutex_init(MutexT* mutex) {
+    return uv_rwlock_init(mutex);
+  }
+
+  static inline void mutex_destroy(MutexT* mutex) {
+    uv_rwlock_destroy(mutex);
+  }
+
+  static inline void mutex_lock(MutexT* mutex) {
+    uv_rwlock_wrlock(mutex);
+  }
+
+  static inline void mutex_unlock(MutexT* mutex) {
+    uv_rwlock_wrunlock(mutex);
+  }
+
+  static inline void mutex_rdlock(MutexT* mutex) {
+    uv_rwlock_rdlock(mutex);
+  }
+
+  static inline void mutex_rdunlock(MutexT* mutex) {
+    uv_rwlock_rdunlock(mutex);
+  }
 };
 
 template <typename Traits>
@@ -214,6 +269,16 @@ void MutexBase<Traits>::Unlock() {
   Traits::mutex_unlock(&mutex_);
 }
 
+template <typename Traits>
+void MutexBase<Traits>::RdLock() {
+  Traits::mutex_rdlock(&mutex_);
+}
+
+template <typename Traits>
+void MutexBase<Traits>::RdUnlock() {
+  Traits::mutex_rdunlock(&mutex_);
+}
+
 template <typename Traits>
 MutexBase<Traits>::ScopedLock::ScopedLock(const MutexBase& mutex)
     : mutex_(mutex) {
@@ -229,6 +294,17 @@ MutexBase<Traits>::ScopedLock::~ScopedLock() {
   Traits::mutex_unlock(&mutex_.mutex_);
 }
 
+template <typename Traits>
+MutexBase<Traits>::ScopedReadLock::ScopedReadLock(const MutexBase& mutex)
+    : mutex_(mutex) {
+  Traits::mutex_rdlock(&mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedReadLock::~ScopedReadLock() {
+  Traits::mutex_rdunlock(&mutex_.mutex_);
+}
+
 template <typename Traits>
 MutexBase<Traits>::ScopedUnlock::ScopedUnlock(const ScopedLock& scoped_lock)
     : mutex_(scoped_lock.mutex_) {

package/src/headers/{12 → 18}/node_native_module.h

@@ -15,6 +15,7 @@
 class PerProcessTest;
 
 namespace node {
+class SnapshotBuilder;
 namespace native_module {
 
 using NativeModuleRecordMap = std::map<std::string, UnionBytes>;
@@ -22,6 +23,11 @@ using NativeModuleCacheMap =
     std::unordered_map<std::string,
                        std::unique_ptr<v8::ScriptCompiler::CachedData>>;
 
+struct CodeCacheInfo {
+  std::string id;
+  std::vector<uint8_t> data;
+};
+
 // The native (C++) side of the NativeModule in JS land, which
 // handles compilation and caching of builtin modules (NativeModule)
 // and bootstrappers, whose source are bundled into the binary
@@ -29,7 +35,7 @@ using NativeModuleCacheMap =
 // This class should not depend on any Environment, or depend on access to
 // the its own singleton - that should be encapsulated in NativeModuleEnv
 // instead.
-class NativeModuleLoader {
+class NODE_EXTERN_PRIVATE NativeModuleLoader {
  public:
   NativeModuleLoader(const NativeModuleLoader&) = delete;
   NativeModuleLoader& operator=(const NativeModuleLoader&) = delete;
@@ -47,6 +53,8 @@ class NativeModuleLoader {
   UnionBytes GetConfig();       // Return data for config.gypi
 
   bool Exists(const char* id);
+  bool Add(const char* id, const UnionBytes& source);
+
   v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
   v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
   std::vector<std::string> GetModuleIds();
@@ -64,6 +72,8 @@ class NativeModuleLoader {
   bool CannotBeRequired(const char* id);
 
   NativeModuleCacheMap* code_cache();
+  const Mutex& code_cache_mutex() const { return code_cache_mutex_; }
+
   v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
   enum class Result { kWithCache, kWithoutCache };
   v8::MaybeLocal<v8::String> LoadBuiltinModuleSource(v8::Isolate* isolate,

package/src/headers/{13 → 18}/node_native_module_env.h

@@ -3,17 +3,20 @@
 
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
+#include <vector>
 #include "node_native_module.h"
 
 namespace node {
 class Environment;
-
+class ExternalReferenceRegistry;
 namespace native_module {
 
-extern const bool has_code_cache;
-
+// TODO(joyeecheung): since it's safer to make the code cache part of the
+// embedded snapshot, there is no need to separate NativeModuleEnv and
+// NativeModuleLoader. Merge the two.
 class NativeModuleEnv {
  public:
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context,
@@ -29,12 +32,11 @@ class NativeModuleEnv {
   // Returns config.gypi as a JSON string
   static v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
   static bool Exists(const char* id);
+  static bool Add(const char* id, const UnionBytes& source);
 
-  // Loads data into NativeModuleLoader::.instance.code_cache_
-  // Generated by mkcodecache as node_code_cache.cc when
-  // the build is configured with --code-cache-path=.... They are noops
-  // in node_code_cache_stub.cc
-  static void InitializeCodeCache();
+  static bool CompileAllModules(v8::Local<v8::Context> context);
+  static void RefreshCodeCache(const std::vector<CodeCacheInfo>& in);
+  static void CopyCodeCache(std::vector<CodeCacheInfo>* out);
 
  private:
   static void RecordResult(const char* id,
@@ -54,6 +56,10 @@ class NativeModuleEnv {
       const v8::PropertyCallbackInfo<v8::Value>& info);
   // Compile a specific native module as a function
   static void CompileFunction(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void HasCachedBuiltins(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static bool has_code_cache_;
 };
 
 }  // namespace native_module