@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{16 → 24}/node_internals.h

@@ -43,8 +43,8 @@ struct sockaddr;
 
 namespace node {
 
-namespace native_module {
-class NativeModuleLoader;
+namespace builtins {
+class BuiltinLoader;
 }
 
 namespace per_process {
@@ -58,7 +58,7 @@ class Environment;
 // Convert a struct sockaddr to a { address: '1.2.3.4', port: 1234 } JS object.
 // Sets address and port properties on the info object and returns it.
 // If |info| is omitted, a new object is returned.
-v8::Local<v8::Object> AddressToJS(
+v8::MaybeLocal<v8::Object> AddressToJS(
     Environment* env,
     const sockaddr* addr,
     v8::Local<v8::Object> info = v8::Local<v8::Object>());
@@ -66,9 +66,8 @@ v8::Local<v8::Object> AddressToJS(
 template <typename T, int (*F)(const typename T::HandleType*, sockaddr*, int*)>
 void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>& args) {
   T* wrap;
-  ASSIGN_OR_RETURN_UNWRAP(&wrap,
-                          args.Holder(),
-                          args.GetReturnValue().Set(UV_EBADF));
+  ASSIGN_OR_RETURN_UNWRAP(
+      &wrap, args.This(), args.GetReturnValue().Set(UV_EBADF));
   CHECK(args[0]->IsObject());
   sockaddr_storage storage;
   int addrlen = sizeof(storage);
@@ -79,11 +78,30 @@ void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(err);
 }
 
-void PrintStackTrace(v8::Isolate* isolate, v8::Local<v8::StackTrace> stack);
+constexpr int kMaxFrameCountForLogging = 10;
+v8::MaybeLocal<v8::StackTrace> GetCurrentStackTrace(
+    v8::Isolate* isolate, int frame_count = kMaxFrameCountForLogging);
+
+enum class StackTracePrefix {
+  kAt,  // "    at "
+  kNumber
+};
+void PrintCurrentStackTrace(v8::Isolate* isolate,
+                            StackTracePrefix prefix = StackTracePrefix::kAt);
+void PrintStackTrace(v8::Isolate* isolate,
+                     v8::Local<v8::StackTrace> stack,
+                     StackTracePrefix prefix = StackTracePrefix::kAt);
 void PrintCaughtException(v8::Isolate* isolate,
                           v8::Local<v8::Context> context,
                           const v8::TryCatch& try_catch);
-
+std::string FormatCaughtException(v8::Isolate* isolate,
+                                  v8::Local<v8::Context> context,
+                                  const v8::TryCatch& try_catch);
+std::string FormatErrorMessage(v8::Isolate* isolate,
+                               v8::Local<v8::Context> context,
+                               const std::string& reason,
+                               v8::Local<v8::Message> message,
+                               bool add_source_line = true);
 void ResetStdio();  // Safe to call more than once and from signal handlers.
 #ifdef __POSIX__
 void SignalExit(int signal, siginfo_t* info, void* ucontext);
@@ -92,8 +110,13 @@ void SignalExit(int signal, siginfo_t* info, void* ucontext);
 std::string GetProcessTitle(const char* default_title);
 std::string GetHumanReadableProcessName();
 
-v8::Maybe<bool> InitializeContextRuntime(v8::Local<v8::Context> context);
-bool InitializePrimordials(v8::Local<v8::Context> context);
+v8::Maybe<void> InitializeBaseContextForSnapshot(
+    v8::Local<v8::Context> context);
+v8::Maybe<void> InitializeContextRuntime(v8::Local<v8::Context> context);
+v8::Maybe<void> InitializePrimordials(v8::Local<v8::Context> context,
+                                      IsolateData* isolate_data);
+v8::MaybeLocal<v8::Object> InitializePrivateSymbols(
+    v8::Local<v8::Context> context, IsolateData* isolate_data);
 
 class NodeArrayBufferAllocator : public ArrayBufferAllocator {
  public:
@@ -102,7 +125,6 @@ class NodeArrayBufferAllocator : public ArrayBufferAllocator {
   void* Allocate(size_t size) override;  // Defined in src/node.cc
   void* AllocateUninitialized(size_t size) override;
   void Free(void* data, size_t size) override;
-  void* Reallocate(void* data, size_t old_size, size_t size) override;
   virtual void RegisterPointer(void* data, size_t size) {
     total_mem_usage_.fetch_add(size, std::memory_order_relaxed);
   }
@@ -118,6 +140,10 @@ class NodeArrayBufferAllocator : public ArrayBufferAllocator {
  private:
   uint32_t zero_fill_field_ = 1;  // Boolean but exposed as uint32 to JS land.
   std::atomic<size_t> total_mem_usage_ {0};
+
+  // Delegate to V8's allocator for compatibility with the V8 memory cage.
+  std::unique_ptr<v8::ArrayBuffer::Allocator> allocator_{
+      v8::ArrayBuffer::Allocator::NewDefaultAllocator()};
 };
 
 class DebuggingArrayBufferAllocator final : public NodeArrayBufferAllocator {
@@ -126,7 +152,6 @@ class DebuggingArrayBufferAllocator final : public NodeArrayBufferAllocator {
   void* Allocate(size_t size) override;
   void* AllocateUninitialized(size_t size) override;
   void Free(void* data, size_t size) override;
-  void* Reallocate(void* data, size_t old_size, size_t size) override;
   void RegisterPointer(void* data, size_t size) override;
   void UnregisterPointer(void* data, size_t size) override;
 
@@ -171,16 +196,13 @@ static v8::MaybeLocal<v8::Object> New(Environment* env,
   char* src = reinterpret_cast<char*>(buf->out());
   const size_t len_in_bytes = buf->length() * sizeof(buf->out()[0]);
 
-  if (buf->IsAllocated())
+  if (buf->IsAllocated()) {
     ret = New(env, src, len_in_bytes);
-  else if (!buf->IsInvalidated())
-    ret = Copy(env, src, len_in_bytes);
-
-  if (ret.IsEmpty())
-    return ret;
-
-  if (buf->IsAllocated())
+    // new always takes ownership of src
     buf->Release();
+  } else if (!buf->IsInvalidated()) {
+    ret = Copy(env, src, len_in_bytes);
+  }
 
   return ret;
 }
@@ -193,7 +215,17 @@ v8::MaybeLocal<v8::Value> InternalMakeCallback(
     const v8::Local<v8::Function> callback,
     int argc,
     v8::Local<v8::Value> argv[],
-    async_context asyncContext);
+    async_context asyncContext,
+    v8::Local<v8::Value> context_frame);
+
+v8::MaybeLocal<v8::Value> InternalMakeCallback(
+    v8::Isolate* isolate,
+    v8::Local<v8::Object> recv,
+    const v8::Local<v8::Function> callback,
+    int argc,
+    v8::Local<v8::Value> argv[],
+    async_context asyncContext,
+    v8::Local<v8::Value> context_frame);
 
 v8::MaybeLocal<v8::Value> MakeSyncCallback(v8::Isolate* isolate,
                                            v8::Local<v8::Object> recv,
@@ -213,10 +245,13 @@ class InternalCallbackScope {
     // compatibility issues, but it shouldn't.)
     kSkipTaskQueues = 2
   };
-  InternalCallbackScope(Environment* env,
-                        v8::Local<v8::Object> object,
-                        const async_context& asyncContext,
-                        int flags = kNoFlags);
+  InternalCallbackScope(
+      Environment* env,
+      v8::Local<v8::Object> object,
+      const async_context& asyncContext,
+      int flags = kNoFlags,
+      v8::Local<v8::Value> context_frame = v8::Local<v8::Value>());
+
   // Utility that can be used by AsyncWrap classes.
   explicit InternalCallbackScope(AsyncWrap* async_wrap, int flags = 0);
   ~InternalCallbackScope();
@@ -234,6 +269,7 @@ class InternalCallbackScope {
   bool failed_ = false;
   bool pushed_ids_ = false;
   bool closed_ = false;
+  v8::Global<v8::Value> prior_context_frame_;
 };
 
 class DebugSealHandleScope {
@@ -252,7 +288,8 @@ class DebugSealHandleScope {
 
 class ThreadPoolWork {
  public:
-  explicit inline ThreadPoolWork(Environment* env) : env_(env) {
+  explicit inline ThreadPoolWork(Environment* env, const char* type)
+      : env_(env), type_(type) {
     CHECK_NOT_NULL(env);
   }
   inline virtual ~ThreadPoolWork() = default;
@@ -268,6 +305,7 @@ class ThreadPoolWork {
  private:
   Environment* env_;
   uv_work_t work_req_;
+  const char* type_;
 };
 
 #define TRACING_CATEGORY_NODE "node"
@@ -283,49 +321,51 @@ class ThreadPoolWork {
 
 #if defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
 #define NODE_IMPLEMENTS_POSIX_CREDENTIALS 1
-#endif  // __POSIX__ && !defined(__ANDROID__) && !defined(__CloudABI__)
+#endif  // defined(__POSIX__) && !defined(__ANDROID__) && !defined(__CloudABI__)
 
 namespace credentials {
 bool SafeGetenv(const char* key, std::string* text, Environment* env = nullptr);
 }  // namespace credentials
 
+void TraceEnvVar(Environment* env, const char* message);
+void TraceEnvVar(Environment* env, const char* message, const char* key);
+void TraceEnvVar(Environment* env,
+                 const char* message,
+                 v8::Local<v8::String> key);
+
 void DefineZlibConstants(v8::Local<v8::Object> target);
 v8::Isolate* NewIsolate(v8::Isolate::CreateParams* params,
                         uv_loop_t* event_loop,
-                        MultiIsolatePlatform* platform);
+                        MultiIsolatePlatform* platform,
+                        const SnapshotData* snapshot_data = nullptr,
+                        const IsolateSettings& settings = {});
 // This overload automatically picks the right 'main_script_id' if no callback
 // was provided by the embedder.
 v8::MaybeLocal<v8::Value> StartExecution(Environment* env,
                                          StartExecutionCallback cb = nullptr);
-v8::MaybeLocal<v8::Object> GetPerContextExports(v8::Local<v8::Context> context);
-v8::MaybeLocal<v8::Value> ExecuteBootstrapper(
-    Environment* env,
-    const char* id,
-    std::vector<v8::Local<v8::String>>* parameters,
-    std::vector<v8::Local<v8::Value>>* arguments);
+v8::MaybeLocal<v8::Object> GetPerContextExports(
+    v8::Local<v8::Context> context, IsolateData* isolate_data = nullptr);
 void MarkBootstrapComplete(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-struct InitializationResult {
-  int exit_code = 0;
-  std::vector<std::string> args;
-  std::vector<std::string> exec_args;
-  bool early_return = false;
-};
-
-enum InitializationSettingsFlags : uint64_t {
-  kDefaultInitialization = 1 << 0,
-  kInitializeV8 = 1 << 1,
-  kRunPlatformInit = 1 << 2,
-  kInitOpenSSL = 1 << 3
+class InitializationResultImpl final : public InitializationResult {
+ public:
+  ~InitializationResultImpl() = default;
+  int exit_code() const { return static_cast<int>(exit_code_enum()); }
+  ExitCode exit_code_enum() const { return exit_code_; }
+  bool early_return() const { return early_return_; }
+  const std::vector<std::string>& args() const { return args_; }
+  const std::vector<std::string>& exec_args() const { return exec_args_; }
+  const std::vector<std::string>& errors() const { return errors_; }
+  MultiIsolatePlatform* platform() const { return platform_; }
+
+  ExitCode exit_code_ = ExitCode::kNoFailure;
+  std::vector<std::string> args_;
+  std::vector<std::string> exec_args_;
+  std::vector<std::string> errors_;
+  bool early_return_ = false;
+  MultiIsolatePlatform* platform_ = nullptr;
 };
 
-// TODO(codebytere): eventually document and expose to embedders.
-InitializationResult InitializeOncePerProcess(int argc, char** argv);
-InitializationResult InitializeOncePerProcess(
-  int argc,
-  char** argv,
-  InitializationSettingsFlags flags);
-void TearDownOncePerProcess();
 void SetIsolateErrorHandlers(v8::Isolate* isolate, const IsolateSettings& s);
 void SetIsolateMiscHandlers(v8::Isolate* isolate, const IsolateSettings& s);
 void SetIsolateCreateParamsForNode(v8::Isolate::CreateParams* params);
@@ -344,11 +384,12 @@ bool HasSignalJSHandler(int signum);
 
 #ifdef _WIN32
 typedef SYSTEMTIME TIME_TYPE;
-#else  // UNIX, OSX
+#else  // UNIX, macOS
 typedef struct tm TIME_TYPE;
 #endif
 
 double GetCurrentTimeInMicroseconds();
+int WriteFileSync(const char* path, uv_buf_t* bufs, size_t buf_count);
 int WriteFileSync(const char* path, uv_buf_t buf);
 int WriteFileSync(v8::Isolate* isolate,
                   const char* path,
@@ -378,26 +419,11 @@ class DiagnosticFilename {
 };
 
 namespace heap {
-bool WriteSnapshot(v8::Isolate* isolate, const char* filename);
+v8::Maybe<void> WriteSnapshot(Environment* env,
+                              const char* filename,
+                              v8::HeapProfiler::HeapSnapshotOptions options);
 }
 
-class TraceEventScope {
- public:
-  TraceEventScope(const char* category,
-                  const char* name,
-                  void* id) : category_(category), name_(name), id_(id) {
-    TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(category_, name_, id_);
-  }
-  ~TraceEventScope() {
-    TRACE_EVENT_NESTABLE_ASYNC_END0(category_, name_, id_);
-  }
-
- private:
-  const char* category_;
-  const char* name_;
-  void* id_;
-};
-
 namespace heap {
 
 void DeleteHeapSnapshot(const v8::HeapSnapshot* snapshot);
@@ -408,12 +434,41 @@ BaseObjectPtr<AsyncWrap> CreateHeapSnapshotStream(
     Environment* env, HeapSnapshotPointer&& snapshot);
 }  // namespace heap
 
-namespace fs {
-std::string Basename(const std::string& str, const std::string& extension);
-}  // namespace fs
-
 node_module napi_module_to_node_module(const napi_module* mod);
 
+std::ostream& operator<<(std::ostream& output, const SnapshotFlags& flags);
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<SnapshotIndex>& v);
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<std::string>& vec);
+std::ostream& operator<<(std::ostream& output,
+                         const std::vector<PropInfo>& vec);
+std::ostream& operator<<(std::ostream& output, const PropInfo& d);
+std::ostream& operator<<(std::ostream& output, const EnvSerializeInfo& d);
+std::ostream& operator<<(std::ostream& output,
+                         const ImmediateInfo::SerializeInfo& d);
+std::ostream& operator<<(std::ostream& output,
+                         const TickInfo::SerializeInfo& d);
+std::ostream& operator<<(std::ostream& output,
+                         const AsyncHooks::SerializeInfo& d);
+std::ostream& operator<<(std::ostream& output, const SnapshotMetadata& d);
+
+namespace performance {
+std::ostream& operator<<(std::ostream& output,
+                         const PerformanceState::SerializeInfo& d);
+}
+
+bool linux_at_secure();
+
+namespace heap {
+v8::HeapProfiler::HeapSnapshotOptions GetHeapSnapshotOptions(
+    v8::Local<v8::Value> options);
+}  // namespace heap
+
+enum encoding ParseEncoding(v8::Isolate* isolate,
+                            v8::Local<v8::Value> encoding_v,
+                            v8::Local<v8::Value> encoding_id,
+                            enum encoding default_encoding);
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/24/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/src/headers/24/node_large_page.h

@@ -0,0 +1,34 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// 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.
+//
+// SPDX-License-Identifier: MIT
+
+#ifndef SRC_LARGE_PAGES_NODE_LARGE_PAGE_H_
+#define SRC_LARGE_PAGES_NODE_LARGE_PAGE_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+int MapStaticCodeToLargePages();
+const char* LargePagesError(int status);
+}  // namespace node
+
+#endif  // NODE_WANT_INTERNALS
+#endif  // SRC_LARGE_PAGES_NODE_LARGE_PAGE_H_

package/src/headers/24/node_locks.h

@@ -0,0 +1,180 @@
+#ifndef SRC_NODE_LOCKS_H_
+#define SRC_NODE_LOCKS_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <deque>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "base_object.h"
+#include "env.h"
+#include "node_mutex.h"
+#include "v8.h"
+
+namespace node::worker::locks {
+
+class Lock final {
+ public:
+  enum class Mode { Shared, Exclusive };
+
+  Lock(Environment* env,
+       const std::u16string& name,
+       Mode mode,
+       const std::string& client_id,
+       v8::Local<v8::Promise::Resolver> waiting,
+       v8::Local<v8::Promise::Resolver> released);
+  ~Lock() = default;
+
+  Lock(const Lock&) = delete;
+  Lock& operator=(const Lock&) = delete;
+
+  // Resource name for this lock as DOMString
+  const std::u16string& name() const { return name_; }
+  // Lock mode (shared or exclusive).
+  Mode mode() const { return mode_; }
+  // Client identifier string.
+  const std::string& client_id() const { return client_id_; }
+  // Environment that owns this lock.
+  Environment* env() const { return env_; }
+
+  // Returns true if this lock was stolen by another request.
+  bool is_stolen() const { return stolen_; }
+  // Marks this lock as stolen.
+  void mark_stolen() { stolen_ = true; }
+
+  // Promise that resolves when the user callback completes.
+  v8::Local<v8::Promise::Resolver> waiting_promise() {
+    return waiting_promise_.Get(env_->isolate());
+  }
+  // Promise that resolves when the lock is finally released.
+  v8::Local<v8::Promise::Resolver> released_promise() {
+    return released_promise_.Get(env_->isolate());
+  }
+
+ private:
+  Environment* env_;
+  std::u16string name_;
+  Mode mode_;
+  std::string client_id_;
+  bool stolen_ = false;
+  v8::Global<v8::Promise::Resolver> waiting_promise_;
+  v8::Global<v8::Promise::Resolver> released_promise_;
+};
+
+class LockHolder final : public BaseObject {
+ public:
+  LockHolder(Environment* env,
+             v8::Local<v8::Object> obj,
+             std::shared_ptr<Lock> lock)
+      : BaseObject(env, obj), lock_(std::move(lock)) {
+    MakeWeak();
+  }
+
+  ~LockHolder() = default;
+
+  LockHolder(const LockHolder&) = delete;
+  LockHolder& operator=(const LockHolder&) = delete;
+
+  std::shared_ptr<Lock> lock() const { return lock_; }
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(LockHolder)
+  SET_SELF_SIZE(LockHolder)
+
+  static BaseObjectPtr<LockHolder> Create(Environment* env,
+                                          std::shared_ptr<Lock> lock);
+
+ private:
+  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
+      Environment* env);
+
+  std::shared_ptr<Lock> lock_;
+};
+
+class LockRequest final {
+ public:
+  LockRequest(Environment* env,
+              v8::Local<v8::Promise::Resolver> waiting,
+              v8::Local<v8::Promise::Resolver> released,
+              v8::Local<v8::Function> callback,
+              const std::u16string& name,
+              Lock::Mode mode,
+              const std::string& client_id,
+              bool steal,
+              bool if_available);
+  ~LockRequest() = default;
+
+  LockRequest(const LockRequest&) = delete;
+  LockRequest& operator=(const LockRequest&) = delete;
+
+  const std::u16string& name() const { return name_; }
+  Lock::Mode mode() const { return mode_; }
+  const std::string& client_id() const { return client_id_; }
+  bool steal() const { return steal_; }
+  // Returns true if this is an ifAvailable request.
+  bool if_available() const { return if_available_; }
+  Environment* env() const { return env_; }
+
+  v8::Local<v8::Promise::Resolver> waiting_promise() {
+    return waiting_promise_.Get(env_->isolate());
+  }
+  v8::Local<v8::Promise::Resolver> released_promise() {
+    return released_promise_.Get(env_->isolate());
+  }
+  v8::Local<v8::Function> callback() { return callback_.Get(env_->isolate()); }
+
+ private:
+  Environment* env_;
+  std::u16string name_;
+  Lock::Mode mode_;
+  std::string client_id_;
+  bool steal_;
+  bool if_available_;
+  v8::Global<v8::Promise::Resolver> waiting_promise_;
+  v8::Global<v8::Promise::Resolver> released_promise_;
+  v8::Global<v8::Function> callback_;
+};
+
+class LockManager final {
+ public:
+  static void Request(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Query(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  void ProcessQueue(Environment* env);
+  void CleanupEnvironment(Environment* env);
+
+  static void OnEnvironmentCleanup(void* arg);
+  static LockManager* GetCurrent() { return &current_; }
+  void ReleaseLockAndProcessQueue(Environment* env,
+                                  std::shared_ptr<Lock> lock,
+                                  v8::Local<v8::Value> result,
+                                  bool was_rejected = false);
+
+ private:
+  LockManager() = default;
+  ~LockManager() = default;
+
+  LockManager(const LockManager&) = delete;
+  LockManager& operator=(const LockManager&) = delete;
+
+  bool IsGrantable(const LockRequest* req) const;
+  void CleanupStolenLocks(Environment* env);
+  void ReleaseLock(Lock* lock);
+  void WakeEnvironment(Environment* env);
+
+  static LockManager current_;
+
+  mutable Mutex mutex_;
+  // All entries for a given Environment* are purged in CleanupEnvironment().
+  std::unordered_map<std::u16string, std::deque<std::shared_ptr<Lock>>>
+      held_locks_;
+  std::deque<std::unique_ptr<LockRequest>> pending_queue_;
+  std::unordered_set<Environment*> registered_envs_;
+};
+
+}  // namespace node::worker::locks
+
+#endif  // NODE_WANT_INTERNALS
+#endif  // SRC_NODE_LOCKS_H_

package/src/headers/{14 → 24}/node_main_instance.h

@@ -7,67 +7,38 @@
 #include <memory>
 
 #include "node.h"
+#include "node_exit_code.h"
 #include "util.h"
 #include "uv.h"
 #include "v8.h"
 
 namespace node {
 
+class ExternalReferenceRegistry;
+struct EnvSerializeInfo;
+struct SnapshotData;
+
 // TODO(joyeecheung): align this with the Worker/WorkerThreadData class.
 // We may be able to create an abstract class to reuse some of the routines.
 class NodeMainInstance {
  public:
-  // To create a main instance that does not own the isolate,
-  // The caller needs to do:
-  //
-  //   Isolate* isolate = Isolate::Allocate();
-  //   platform->RegisterIsolate(isolate, loop);
-  //   isolate->Initialize(...);
-  //   isolate->Enter();
-  //   std::unique_ptr<NodeMainInstance> main_instance =
-  //       NodeMainInstance::Create(isolate, loop, args, exec_args);
-  //
-  // When tearing it down:
-  //
-  //   main_instance->Cleanup();  // While the isolate is entered
-  //   isolate->Exit();
-  //   isolate->Dispose();
-  //   platform->UnregisterIsolate(isolate);
-  //
-  // After calling Dispose() the main_instance is no longer accessible.
-  static std::unique_ptr<NodeMainInstance> Create(
-      v8::Isolate* isolate,
-      uv_loop_t* event_loop,
-      MultiIsolatePlatform* platform,
-      const std::vector<std::string>& args,
-      const std::vector<std::string>& exec_args);
-
-  void Dispose();
-
   // Create a main instance that owns the isolate
-  NodeMainInstance(
-      v8::Isolate::CreateParams* params,
-      uv_loop_t* event_loop,
-      MultiIsolatePlatform* platform,
-      const std::vector<std::string>& args,
-      const std::vector<std::string>& exec_args,
-      const std::vector<size_t>* per_isolate_data_indexes = nullptr);
+  NodeMainInstance(const SnapshotData* snapshot_data,
+                   uv_loop_t* event_loop,
+                   MultiIsolatePlatform* platform,
+                   const std::vector<std::string>& args,
+                   const std::vector<std::string>& exec_args);
   ~NodeMainInstance();
 
   // Start running the Node.js instances, return the exit code when finished.
-  int Run();
+  ExitCode Run();
+  void Run(ExitCode* exit_code, Environment* env);
 
   IsolateData* isolate_data() { return isolate_data_.get(); }
 
   DeleteFnPtr<Environment, FreeEnvironment> CreateMainEnvironment(
-      int* exit_code);
-
-  // If nullptr is returned, the binary is not built with embedded
-  // snapshot.
-  static const std::vector<size_t>* GetIsolateDataIndexes();
-  static v8::StartupData* GetEmbeddedSnapshotBlob();
+      ExitCode* exit_code);
 
-  static const size_t kNodeContextIndex = 0;
   NodeMainInstance(const NodeMainInstance&) = delete;
   NodeMainInstance& operator=(const NodeMainInstance&) = delete;
   NodeMainInstance(NodeMainInstance&&) = delete;
@@ -86,8 +57,8 @@ class NodeMainInstance {
   v8::Isolate* isolate_;
   MultiIsolatePlatform* platform_;
   std::unique_ptr<IsolateData> isolate_data_;
-  bool owns_isolate_ = false;
-  bool deserialize_mode_ = false;
+  std::unique_ptr<v8::Isolate::CreateParams> isolate_params_;
+  const SnapshotData* snapshot_data_ = nullptr;
 };
 
 }  // namespace node