@encharm/cws 4.4.1 → 4.5.2

package/src/headers/16/node_platform.h

@@ -1,192 +0,0 @@
-#ifndef SRC_NODE_PLATFORM_H_
-#define SRC_NODE_PLATFORM_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <queue>
-#include <unordered_map>
-#include <vector>
-#include <functional>
-
-#include "libplatform/libplatform.h"
-#include "node.h"
-#include "node_mutex.h"
-#include "uv.h"
-
-namespace node {
-
-class NodePlatform;
-class IsolateData;
-class PerIsolatePlatformData;
-
-template <class T>
-class TaskQueue {
- public:
-  TaskQueue();
-  ~TaskQueue() = default;
-
-  void Push(std::unique_ptr<T> task);
-  std::unique_ptr<T> Pop();
-  std::unique_ptr<T> BlockingPop();
-  std::queue<std::unique_ptr<T>> PopAll();
-  void NotifyOfCompletion();
-  void BlockingDrain();
-  void Stop();
-
- private:
-  Mutex lock_;
-  ConditionVariable tasks_available_;
-  ConditionVariable tasks_drained_;
-  int outstanding_tasks_;
-  bool stopped_;
-  std::queue<std::unique_ptr<T>> task_queue_;
-};
-
-struct DelayedTask {
-  std::unique_ptr<v8::Task> task;
-  uv_timer_t timer;
-  double timeout;
-  std::shared_ptr<PerIsolatePlatformData> platform_data;
-};
-
-// This acts as the foreground task runner for a given Isolate.
-class PerIsolatePlatformData :
-    public IsolatePlatformDelegate,
-    public v8::TaskRunner,
-    public std::enable_shared_from_this<PerIsolatePlatformData> {
- public:
-  PerIsolatePlatformData(v8::Isolate* isolate, uv_loop_t* loop);
-  ~PerIsolatePlatformData() override;
-
-  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner() override;
-  void PostTask(std::unique_ptr<v8::Task> task) override;
-  void PostIdleTask(std::unique_ptr<v8::IdleTask> task) override;
-  void PostDelayedTask(std::unique_ptr<v8::Task> task,
-                       double delay_in_seconds) override;
-  bool IdleTasksEnabled() override { return false; }
-
-  // Non-nestable tasks are treated like regular tasks.
-  bool NonNestableTasksEnabled() const override { return true; }
-  bool NonNestableDelayedTasksEnabled() const override { return true; }
-  void PostNonNestableTask(std::unique_ptr<v8::Task> task) override;
-  void PostNonNestableDelayedTask(std::unique_ptr<v8::Task> task,
-                                  double delay_in_seconds) override;
-
-  void AddShutdownCallback(void (*callback)(void*), void* data);
-  void Shutdown();
-
-  // Returns true if work was dispatched or executed. New tasks that are
-  // posted during flushing of the queue are postponed until the next
-  // flushing.
-  bool FlushForegroundTasksInternal();
-
-  const uv_loop_t* event_loop() const { return loop_; }
-
- private:
-  void DeleteFromScheduledTasks(DelayedTask* task);
-  void DecreaseHandleCount();
-
-  static void FlushTasks(uv_async_t* handle);
-  void RunForegroundTask(std::unique_ptr<v8::Task> task);
-  static void RunForegroundTask(uv_timer_t* timer);
-
-  struct ShutdownCallback {
-    void (*cb)(void*);
-    void* data;
-  };
-  typedef std::vector<ShutdownCallback> ShutdownCbList;
-  ShutdownCbList shutdown_callbacks_;
-  // shared_ptr to self to keep this object alive during shutdown.
-  std::shared_ptr<PerIsolatePlatformData> self_reference_;
-  uint32_t uv_handle_count_ = 1;  // 1 = flush_tasks_
-
-  v8::Isolate* const isolate_;
-  uv_loop_t* const loop_;
-  uv_async_t* flush_tasks_ = nullptr;
-  TaskQueue<v8::Task> foreground_tasks_;
-  TaskQueue<DelayedTask> foreground_delayed_tasks_;
-
-  // Use a custom deleter because libuv needs to close the handle first.
-  typedef std::unique_ptr<DelayedTask, void(*)(DelayedTask*)>
-      DelayedTaskPointer;
-  std::vector<DelayedTaskPointer> scheduled_delayed_tasks_;
-};
-
-// This acts as the single worker thread task runner for all Isolates.
-class WorkerThreadsTaskRunner {
- public:
-  explicit WorkerThreadsTaskRunner(int thread_pool_size);
-
-  void PostTask(std::unique_ptr<v8::Task> task);
-  void PostDelayedTask(std::unique_ptr<v8::Task> task,
-                       double delay_in_seconds);
-
-  void BlockingDrain();
-  void Shutdown();
-
-  int NumberOfWorkerThreads() const;
-
- private:
-  TaskQueue<v8::Task> pending_worker_tasks_;
-
-  class DelayedTaskScheduler;
-  std::unique_ptr<DelayedTaskScheduler> delayed_task_scheduler_;
-
-  std::vector<std::unique_ptr<uv_thread_t>> threads_;
-};
-
-class NodePlatform : public MultiIsolatePlatform {
- public:
-  NodePlatform(int thread_pool_size,
-               v8::TracingController* tracing_controller);
-  ~NodePlatform() override;
-
-  void DrainTasks(v8::Isolate* isolate) override;
-  void Shutdown();
-
-  // v8::Platform implementation.
-  int NumberOfWorkerThreads() override;
-  void CallOnWorkerThread(std::unique_ptr<v8::Task> task) override;
-  void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> task,
-                                 double delay_in_seconds) override;
-  bool IdleTasksEnabled(v8::Isolate* isolate) override;
-  double MonotonicallyIncreasingTime() override;
-  double CurrentClockTimeMillis() override;
-  v8::TracingController* GetTracingController() override;
-  bool FlushForegroundTasks(v8::Isolate* isolate) override;
-  std::unique_ptr<v8::JobHandle> PostJob(
-      v8::TaskPriority priority,
-      std::unique_ptr<v8::JobTask> job_task) override;
-
-  void RegisterIsolate(v8::Isolate* isolate, uv_loop_t* loop) override;
-  void RegisterIsolate(v8::Isolate* isolate,
-                       IsolatePlatformDelegate* delegate) override;
-
-  void UnregisterIsolate(v8::Isolate* isolate) override;
-  void AddIsolateFinishedCallback(v8::Isolate* isolate,
-                                  void (*callback)(void*), void* data) override;
-
-  std::shared_ptr<v8::TaskRunner> GetForegroundTaskRunner(
-      v8::Isolate* isolate) override;
-
-  Platform::StackTracePrinter GetStackTracePrinter() override;
-
- private:
-  IsolatePlatformDelegate* ForIsolate(v8::Isolate* isolate);
-  std::shared_ptr<PerIsolatePlatformData> ForNodeIsolate(v8::Isolate* isolate);
-
-  Mutex per_isolate_mutex_;
-  using DelegatePair = std::pair<
-    IsolatePlatformDelegate*, std::shared_ptr<PerIsolatePlatformData>>;
-  std::unordered_map<v8::Isolate*, DelegatePair> per_isolate_;
-
-  v8::TracingController* tracing_controller_;
-  std::shared_ptr<WorkerThreadsTaskRunner> worker_thread_task_runner_;
-  bool has_shut_down_ = false;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_PLATFORM_H_

package/src/headers/16/node_process.h

@@ -1,43 +0,0 @@
-#ifndef SRC_NODE_PROCESS_H_
-#define SRC_NODE_PROCESS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-
-namespace node {
-
-v8::MaybeLocal<v8::Object> CreateEnvVarProxy(v8::Local<v8::Context> context,
-                                             v8::Isolate* isolate);
-
-// Most of the time, it's best to use `console.error` to write
-// to the process.stderr stream.  However, in some cases, such as
-// when debugging the stream.Writable class or the process.nextTick
-// function, it is useful to bypass JavaScript entirely.
-void RawDebug(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-v8::MaybeLocal<v8::Value> ProcessEmit(Environment* env,
-                                      const char* event,
-                                      v8::Local<v8::Value> message);
-
-v8::Maybe<bool> ProcessEmitWarningGeneric(Environment* env,
-                                          const char* warning,
-                                          const char* type = nullptr,
-                                          const char* code = nullptr);
-
-template <typename... Args>
-inline v8::Maybe<bool> ProcessEmitWarning(Environment* env,
-                                          const char* fmt,
-                                          Args&&... args);
-v8::Maybe<bool> ProcessEmitExperimentalWarning(Environment* env,
-                                              const char* warning);
-v8::Maybe<bool> ProcessEmitDeprecationWarning(Environment* env,
-                                              const char* warning,
-                                              const char* deprecation_code);
-
-v8::MaybeLocal<v8::Object> CreateProcessObject(Environment* env);
-void PatchProcessObject(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-}  // namespace node
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_PROCESS_H_

package/src/headers/16/node_provider.d

@@ -1,80 +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.
- */
-
-/*
- * DTrace provider for node.js.
- */
-
-/*
- * In order to have the information we need here to create the provider,
- * we must declare bogus definitions for our depended-upon structures.  And
- * yes, the fact that we need to do this represents a shortcoming in DTrace,
- * one that would be resolved by that elusive El Dorado:  dynamic translators.
- */
-
-typedef struct {
-	int dummy;
-} node_dtrace_connection_t;
-
-typedef struct {
-	int dummy;
-} node_connection_t;
-
-typedef struct {
-	int dummy;
-} node_dtrace_http_server_request_t;
-
-typedef struct {
-	int dummy;
-} node_dtrace_http_client_request_t;
-
-typedef struct {
-	int dummy;
-} node_http_request_t;
-
-provider node {
-	probe net__server__connection(node_dtrace_connection_t *c,
-	    const char *a, int p, int fd) : (node_connection_t *c, string a, int p,
-      int fd);
-	probe net__stream__end(node_dtrace_connection_t *c, const char *a,
-	    int p, int fd) : (node_connection_t *c, string a, int p, int fd);
-	probe http__server__request(node_dtrace_http_server_request_t *h,
-	    node_dtrace_connection_t *c, const char *a, int p, const char *m,
-	    const char *u, int fd) : (node_http_request_t *h, node_connection_t *c,
-      string a, int p, string m, string u, int fd);
-	probe http__server__response(node_dtrace_connection_t *c, const char *a,
-	    int p, int fd) : (node_connection_t *c, string a, int p, int fd);
-	probe http__client__request(node_dtrace_http_client_request_t *h,
-	    node_dtrace_connection_t *c, const char *a, int p, const char *m,
-	    const char *u, int fd) : (node_http_request_t *h, node_connection_t *c,
-      string a, int p, string m, string u, int fd);
-	probe http__client__response(node_dtrace_connection_t *c, const char *a,
-	    int p, int fd) : (node_connection_t *c, string a, int p, int fd);
-	probe gc__start(int t, int f, void *isolate);
-	probe gc__done(int t, int f, void *isolate);
-};
-
-#pragma D attributes Evolving/Evolving/ISA provider node provider
-#pragma D attributes Private/Private/Unknown provider node module
-#pragma D attributes Private/Private/Unknown provider node function
-#pragma D attributes Private/Private/ISA provider node name
-#pragma D attributes Evolving/Evolving/ISA provider node args

package/src/headers/16/node_snapshotable.h

@@ -1,137 +0,0 @@
-
-#ifndef SRC_NODE_SNAPSHOTABLE_H_
-#define SRC_NODE_SNAPSHOTABLE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "util.h"
-
-namespace node {
-
-class Environment;
-struct EnvSerializeInfo;
-struct SnapshotData;
-
-#define SERIALIZABLE_OBJECT_TYPES(V)                                           \
-  V(fs_binding_data, fs::BindingData)                                          \
-  V(v8_binding_data, v8_utils::BindingData)                                    \
-  V(blob_binding_data, BlobBindingData)
-
-enum class EmbedderObjectType : uint8_t {
-  k_default = 0,
-#define V(PropertyName, NativeType) k_##PropertyName,
-  SERIALIZABLE_OBJECT_TYPES(V)
-#undef V
-};
-
-// When serializing an embedder object, we'll serialize the native states
-// into a chunk that can be mapped into a subclass of InternalFieldInfo,
-// and pass it into the V8 callback as the payload of StartupData.
-// TODO(joyeecheung): the classification of types seem to be wrong.
-// We'd need a type for each field of each class of native object.
-// Maybe it's fine - we'll just use the type to invoke BaseObject constructors
-// and specify that the BaseObject has only one field for us to serialize.
-// And for non-BaseObject embedder objects, we'll use field-wise types.
-// The memory chunk looks like this:
-//
-// [   type   ] - EmbedderObjectType (a uint8_t)
-// [  length  ] - a size_t
-// [    ...   ] - custom bytes of size |length - header size|
-struct InternalFieldInfo {
-  EmbedderObjectType type;
-  size_t length;
-
-  InternalFieldInfo() = delete;
-
-  static InternalFieldInfo* New(EmbedderObjectType type) {
-    return New(type, sizeof(InternalFieldInfo));
-  }
-
-  static InternalFieldInfo* New(EmbedderObjectType type, size_t length) {
-    InternalFieldInfo* result =
-        reinterpret_cast<InternalFieldInfo*>(::operator new[](length));
-    result->type = type;
-    result->length = length;
-    return result;
-  }
-
-  InternalFieldInfo* Copy() const {
-    InternalFieldInfo* result =
-        reinterpret_cast<InternalFieldInfo*>(::operator new[](length));
-    memcpy(result, this, length);
-    return result;
-  }
-
-  void Delete() { ::operator delete[](this); }
-};
-
-// An interface for snapshotable native objects to inherit from.
-// Use the SERIALIZABLE_OBJECT_METHODS() macro in the class to define
-// the following methods to implement:
-//
-// - PrepareForSerialization(): This would be run prior to context
-//   serialization. Use this method to e.g. release references that
-//   can be re-initialized, or perform property store operations
-//   that needs a V8 context.
-// - Serialize(): This would be called during context serialization,
-//   once for each embedder field of the object.
-//   Allocate and construct an InternalFieldInfo object that contains
-//   data that can be used to deserialize native states.
-// - Deserialize(): This would be called after the context is
-//   deserialized and the object graph is complete, once for each
-//   embedder field of the object. Use this to restore native states
-//   in the object.
-class SnapshotableObject : public BaseObject {
- public:
-  SnapshotableObject(Environment* env,
-                     v8::Local<v8::Object> wrap,
-                     EmbedderObjectType type = EmbedderObjectType::k_default);
-  const char* GetTypeNameChars() const;
-
-  virtual void PrepareForSerialization(v8::Local<v8::Context> context,
-                                       v8::SnapshotCreator* creator) = 0;
-  virtual InternalFieldInfo* Serialize(int index) = 0;
-  bool is_snapshotable() const override { return true; }
-  // We'll make sure that the type is set in the constructor
-  EmbedderObjectType type() { return type_; }
-
- private:
-  EmbedderObjectType type_;
-};
-
-#define SERIALIZABLE_OBJECT_METHODS()                                          \
-  void PrepareForSerialization(v8::Local<v8::Context> context,                 \
-                               v8::SnapshotCreator* creator) override;         \
-  InternalFieldInfo* Serialize(int index) override;                            \
-  static void Deserialize(v8::Local<v8::Context> context,                      \
-                          v8::Local<v8::Object> holder,                        \
-                          int index,                                           \
-                          InternalFieldInfo* info);
-
-v8::StartupData SerializeNodeContextInternalFields(v8::Local<v8::Object> holder,
-                                                   int index,
-                                                   void* env);
-void DeserializeNodeInternalFields(v8::Local<v8::Object> holder,
-                                   int index,
-                                   v8::StartupData payload,
-                                   void* env);
-void SerializeBindingData(Environment* env,
-                          v8::SnapshotCreator* creator,
-                          EnvSerializeInfo* info);
-
-bool IsSnapshotableType(FastStringKey key);
-
-class SnapshotBuilder {
- public:
-  static std::string Generate(const std::vector<std::string> args,
-                              const std::vector<std::string> exec_args);
-  static void Generate(SnapshotData* out,
-                       const std::vector<std::string> args,
-                       const std::vector<std::string> exec_args);
-};
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_SNAPSHOTABLE_H_

package/src/headers/16/node_union_bytes.h

@@ -1,103 +0,0 @@
-
-#ifndef SRC_NODE_UNION_BYTES_H_
-#define SRC_NODE_UNION_BYTES_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-// A union of const uint8_t* or const uint16_t* data that can be
-// turned into external v8::String when given an isolate.
-
-#include "v8.h"
-
-namespace node {
-
-class NonOwningExternalOneByteResource
-    : public v8::String::ExternalOneByteStringResource {
- public:
-  explicit NonOwningExternalOneByteResource(const uint8_t* data, size_t length)
-      : data_(data), length_(length) {}
-  ~NonOwningExternalOneByteResource() override = default;
-
-  const char* data() const override {
-    return reinterpret_cast<const char*>(data_);
-  }
-  size_t length() const override { return length_; }
-
-  NonOwningExternalOneByteResource(const NonOwningExternalOneByteResource&) =
-      delete;
-  NonOwningExternalOneByteResource& operator=(
-      const NonOwningExternalOneByteResource&) = delete;
-
- private:
-  const uint8_t* data_;
-  size_t length_;
-};
-
-class NonOwningExternalTwoByteResource
-    : public v8::String::ExternalStringResource {
- public:
-  explicit NonOwningExternalTwoByteResource(const uint16_t* data, size_t length)
-      : data_(data), length_(length) {}
-  ~NonOwningExternalTwoByteResource() override = default;
-
-  const uint16_t* data() const override { return data_; }
-  size_t length() const override { return length_; }
-
-  NonOwningExternalTwoByteResource(const NonOwningExternalTwoByteResource&) =
-      delete;
-  NonOwningExternalTwoByteResource& operator=(
-      const NonOwningExternalTwoByteResource&) = delete;
-
- private:
-  const uint16_t* data_;
-  size_t length_;
-};
-
-// Similar to a v8::String, but it's independent from Isolates
-// and can be materialized in Isolates as external Strings
-// via ToStringChecked. The data pointers are owned by the caller.
-class UnionBytes {
- public:
-  UnionBytes(const uint16_t* data, size_t length)
-      : one_bytes_(nullptr), two_bytes_(data), length_(length) {}
-  UnionBytes(const uint8_t* data, size_t length)
-      : one_bytes_(data), two_bytes_(nullptr), length_(length) {}
-
-  UnionBytes(const UnionBytes&) = default;
-  UnionBytes& operator=(const UnionBytes&) = default;
-  UnionBytes(UnionBytes&&) = default;
-  UnionBytes& operator=(UnionBytes&&) = default;
-
-  bool is_one_byte() const { return one_bytes_ != nullptr; }
-  const uint16_t* two_bytes_data() const {
-    CHECK_NOT_NULL(two_bytes_);
-    return two_bytes_;
-  }
-  const uint8_t* one_bytes_data() const {
-    CHECK_NOT_NULL(one_bytes_);
-    return one_bytes_;
-  }
-  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const {
-    if (is_one_byte()) {
-      NonOwningExternalOneByteResource* source =
-          new NonOwningExternalOneByteResource(one_bytes_data(), length_);
-      return v8::String::NewExternalOneByte(isolate, source).ToLocalChecked();
-    } else {
-      NonOwningExternalTwoByteResource* source =
-          new NonOwningExternalTwoByteResource(two_bytes_data(), length_);
-      return v8::String::NewExternalTwoByte(isolate, source).ToLocalChecked();
-    }
-  }
-  size_t length() { return length_; }
-
- private:
-  const uint8_t* one_bytes_;
-  const uint16_t* two_bytes_;
-  size_t length_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_UNION_BYTES_H_