@encharm/cws 4.0.2 → 4.3.0

package/src/headers/10/node_messaging.h

@@ -1,219 +0,0 @@
-#ifndef SRC_NODE_MESSAGING_H_
-#define SRC_NODE_MESSAGING_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "node_mutex.h"
-#include "sharedarraybuffer_metadata.h"
-#include <list>
-
-namespace node {
-namespace worker {
-
-class MessagePortData;
-class MessagePort;
-
-// Represents a single communication message.
-class Message : public MemoryRetainer {
- public:
-  explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
-
-  Message(Message&& other) = default;
-  Message& operator=(Message&& other) = default;
-  Message& operator=(const Message&) = delete;
-  Message(const Message&) = delete;
-
-  // 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);
-
-  // Serialize a JS value, and optionally transfer objects, into this message.
-  // The Message object retains ownership of all transferred objects until
-  // deserialization.
-  // The source_port parameter, if provided, will make Serialize() throw a
-  // "DataCloneError" DOMException if source_port is found in transfer_list.
-  v8::Maybe<bool> Serialize(Environment* env,
-                            v8::Local<v8::Context> context,
-                            v8::Local<v8::Value> input,
-                            v8::Local<v8::Value> transfer_list,
-                            v8::Local<v8::Object> source_port =
-                                v8::Local<v8::Object>());
-
-  // Internal method of Message that is called when a new SharedArrayBuffer
-  // object is encountered in the incoming value's structure.
-  void AddSharedArrayBuffer(SharedArrayBufferMetadataReference ref);
-  // 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);
-
-  // The MessagePorts that will be transferred, as recorded by Serialize().
-  // 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_;
-  }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-
-  SET_MEMORY_INFO_NAME(Message)
-  SET_SELF_SIZE(Message)
-
- private:
-  MallocedBuffer<char> main_message_buf_;
-  std::vector<MallocedBuffer<char>> array_buffer_contents_;
-  std::vector<SharedArrayBufferMetadataReference> shared_array_buffers_;
-  std::vector<std::unique_ptr<MessagePortData>> message_ports_;
-
-  friend class MessagePort;
-};
-
-// 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 {
- public:
-  explicit MessagePortData(MessagePort* owner);
-  ~MessagePortData();
-
-  MessagePortData(MessagePortData&& other) = delete;
-  MessagePortData& operator=(MessagePortData&& other) = delete;
-  MessagePortData(const MessagePortData& other) = delete;
-  MessagePortData& operator=(const MessagePortData& other) = delete;
-
-  // Add a message to the incoming queue and notify the receiver.
-  // This may be called from any thread.
-  void AddToIncomingQueue(Message&& message);
-
-  // Returns true if and only this MessagePort is currently not entangled
-  // with another message port.
-  bool IsSiblingClosed() const;
-
-  // 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.
-  static void Entangle(MessagePortData* a, MessagePortData* b);
-
-  // Removes any possible sibling. This is thread-safe (it acquires both
-  // `sibling_mutex_` and `mutex_`), and has to be because it is called once
-  // the corresponding JS handle handle wants to close
-  // which can happen on either side of a worker.
-  void Disentangle();
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-
-  SET_MEMORY_INFO_NAME(MessagePortData)
-  SET_SELF_SIZE(MessagePortData)
-
- private:
-  // After disentangling this message port, the owner handle (if any)
-  // is asynchronously triggered, so that it can close down naturally.
-  void PingOwnerAfterDisentanglement();
-
-  // This mutex protects all fields below it, with the exception of
-  // sibling_.
-  mutable Mutex mutex_;
-  bool receiving_messages_ = false;
-  std::list<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;
-
-  friend class MessagePort;
-};
-
-// A message port that receives messages from other threads, including
-// the uv_async_t handle that is used to notify the current event loop of
-// new incoming messages.
-class MessagePort : public HandleWrap {
- public:
-  // Create a new MessagePort. The `context` argument specifies the Context
-  // instance that is used for creating the values emitted from this port.
-  MessagePort(Environment* env,
-              v8::Local<v8::Context> context,
-              v8::Local<v8::Object> wrap);
-  ~MessagePort();
-
-  // Create a new message port instance, optionally over an existing
-  // `MessagePortData` object.
-  static MessagePort* New(Environment* env,
-                          v8::Local<v8::Context> context,
-                          std::unique_ptr<MessagePortData> data = nullptr);
-
-  // 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::Value> message,
-                              v8::Local<v8::Value> transfer);
-  // Deliver a single message into this port's incoming queue.
-  void AddToIncomingQueue(Message&& message);
-
-  // Start processing messages on this port as a receiving end.
-  void Start();
-  // Stop processing messages on this port as a receiving end.
-  void Stop();
-  // Stop processing messages on this port as a receiving end,
-  // and stop the event loop that this port is associated with.
-  void StopEventLoop();
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  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 Drain(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  // 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.
-  static void Entangle(MessagePort* a, MessagePort* b);
-  static void Entangle(MessagePort* a, MessagePortData* b);
-
-  // Detach this port's data for transferring. After this, the MessagePortData
-  // is no longer associated with this handle, although it can still receive
-  // messages.
-  std::unique_ptr<MessagePortData> Detach();
-
-  bool IsSiblingClosed() const;
-  void Close(
-      v8::Local<v8::Value> close_callback = v8::Local<v8::Value>()) override;
-
-  // Returns true if either data_ has been freed, or if the handle is being
-  // closed. Equivalent to the [[Detached]] internal slot in the HTML Standard.
-  //
-  // If checking if a JavaScript MessagePort object is detached, this method
-  // alone is often not enough, since the backing C++ MessagePort object may
-  // have been deleted already. For all intents and purposes, an object with a
-  // NULL pointer to the C++ MessagePort object is also detached.
-  inline bool IsDetached() const;
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("data", data_);
-  }
-
-  SET_MEMORY_INFO_NAME(MessagePort)
-  SET_SELF_SIZE(MessagePort)
-
- private:
-  void OnClose() override;
-  void OnMessage();
-  void TriggerAsync();
-  inline uv_async_t* async();
-
-  std::unique_ptr<MessagePortData> data_ = nullptr;
-  bool stop_event_loop_ = false;
-
-  friend class MessagePortData;
-};
-
-v8::MaybeLocal<v8::Function> GetMessagePortConstructor(
-    Environment* env, v8::Local<v8::Context> context);
-
-}  // namespace worker
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-
-#endif  // SRC_NODE_MESSAGING_H_

package/src/headers/10/node_mutex.h

@@ -1,191 +0,0 @@
-#ifndef SRC_NODE_MUTEX_H_
-#define SRC_NODE_MUTEX_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "util.h"
-#include "uv.h"
-
-namespace node {
-
-template <typename Traits> class ConditionVariableBase;
-template <typename Traits> class MutexBase;
-struct LibuvMutexTraits;
-
-using ConditionVariable = ConditionVariableBase<LibuvMutexTraits>;
-using Mutex = MutexBase<LibuvMutexTraits>;
-
-template <typename Traits>
-class MutexBase {
- public:
-  inline MutexBase();
-  inline ~MutexBase();
-  inline void Lock();
-  inline void Unlock();
-
-  class ScopedLock;
-  class ScopedUnlock;
-
-  class ScopedLock {
-   public:
-    inline explicit ScopedLock(const MutexBase& mutex);
-    inline explicit ScopedLock(const ScopedUnlock& scoped_unlock);
-    inline ~ScopedLock();
-
-   private:
-    template <typename> friend class ConditionVariableBase;
-    friend class ScopedUnlock;
-    const MutexBase& mutex_;
-    DISALLOW_COPY_AND_ASSIGN(ScopedLock);
-  };
-
-  class ScopedUnlock {
-   public:
-    inline explicit ScopedUnlock(const ScopedLock& scoped_lock);
-    inline ~ScopedUnlock();
-
-   private:
-    friend class ScopedLock;
-    const MutexBase& mutex_;
-    DISALLOW_COPY_AND_ASSIGN(ScopedUnlock);
-  };
-
- private:
-  template <typename> friend class ConditionVariableBase;
-  mutable typename Traits::MutexT mutex_;
-  DISALLOW_COPY_AND_ASSIGN(MutexBase);
-};
-
-template <typename Traits>
-class ConditionVariableBase {
- public:
-  using ScopedLock = typename MutexBase<Traits>::ScopedLock;
-
-  inline ConditionVariableBase();
-  inline ~ConditionVariableBase();
-  inline void Broadcast(const ScopedLock&);
-  inline void Signal(const ScopedLock&);
-  inline void Wait(const ScopedLock& scoped_lock);
-
- private:
-  typename Traits::CondT cond_;
-  DISALLOW_COPY_AND_ASSIGN(ConditionVariableBase);
-};
-
-struct LibuvMutexTraits {
-  using CondT = uv_cond_t;
-  using MutexT = uv_mutex_t;
-
-  static inline int cond_init(CondT* cond) {
-    return uv_cond_init(cond);
-  }
-
-  static inline int mutex_init(MutexT* mutex) {
-    return uv_mutex_init(mutex);
-  }
-
-  static inline void cond_broadcast(CondT* cond) {
-    uv_cond_broadcast(cond);
-  }
-
-  static inline void cond_destroy(CondT* cond) {
-    uv_cond_destroy(cond);
-  }
-
-  static inline void cond_signal(CondT* cond) {
-    uv_cond_signal(cond);
-  }
-
-  static inline void cond_wait(CondT* cond, MutexT* mutex) {
-    uv_cond_wait(cond, mutex);
-  }
-
-  static inline void mutex_destroy(MutexT* mutex) {
-    uv_mutex_destroy(mutex);
-  }
-
-  static inline void mutex_lock(MutexT* mutex) {
-    uv_mutex_lock(mutex);
-  }
-
-  static inline void mutex_unlock(MutexT* mutex) {
-    uv_mutex_unlock(mutex);
-  }
-};
-
-template <typename Traits>
-ConditionVariableBase<Traits>::ConditionVariableBase() {
-  CHECK_EQ(0, Traits::cond_init(&cond_));
-}
-
-template <typename Traits>
-ConditionVariableBase<Traits>::~ConditionVariableBase() {
-  Traits::cond_destroy(&cond_);
-}
-
-template <typename Traits>
-void ConditionVariableBase<Traits>::Broadcast(const ScopedLock&) {
-  Traits::cond_broadcast(&cond_);
-}
-
-template <typename Traits>
-void ConditionVariableBase<Traits>::Signal(const ScopedLock&) {
-  Traits::cond_signal(&cond_);
-}
-
-template <typename Traits>
-void ConditionVariableBase<Traits>::Wait(const ScopedLock& scoped_lock) {
-  Traits::cond_wait(&cond_, &scoped_lock.mutex_.mutex_);
-}
-
-template <typename Traits>
-MutexBase<Traits>::MutexBase() {
-  CHECK_EQ(0, Traits::mutex_init(&mutex_));
-}
-
-template <typename Traits>
-MutexBase<Traits>::~MutexBase() {
-  Traits::mutex_destroy(&mutex_);
-}
-
-template <typename Traits>
-void MutexBase<Traits>::Lock() {
-  Traits::mutex_lock(&mutex_);
-}
-
-template <typename Traits>
-void MutexBase<Traits>::Unlock() {
-  Traits::mutex_unlock(&mutex_);
-}
-
-template <typename Traits>
-MutexBase<Traits>::ScopedLock::ScopedLock(const MutexBase& mutex)
-    : mutex_(mutex) {
-  Traits::mutex_lock(&mutex_.mutex_);
-}
-
-template <typename Traits>
-MutexBase<Traits>::ScopedLock::ScopedLock(const ScopedUnlock& scoped_unlock)
-    : MutexBase(scoped_unlock.mutex_) {}
-
-template <typename Traits>
-MutexBase<Traits>::ScopedLock::~ScopedLock() {
-  Traits::mutex_unlock(&mutex_.mutex_);
-}
-
-template <typename Traits>
-MutexBase<Traits>::ScopedUnlock::ScopedUnlock(const ScopedLock& scoped_lock)
-    : mutex_(scoped_lock.mutex_) {
-  Traits::mutex_unlock(&mutex_.mutex_);
-}
-
-template <typename Traits>
-MutexBase<Traits>::ScopedUnlock::~ScopedUnlock() {
-  Traits::mutex_lock(&mutex_.mutex_);
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_MUTEX_H_

package/src/headers/10/node_object_wrap.h

@@ -1,130 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-#ifndef SRC_NODE_OBJECT_WRAP_H_
-#define SRC_NODE_OBJECT_WRAP_H_
-
-#include "v8.h"
-#include <assert.h>
-
-
-namespace node {
-
-class ObjectWrap {
- public:
-  ObjectWrap() {
-    refs_ = 0;
-  }
-
-
-  virtual ~ObjectWrap() {
-    if (persistent().IsEmpty())
-      return;
-    persistent().ClearWeak();
-    persistent().Reset();
-  }
-
-
-  template <class T>
-  static inline T* Unwrap(v8::Local<v8::Object> handle) {
-    assert(!handle.IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    // Cast to ObjectWrap before casting to T.  A direct cast from void
-    // to T won't work right when T has more than one base class.
-    void* ptr = handle->GetAlignedPointerFromInternalField(0);
-    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
-    return static_cast<T*>(wrap);
-  }
-
-
-  inline v8::Local<v8::Object> handle() {
-    return handle(v8::Isolate::GetCurrent());
-  }
-
-
-  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
-    return v8::Local<v8::Object>::New(isolate, persistent());
-  }
-
-
-  inline v8::Persistent<v8::Object>& persistent() {
-    return handle_;
-  }
-
-
- protected:
-  inline void Wrap(v8::Local<v8::Object> handle) {
-    assert(persistent().IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    handle->SetAlignedPointerInInternalField(0, this);
-    persistent().Reset(v8::Isolate::GetCurrent(), handle);
-    MakeWeak();
-  }
-
-
-  inline void MakeWeak(void) {
-    persistent().SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
-  }
-
-  /* Ref() marks the object as being attached to an event loop.
-   * Refed objects will not be garbage collected, even if
-   * all references are lost.
-   */
-  virtual void Ref() {
-    assert(!persistent().IsEmpty());
-    persistent().ClearWeak();
-    refs_++;
-  }
-
-  /* Unref() marks an object as detached from the event loop.  This is its
-   * default state.  When an object with a "weak" reference changes from
-   * attached to detached state it will be freed. Be careful not to access
-   * the object after making this call as it might be gone!
-   * (A "weak reference" means an object that only has a
-   * persistent handle.)
-   *
-   * DO NOT CALL THIS FROM DESTRUCTOR
-   */
-  virtual void Unref() {
-    assert(!persistent().IsEmpty());
-    assert(!persistent().IsWeak());
-    assert(refs_ > 0);
-    if (--refs_ == 0)
-      MakeWeak();
-  }
-
-  int refs_;  // ro
-
- private:
-  static void WeakCallback(
-      const v8::WeakCallbackInfo<ObjectWrap>& data) {
-    ObjectWrap* wrap = data.GetParameter();
-    assert(wrap->refs_ == 0);
-    wrap->handle_.Reset();
-    delete wrap;
-  }
-
-  v8::Persistent<v8::Object> handle_;
-};
-
-}  // namespace node
-
-#endif  // SRC_NODE_OBJECT_WRAP_H_