@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{18 → 24}/js_native_api_v8.h

@@ -1,22 +1,21 @@
 #ifndef SRC_JS_NATIVE_API_V8_H_
 #define SRC_JS_NATIVE_API_V8_H_
 
-// This file needs to be compatible with C compilers.
-#include <string.h>  // NOLINT(modernize-deprecated-headers)
 #include "js_native_api_types.h"
 #include "js_native_api_v8_internals.h"
 
-static napi_status napi_clear_last_error(napi_env env);
+inline napi_status napi_clear_last_error(node_api_basic_env env);
 
 namespace v8impl {
 
+// Base class to track references and finalizers in a doubly linked list.
 class RefTracker {
  public:
-  RefTracker() {}
-  virtual ~RefTracker() {}
-  virtual void Finalize(bool isEnvTeardown) {}
+  using RefList = RefTracker;
 
-  typedef RefTracker RefList;
+  RefTracker() = default;
+  virtual ~RefTracker() = default;
+  virtual void Finalize() {}
 
   inline void Link(RefList* list) {
     prev_ = list;
@@ -40,7 +39,7 @@ class RefTracker {
 
   static void FinalizeAll(RefList* list) {
     while (list->next_ != nullptr) {
-      list->next_->Finalize(true);
+      list->next_->Finalize();
     }
   }
 
@@ -52,14 +51,13 @@ class RefTracker {
 }  // end of namespace v8impl
 
 struct napi_env__ {
-  explicit napi_env__(v8::Local<v8::Context> context)
-      : isolate(context->GetIsolate()), context_persistent(isolate, context) {
-    CHECK_EQ(isolate, context->GetIsolate());
+  explicit napi_env__(v8::Local<v8::Context> context,
+                      int32_t module_api_version)
+      : isolate(context->GetIsolate()),
+        context_persistent(isolate, context),
+        module_api_version(module_api_version) {
     napi_clear_last_error(this);
   }
-  virtual ~napi_env__() { FinalizeAll(); }
-  v8::Isolate* const isolate;  // Shortcut for context()->GetIsolate()
-  v8impl::Persistent<v8::Context> context_persistent;
 
   inline v8::Local<v8::Context> context() const {
     return v8impl::PersistentToLocal::Strong(context_persistent);
@@ -67,19 +65,26 @@ struct napi_env__ {
 
   inline void Ref() { refs++; }
   inline void Unref() {
-    if (--refs == 0) delete this;
+    if (--refs == 0) DeleteMe();
   }
 
   virtual bool can_call_into_js() const { return true; }
-  virtual v8::Maybe<bool> mark_arraybuffer_as_untransferable(
-      v8::Local<v8::ArrayBuffer> ab) const {
-    return v8::Just(true);
-  }
 
   static inline void HandleThrow(napi_env env, v8::Local<v8::Value> value) {
+    if (env->terminatedOrTerminating()) {
+      return;
+    }
     env->isolate->ThrowException(value);
   }
 
+  // i.e. whether v8 exited or is about to exit
+  inline bool terminatedOrTerminating() {
+    return this->isolate->IsExecutionTerminating() || !can_call_into_js();
+  }
+
+  // v8 uses a special exception to indicate termination, the
+  // `handle_exception` callback should identify such case using
+  // terminatedOrTerminating() before actually handle the exception
   template <typename T, typename U = decltype(HandleThrow)>
   inline void CallIntoModule(T&& call, U&& handle_exception = HandleThrow) {
     int open_handle_scopes_before = open_handle_scopes;
@@ -94,14 +99,26 @@ struct napi_env__ {
     }
   }
 
-  // This should be overridden to schedule the finalization to a properiate
-  // timing, like next tick of the event loop.
-  virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) {
-    v8::HandleScope handle_scope(isolate);
-    CallIntoModule([&](napi_env env) { cb(env, data, hint); });
+  virtual void CallFinalizer(napi_finalize cb, void* data, void* hint) = 0;
+
+  // Invoke finalizer from V8 garbage collector.
+  void InvokeFinalizerFromGC(v8impl::RefTracker* finalizer);
+
+  // Enqueue the finalizer to the napi_env's own queue of the second pass
+  // weak callback.
+  // Implementation should drain the queue at the time it is safe to call
+  // into JavaScript.
+  virtual void EnqueueFinalizer(v8impl::RefTracker* finalizer) {
+    pending_finalizers.emplace(finalizer);
+  }
+
+  // Remove the finalizer from the scheduled second pass weak callback queue.
+  // The finalizer can be deleted after this call.
+  virtual void DequeueFinalizer(v8impl::RefTracker* finalizer) {
+    pending_finalizers.erase(finalizer);
   }
 
-  void FinalizeAll() {
+  virtual void DeleteMe() {
     // First we must finalize those references that have `napi_finalizer`
     // callbacks. The reason is that addons might store other references which
     // they delete during their `napi_finalizer` callbacks. If we deleted such
@@ -109,8 +126,25 @@ struct napi_env__ {
     // `napi_finalizer` deleted them subsequently.
     v8impl::RefTracker::FinalizeAll(&finalizing_reflist);
     v8impl::RefTracker::FinalizeAll(&reflist);
+    delete this;
   }
 
+  void CheckGCAccess() {
+    if (module_api_version == NAPI_VERSION_EXPERIMENTAL && in_gc_finalizer) {
+      v8impl::OnFatalError(
+          nullptr,
+          "Finalizer is calling a function that may affect GC state.\n"
+          "The finalizers are run directly from GC and must not affect GC "
+          "state.\n"
+          "Use `node_api_post_finalizer` from inside of the finalizer to work "
+          "around this issue.\n"
+          "It schedules the call as a new task in the event loop.");
+    }
+  }
+
+  v8::Isolate* const isolate;  // Shortcut for context()->GetIsolate()
+  v8impl::Persistent<v8::Context> context_persistent;
+
   v8impl::Persistent<v8::Value> last_exception;
 
   // We store references in two different lists, depending on whether they have
@@ -118,54 +152,36 @@ struct napi_env__ {
   // have such a callback. See `~napi_env__()` above for details.
   v8impl::RefTracker::RefList reflist;
   v8impl::RefTracker::RefList finalizing_reflist;
+  // The invocation order of the finalizers is not determined.
+  std::unordered_set<v8impl::RefTracker*> pending_finalizers;
   napi_extended_error_info last_error;
   int open_handle_scopes = 0;
   int open_callback_scopes = 0;
   int refs = 1;
   void* instance_data = nullptr;
-};
-
-// This class is used to keep a napi_env live in a way that
-// is exception safe versus calling Ref/Unref directly
-class EnvRefHolder {
- public:
-  explicit EnvRefHolder(napi_env env) : _env(env) { _env->Ref(); }
-
-  explicit EnvRefHolder(const EnvRefHolder& other) : _env(other.env()) {
-    _env->Ref();
-  }
-
-  EnvRefHolder(EnvRefHolder&& other) {
-    _env = other._env;
-    other._env = nullptr;
-  }
+  int32_t module_api_version = NODE_API_DEFAULT_MODULE_API_VERSION;
+  bool in_gc_finalizer = false;
 
-  ~EnvRefHolder() {
-    if (_env != nullptr) {
-      _env->Unref();
-    }
-  }
-
-  napi_env env(void) const { return _env; }
-
- private:
-  napi_env _env;
+ protected:
+  // Should not be deleted directly. Delete with `napi_env__::DeleteMe()`
+  // instead.
+  virtual ~napi_env__() = default;
 };
 
-static inline napi_status napi_clear_last_error(napi_env env) {
+inline napi_status napi_clear_last_error(node_api_basic_env basic_env) {
+  napi_env env = const_cast<napi_env>(basic_env);
   env->last_error.error_code = napi_ok;
-
-  // TODO(boingoing): Should this be a callback?
   env->last_error.engine_error_code = 0;
   env->last_error.engine_reserved = nullptr;
   env->last_error.error_message = nullptr;
   return napi_ok;
 }
 
-static inline napi_status napi_set_last_error(napi_env env,
-                                              napi_status error_code,
-                                              uint32_t engine_error_code = 0,
-                                              void* engine_reserved = nullptr) {
+inline napi_status napi_set_last_error(node_api_basic_env basic_env,
+                                       napi_status error_code,
+                                       uint32_t engine_error_code = 0,
+                                       void* engine_reserved = nullptr) {
+  napi_env env = const_cast<napi_env>(basic_env);
   env->last_error.error_code = error_code;
   env->last_error.engine_error_code = engine_error_code;
   env->last_error.engine_reserved = engine_reserved;
@@ -194,6 +210,12 @@ static inline napi_status napi_set_last_error(napi_env env,
     }                                                                          \
   } while (0)
 
+#define CHECK_ENV_NOT_IN_GC(env)                                               \
+  do {                                                                         \
+    CHECK_ENV((env));                                                          \
+    (env)->CheckGCAccess();                                                    \
+  } while (0)
+
 #define CHECK_ARG(env, arg)                                                    \
   RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)
 
@@ -209,11 +231,14 @@ static inline napi_status napi_set_last_error(napi_env env,
 
 // NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope
 #define NAPI_PREAMBLE(env)                                                     \
-  CHECK_ENV((env));                                                            \
+  CHECK_ENV_NOT_IN_GC((env));                                                  \
+  RETURN_STATUS_IF_FALSE(                                                      \
+      (env), (env)->last_exception.IsEmpty(), napi_pending_exception);         \
   RETURN_STATUS_IF_FALSE(                                                      \
       (env),                                                                   \
-      (env)->last_exception.IsEmpty() && (env)->can_call_into_js(),            \
-      napi_pending_exception);                                                 \
+      (env)->can_call_into_js(),                                               \
+      (env->module_api_version >= 10 ? napi_cannot_run_js                      \
+                                     : napi_pending_exception));               \
   napi_clear_last_error((env));                                                \
   v8impl::TryCatch try_catch((env))
 
@@ -264,17 +289,15 @@ static inline napi_status napi_set_last_error(napi_env env,
     }                                                                          \
   } while (0)
 
-#define RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, condition, status)           \
-  do {                                                                         \
-    if (!(condition)) {                                                        \
-      return napi_set_last_error(                                              \
-          (env), try_catch.HasCaught() ? napi_pending_exception : (status));   \
-    }                                                                          \
-  } while (0)
-
 #define CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe, status)                    \
   RETURN_STATUS_IF_FALSE_WITH_PREAMBLE((env), !((maybe).IsEmpty()), (status))
 
+#define STATUS_CALL(call)                                                      \
+  do {                                                                         \
+    napi_status status = (call);                                               \
+    if (status != napi_ok) return status;                                      \
+  } while (0)
+
 namespace v8impl {
 
 //=== Conversion between V8 Handles and napi_value ========================
@@ -297,48 +320,27 @@ inline v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {
 // Adapter for napi_finalize callbacks.
 class Finalizer {
  public:
-  // Some Finalizers are run during shutdown when the napi_env is destroyed,
-  // and some need to keep an explicit reference to the napi_env because they
-  // are run independently.
-  enum EnvReferenceMode { kNoEnvReference, kKeepEnvReference };
-
- protected:
   Finalizer(napi_env env,
             napi_finalize finalize_callback,
             void* finalize_data,
-            void* finalize_hint,
-            EnvReferenceMode refmode = kNoEnvReference)
-      : _env(env),
-        _finalize_callback(finalize_callback),
-        _finalize_data(finalize_data),
-        _finalize_hint(finalize_hint),
-        _has_env_reference(refmode == kKeepEnvReference) {
-    if (_has_env_reference) _env->Ref();
-  }
+            void* finalize_hint)
+      : env_(env),
+        finalize_callback_(finalize_callback),
+        finalize_data_(finalize_data),
+        finalize_hint_(finalize_hint) {}
 
-  ~Finalizer() {
-    if (_has_env_reference) _env->Unref();
-  }
-
- public:
-  static Finalizer* New(napi_env env,
-                        napi_finalize finalize_callback = nullptr,
-                        void* finalize_data = nullptr,
-                        void* finalize_hint = nullptr,
-                        EnvReferenceMode refmode = kNoEnvReference) {
-    return new Finalizer(
-        env, finalize_callback, finalize_data, finalize_hint, refmode);
-  }
+  napi_env env() { return env_; }
+  void* data() { return finalize_data_; }
 
-  static void Delete(Finalizer* finalizer) { delete finalizer; }
+  void ResetEnv();
+  void ResetFinalizer();
+  void CallFinalizer();
 
- protected:
-  napi_env _env;
-  napi_finalize _finalize_callback;
-  void* _finalize_data;
-  void* _finalize_hint;
-  bool _finalize_ran = false;
-  bool _has_env_reference = false;
+ private:
+  napi_env env_;
+  napi_finalize finalize_callback_;
+  void* finalize_data_;
+  void* finalize_hint_;
 };
 
 class TryCatch : public v8::TryCatch {
@@ -355,86 +357,129 @@ class TryCatch : public v8::TryCatch {
   napi_env _env;
 };
 
-// Wrapper around v8impl::Persistent that implements reference counting.
-class RefBase : protected Finalizer, RefTracker {
- protected:
-  RefBase(napi_env env,
-          uint32_t initial_refcount,
-          bool delete_self,
-          napi_finalize finalize_callback,
-          void* finalize_data,
-          void* finalize_hint);
-
+// Wrapper around Finalizer that can be tracked.
+class TrackedFinalizer final : public RefTracker {
  public:
-  static RefBase* New(napi_env env,
-                      uint32_t initial_refcount,
-                      bool delete_self,
-                      napi_finalize finalize_callback,
-                      void* finalize_data,
-                      void* finalize_hint);
+  static TrackedFinalizer* New(napi_env env,
+                               napi_finalize finalize_callback,
+                               void* finalize_data,
+                               void* finalize_hint);
+  ~TrackedFinalizer() override;
 
-  static inline void Delete(RefBase* reference);
-
-  virtual ~RefBase();
-  void* Data();
-  uint32_t Ref();
-  uint32_t Unref();
-  uint32_t RefCount();
+  void* data() { return finalizer_.data(); }
 
- protected:
-  void Finalize(bool is_env_teardown = false) override;
+ private:
+  TrackedFinalizer(napi_env env,
+                   napi_finalize finalize_callback,
+                   void* finalize_data,
+                   void* finalize_hint);
+  void Finalize() override;
 
  private:
-  uint32_t _refcount;
-  bool _delete_self;
+  Finalizer finalizer_;
 };
 
-class Reference : public RefBase {
-  using SecondPassCallParameterRef = Reference*;
-
- protected:
-  template <typename... Args>
-  Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args);
+// Ownership of a reference.
+enum class ReferenceOwnership : uint8_t {
+  // The reference is owned by the runtime. No userland call is needed to
+  // destruct the reference.
+  kRuntime,
+  // The reference is owned by the userland. User code is responsible to delete
+  // the reference with appropriate node-api calls.
+  kUserland,
+};
 
+// Wrapper around v8impl::Persistent.
+class Reference : public RefTracker {
  public:
   static Reference* New(napi_env env,
                         v8::Local<v8::Value> value,
                         uint32_t initial_refcount,
-                        bool delete_self,
-                        napi_finalize finalize_callback = nullptr,
-                        void* finalize_data = nullptr,
-                        void* finalize_hint = nullptr);
+                        ReferenceOwnership ownership);
+  ~Reference() override;
 
-  virtual ~Reference();
   uint32_t Ref();
   uint32_t Unref();
-  v8::Local<v8::Value> Get();
+  v8::Local<v8::Value> Get(napi_env env);
+
+  virtual void ResetFinalizer() {}
+  virtual void* Data() { return nullptr; }
+
+  uint32_t refcount() const { return refcount_; }
+  ReferenceOwnership ownership() { return ownership_; }
 
  protected:
-  void Finalize(bool is_env_teardown = false) override;
+  Reference(napi_env env,
+            v8::Local<v8::Value> value,
+            uint32_t initial_refcount,
+            ReferenceOwnership ownership);
+  virtual void CallUserFinalizer() {}
+  virtual void InvokeFinalizerFromGC();
 
  private:
-  void ClearWeak();
+  static void WeakCallback(const v8::WeakCallbackInfo<Reference>& data);
   void SetWeak();
+  void Finalize() override;
+
+ private:
+  v8impl::Persistent<v8::Value> persistent_;
+  uint32_t refcount_;
+  ReferenceOwnership ownership_;
+  bool can_be_weak_;
+};
 
-  static void FinalizeCallback(
-      const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data);
-  static void SecondPassCallback(
-      const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data);
+// Reference that can store additional data.
+class ReferenceWithData final : public Reference {
+ public:
+  static ReferenceWithData* New(napi_env env,
+                                v8::Local<v8::Value> value,
+                                uint32_t initial_refcount,
+                                ReferenceOwnership ownership,
+                                void* data);
 
-  v8impl::Persistent<v8::Value> _persistent;
-  SecondPassCallParameterRef* _secondPassParameter;
-  bool _secondPassScheduled;
+  void* Data() override { return data_; }
 
-  FRIEND_TEST(JsNativeApiV8Test, Reference);
+ private:
+  ReferenceWithData(napi_env env,
+                    v8::Local<v8::Value> value,
+                    uint32_t initial_refcount,
+                    ReferenceOwnership ownership,
+                    void* data);
+
+ private:
+  void* data_;
 };
 
-}  // end of namespace v8impl
+// Reference that has a user finalizer callback.
+class ReferenceWithFinalizer final : public Reference {
+ public:
+  static ReferenceWithFinalizer* New(napi_env env,
+                                     v8::Local<v8::Value> value,
+                                     uint32_t initial_refcount,
+                                     ReferenceOwnership ownership,
+                                     napi_finalize finalize_callback,
+                                     void* finalize_data,
+                                     void* finalize_hint);
+  ~ReferenceWithFinalizer() override;
+
+  void ResetFinalizer() override { finalizer_.ResetFinalizer(); }
+  void* Data() override { return finalizer_.data(); }
 
-#define STATUS_CALL(call)                                                      \
-  do {                                                                         \
-    napi_status status = (call);                                               \
-    if (status != napi_ok) return status;                                      \
-  } while (0)
+ private:
+  ReferenceWithFinalizer(napi_env env,
+                         v8::Local<v8::Value> value,
+                         uint32_t initial_refcount,
+                         ReferenceOwnership ownership,
+                         napi_finalize finalize_callback,
+                         void* finalize_data,
+                         void* finalize_hint);
+  void CallUserFinalizer() override;
+  void InvokeFinalizerFromGC() override;
+
+ private:
+  Finalizer finalizer_;
+};
+
+}  // end of namespace v8impl
 
 #endif  // SRC_JS_NATIVE_API_V8_H_

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

@@ -14,18 +14,19 @@
 // included below, defines `NAPI_VERSION`.
 
 #include "node_version.h"
+
 #include "env.h"
-#include "node_internals.h"
 #include "gtest/gtest_prod.h"
+#include "node_errors.h"
+#include "node_internals.h"
 
-#define NAPI_ARRAYSIZE(array) \
-  node::arraysize((array))
+#define NAPI_ARRAYSIZE(array) node::arraysize((array))
 
-#define NAPI_FIXED_ONE_BYTE_STRING(isolate, string) \
+#define NAPI_FIXED_ONE_BYTE_STRING(isolate, string)                            \
   node::FIXED_ONE_BYTE_STRING((isolate), (string))
 
-#define NAPI_PRIVATE_KEY(context, suffix) \
-  (node::Environment::GetCurrent((context))->napi_ ## suffix())
+#define NAPI_PRIVATE_KEY(context, suffix)                                      \
+  (node::Environment::GetCurrent((context))->napi_##suffix())
 
 namespace v8impl {
 
@@ -34,6 +35,11 @@ using Persistent = v8::Global<T>;
 
 using PersistentToLocal = node::PersistentToLocal;
 
+[[noreturn]] inline void OnFatalError(const char* location,
+                                      const char* message) {
+  node::OnFatalError(location, message);
+}
+
 }  // end of namespace v8impl
 
 #endif  // SRC_JS_NATIVE_API_V8_INTERNALS_H_

package/src/headers/24/json_parser.h

@@ -0,0 +1,40 @@
+#ifndef SRC_JSON_PARSER_H_
+#define SRC_JSON_PARSER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+// This is intended to be used to get some top-level fields out of a JSON
+// without having to spin up a full Node.js environment that unnecessarily
+// complicates things.
+class JSONParser {
+ public:
+  using StringDict = std::unordered_map<std::string, std::string>;
+  JSONParser();
+  ~JSONParser() = default;
+  bool Parse(const std::string& content);
+  std::optional<std::string> GetTopLevelStringField(std::string_view field);
+  std::optional<bool> GetTopLevelBoolField(std::string_view field);
+  std::optional<StringDict> GetTopLevelStringDict(std::string_view field);
+
+ private:
+  // We might want a lighter-weight JSON parser for this use case. But for now
+  // using V8 is good enough.
+  RAIIIsolateWithoutEntering isolate_;
+
+  v8::Global<v8::Context> context_;
+  v8::Global<v8::Object> content_;
+  bool parsed_ = false;
+};
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_JSON_PARSER_H_

package/src/headers/{18 → 24}/json_utils.h

@@ -4,13 +4,21 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include <iomanip>
-#include <ostream>
 #include <limits>
+#include <ostream>
 #include <string>
+#include <string_view>
 
 namespace node {
 
-std::string EscapeJsonChars(const std::string& str);
+constexpr bool NeedsJsonEscape(std::string_view str) {
+  for (const char c : str) {
+    if (c == '\\' || c == '"' || c < 0x20) return true;
+  }
+  return false;
+}
+
+std::string EscapeJsonChars(std::string_view str);
 std::string Reindent(const std::string& str, int indentation);
 
 // JSON compiler definitions.
@@ -128,24 +136,27 @@ class JSONWriter {
             typename test_for_number = typename std::
                 enable_if<std::numeric_limits<T>::is_specialized, bool>::type>
   inline void write_value(T number) {
-    if (std::is_same<T, bool>::value)
+    if constexpr (std::is_same<T, bool>::value)
       out_ << (number ? "true" : "false");
     else
       out_ << number;
   }
 
   inline void write_value(Null null) { out_ << "null"; }
-  inline void write_value(const char* str) { write_string(str); }
-  inline void write_value(const std::string& str) { write_string(str); }
+  inline void write_value(std::string_view str) { write_string(str); }
 
   inline void write_value(const ForeignJSON& json) {
     out_ << Reindent(json.as_string, indent_);
   }
 
-  inline void write_string(const std::string& str) {
-    out_ << '"' << EscapeJsonChars(str) << '"';
+  inline void write_string(std::string_view str) {
+    out_ << '"';
+    if (NeedsJsonEscape(str))  // only create temporary std::string if necessary
+      out_ << EscapeJsonChars(str);
+    else
+      out_ << str;
+    out_ << '"';
   }
-  inline void write_string(const char* str) { write_string(std::string(str)); }
 
   enum JSONState { kObjectStart, kAfterValue };
   std::ostream& out_;