@encharm/cws 4.1.0 → 4.2.0

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

@@ -53,19 +53,11 @@ class RefTracker {
 
 struct napi_env__ {
   explicit napi_env__(v8::Local<v8::Context> context)
-      : isolate(context->GetIsolate()),
-        context_persistent(isolate, context) {
+      : isolate(context->GetIsolate()), context_persistent(isolate, context) {
     CHECK_EQ(isolate, context->GetIsolate());
+    napi_clear_last_error(this);
   }
-  virtual ~napi_env__() {
-    // 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
-    // references here first, they would be doubly deleted when the
-    // `napi_finalizer` deleted them subsequently.
-    v8impl::RefTracker::FinalizeAll(&finalizing_reflist);
-    v8impl::RefTracker::FinalizeAll(&reflist);
-  }
+  virtual ~napi_env__() { FinalizeAll(); }
   v8::Isolate* const isolate;  // Shortcut for context()->GetIsolate()
   v8impl::Persistent<v8::Context> context_persistent;
 
@@ -74,7 +66,9 @@ struct napi_env__ {
   }
 
   inline void Ref() { refs++; }
-  inline void Unref() { if ( --refs == 0) delete this; }
+  inline void Unref() {
+    if (--refs == 0) delete this;
+  }
 
   virtual bool can_call_into_js() const { return true; }
   virtual v8::Maybe<bool> mark_arraybuffer_as_untransferable(
@@ -82,8 +76,12 @@ struct napi_env__ {
     return v8::Just(true);
   }
 
-  template <typename T, typename U>
-  void CallIntoModule(T&& call, U&& handle_exception) {
+  static inline void HandleThrow(napi_env env, v8::Local<v8::Value> value) {
+    env->isolate->ThrowException(value);
+  }
+
+  template <typename T, typename U = decltype(HandleThrow)>
+  inline void CallIntoModule(T&& call, U&& handle_exception = HandleThrow) {
     int open_handle_scopes_before = open_handle_scopes;
     int open_callback_scopes_before = open_callback_scopes;
     napi_clear_last_error(this);
@@ -96,11 +94,21 @@ struct napi_env__ {
     }
   }
 
-  template <typename T>
-  void CallIntoModuleThrow(T&& call) {
-    CallIntoModule(call, [&](napi_env env, v8::Local<v8::Value> value) {
-      env->isolate->ThrowException(value);
-    });
+  // 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); });
+  }
+
+  void FinalizeAll() {
+    // 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
+    // references here first, they would be doubly deleted when the
+    // `napi_finalizer` deleted them subsequently.
+    v8impl::RefTracker::FinalizeAll(&finalizing_reflist);
+    v8impl::RefTracker::FinalizeAll(&reflist);
   }
 
   v8impl::Persistent<v8::Value> last_exception;
@@ -117,86 +125,143 @@ struct napi_env__ {
   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;
+  }
+
+  ~EnvRefHolder() {
+    if (_env != nullptr) {
+      _env->Unref();
+    }
+  }
+
+  napi_env env(void) const { return _env; }
+
+ private:
+  napi_env _env;
+};
+
 static inline napi_status napi_clear_last_error(napi_env 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) {
+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) {
   env->last_error.error_code = error_code;
   env->last_error.engine_error_code = engine_error_code;
   env->last_error.engine_reserved = engine_reserved;
   return error_code;
 }
 
-#define RETURN_STATUS_IF_FALSE(env, condition, status)                  \
-  do {                                                                  \
-    if (!(condition)) {                                                 \
-      return napi_set_last_error((env), (status));                      \
-    }                                                                   \
+#define RETURN_STATUS_IF_FALSE(env, condition, status)                         \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      return napi_set_last_error((env), (status));                             \
+    }                                                                          \
+  } 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_ENV(env)          \
-  do {                          \
-    if ((env) == nullptr) {     \
-      return napi_invalid_arg;  \
-    }                           \
+#define CHECK_ENV(env)                                                         \
+  do {                                                                         \
+    if ((env) == nullptr) {                                                    \
+      return napi_invalid_arg;                                                 \
+    }                                                                          \
   } while (0)
 
-#define CHECK_ARG(env, arg) \
+#define CHECK_ARG(env, arg)                                                    \
   RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)
 
-#define CHECK_MAYBE_EMPTY(env, maybe, status) \
+#define CHECK_ARG_WITH_PREAMBLE(env, arg)                                      \
+  RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(                                        \
+      (env), ((arg) != nullptr), napi_invalid_arg)
+
+#define CHECK_MAYBE_EMPTY(env, maybe, status)                                  \
   RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status))
 
+#define CHECK_MAYBE_EMPTY_WITH_PREAMBLE(env, maybe, status)                    \
+  RETURN_STATUS_IF_FALSE_WITH_PREAMBLE((env), !((maybe).IsEmpty()), (status))
+
 // NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope
-#define NAPI_PREAMBLE(env)                                          \
-  CHECK_ENV((env));                                                 \
-  RETURN_STATUS_IF_FALSE((env),                                     \
-      (env)->last_exception.IsEmpty() && (env)->can_call_into_js(), \
-      napi_pending_exception);                                      \
-  napi_clear_last_error((env));                                     \
+#define NAPI_PREAMBLE(env)                                                     \
+  CHECK_ENV((env));                                                            \
+  RETURN_STATUS_IF_FALSE(                                                      \
+      (env),                                                                   \
+      (env)->last_exception.IsEmpty() && (env)->can_call_into_js(),            \
+      napi_pending_exception);                                                 \
+  napi_clear_last_error((env));                                                \
   v8impl::TryCatch try_catch((env))
 
-#define CHECK_TO_TYPE(env, type, context, result, src, status)                \
-  do {                                                                        \
-    CHECK_ARG((env), (src));                                                  \
-    auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \
-    CHECK_MAYBE_EMPTY((env), maybe, (status));                                \
-    (result) = maybe.ToLocalChecked();                                        \
+#define CHECK_TO_TYPE(env, type, context, result, src, status)                 \
+  do {                                                                         \
+    CHECK_ARG((env), (src));                                                   \
+    auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context));  \
+    CHECK_MAYBE_EMPTY((env), maybe, (status));                                 \
+    (result) = maybe.ToLocalChecked();                                         \
+  } while (0)
+
+#define CHECK_TO_TYPE_WITH_PREAMBLE(env, type, context, result, src, status)   \
+  do {                                                                         \
+    CHECK_ARG_WITH_PREAMBLE((env), (src));                                     \
+    auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context));  \
+    CHECK_MAYBE_EMPTY_WITH_PREAMBLE((env), maybe, (status));                   \
+    (result) = maybe.ToLocalChecked();                                         \
   } while (0)
 
-#define CHECK_TO_FUNCTION(env, result, src)                                 \
-  do {                                                                      \
-    CHECK_ARG((env), (src));                                                \
-    v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue((src));  \
-    RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \
-    (result) = v8value.As<v8::Function>();                                  \
+#define CHECK_TO_FUNCTION(env, result, src)                                    \
+  do {                                                                         \
+    CHECK_ARG((env), (src));                                                   \
+    v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue((src));     \
+    RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg);    \
+    (result) = v8value.As<v8::Function>();                                     \
   } while (0)
 
-#define CHECK_TO_OBJECT(env, context, result, src) \
+#define CHECK_TO_OBJECT(env, context, result, src)                             \
   CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected)
 
-#define CHECK_TO_STRING(env, context, result, src) \
+#define CHECK_TO_OBJECT_WITH_PREAMBLE(env, context, result, src)               \
+  CHECK_TO_TYPE_WITH_PREAMBLE(                                                 \
+      (env), Object, (context), (result), (src), napi_object_expected)
+
+#define CHECK_TO_STRING(env, context, result, src)                             \
   CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected)
 
-#define GET_RETURN_STATUS(env)      \
-  (!try_catch.HasCaught() ? napi_ok \
-                         : napi_set_last_error((env), napi_pending_exception))
+#define GET_RETURN_STATUS(env)                                                 \
+  (!try_catch.HasCaught()                                                      \
+       ? napi_ok                                                               \
+       : napi_set_last_error((env), napi_pending_exception))
 
-#define THROW_RANGE_ERROR_IF_FALSE(env, condition, error, message) \
-  do {                                                             \
-    if (!(condition)) {                                            \
-      napi_throw_range_error((env), (error), (message));           \
-      return napi_set_last_error((env), napi_generic_failure);     \
-    }                                                              \
+#define THROW_RANGE_ERROR_IF_FALSE(env, condition, error, message)             \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      napi_throw_range_error((env), (error), (message));                       \
+      return napi_set_last_error((env), napi_generic_failure);                 \
+    }                                                                          \
   } while (0)
 
 #define RETURN_STATUS_IF_FALSE_WITH_PREAMBLE(env, condition, status)           \
@@ -217,7 +282,7 @@ namespace v8impl {
 // This asserts v8::Local<> will always be implemented with a single
 // pointer field so that we can pass it around as a void*.
 static_assert(sizeof(v8::Local<v8::Value>) == sizeof(napi_value),
-  "Cannot convert between v8::Local<v8::Value> and napi_value");
+              "Cannot convert between v8::Local<v8::Value> and napi_value");
 
 inline napi_value JsValueFromV8LocalValue(v8::Local<v8::Value> local) {
   return reinterpret_cast<napi_value>(*local);
@@ -235,10 +300,7 @@ class Finalizer {
   // 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
-  };
+  enum EnvReferenceMode { kNoEnvReference, kKeepEnvReference };
 
  protected:
   Finalizer(napi_env env,
@@ -246,18 +308,16 @@ class Finalizer {
             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();
+      : _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();
   }
 
   ~Finalizer() {
-    if (_has_env_reference)
-      _env->Unref();
+    if (_has_env_reference) _env->Unref();
   }
 
  public:
@@ -270,9 +330,7 @@ class Finalizer {
         env, finalize_callback, finalize_data, finalize_hint, refmode);
   }
 
-  static void Delete(Finalizer* finalizer) {
-    delete finalizer;
-  }
+  static void Delete(Finalizer* finalizer) { delete finalizer; }
 
  protected:
   napi_env _env;
@@ -285,8 +343,7 @@ class Finalizer {
 
 class TryCatch : public v8::TryCatch {
  public:
-  explicit TryCatch(napi_env env)
-      : v8::TryCatch(env->isolate), _env(env) {}
+  explicit TryCatch(napi_env env) : v8::TryCatch(env->isolate), _env(env) {}
 
   ~TryCatch() {
     if (HasCaught()) {
@@ -298,6 +355,86 @@ 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);
+
+ 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 inline void Delete(RefBase* reference);
+
+  virtual ~RefBase();
+  void* Data();
+  uint32_t Ref();
+  uint32_t Unref();
+  uint32_t RefCount();
+
+ protected:
+  void Finalize(bool is_env_teardown = false) override;
+
+ private:
+  uint32_t _refcount;
+  bool _delete_self;
+};
+
+class Reference : public RefBase {
+  using SecondPassCallParameterRef = Reference*;
+
+ protected:
+  template <typename... Args>
+  Reference(napi_env env, v8::Local<v8::Value> value, Args&&... args);
+
+ 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);
+
+  virtual ~Reference();
+  uint32_t Ref();
+  uint32_t Unref();
+  v8::Local<v8::Value> Get();
+
+ protected:
+  void Finalize(bool is_env_teardown = false) override;
+
+ private:
+  void ClearWeak();
+  void SetWeak();
+
+  static void FinalizeCallback(
+      const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data);
+  static void SecondPassCallback(
+      const v8::WeakCallbackInfo<SecondPassCallParameterRef>& data);
+
+  v8impl::Persistent<v8::Value> _persistent;
+  SecondPassCallParameterRef* _secondPassParameter;
+  bool _secondPassScheduled;
+
+  FRIEND_TEST(JsNativeApiV8Test, Reference);
+};
+
 }  // end of namespace v8impl
 
+#define STATUS_CALL(call)                                                      \
+  do {                                                                         \
+    napi_status status = (call);                                               \
+    if (status != napi_ok) return status;                                      \
+  } while (0)
+
 #endif  // SRC_JS_NATIVE_API_V8_H_

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

@@ -14,17 +14,18 @@
 // included below, defines `NAPI_VERSION`.
 
 #include "node_version.h"
+
 #include "env.h"
+#include "gtest/gtest_prod.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 {
 

package/src/headers/{13 → 18}/memory_tracker-inl.h

@@ -22,7 +22,7 @@ inline const char* GetNodeName(const char* node_name, const char* edge_name) {
 class MemoryRetainerNode : public v8::EmbedderGraph::Node {
  public:
   inline MemoryRetainerNode(MemoryTracker* tracker,
-                                     const MemoryRetainer* retainer)
+                            const MemoryRetainer* retainer)
       : retainer_(retainer) {
     CHECK_NOT_NULL(retainer_);
     v8::HandleScope handle_scope(tracker->isolate());
@@ -34,9 +34,9 @@ class MemoryRetainerNode : public v8::EmbedderGraph::Node {
   }
 
   inline MemoryRetainerNode(MemoryTracker* tracker,
-                                     const char* name,
-                                     size_t size,
-                                     bool is_root_node = false)
+                            const char* name,
+                            size_t size,
+                            bool is_root_node = false)
       : retainer_(nullptr) {
     name_ = name;
     size_ = size;
@@ -131,7 +131,7 @@ template <typename T, bool kIsWeak>
 void MemoryTracker::TrackField(const char* edge_name,
                                const BaseObjectPtrImpl<T, kIsWeak>& value,
                                const char* node_name) {
-  if (value.get() == nullptr) return;
+  if (value.get() == nullptr || kIsWeak) return;
   TrackField(edge_name, value.get(), node_name);
 }
 
@@ -214,6 +214,7 @@ template <typename T>
 void MemoryTracker::TrackField(const char* edge_name,
                                const v8::PersistentBase<T>& value,
                                const char* node_name) {
+  if (value.IsWeak()) return;
   TrackField(edge_name, value.Get(isolate_));
 }
 

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

@@ -216,13 +216,6 @@ class MemoryTracker {
   inline void TrackField(const char* edge_name,
                          const v8::BackingStore* value,
                          const char* node_name = nullptr);
-  // We do not implement CleanupHookCallback as MemoryRetainer
-  // but instead specialize the method here to avoid the cost of
-  // virtual pointers.
-  // TODO(joyeecheung): do this for BaseObject and remove WrappedObject()
-  void TrackField(const char* edge_name,
-                  const CleanupHookCallback& value,
-                  const char* node_name = nullptr);
   inline void TrackField(const char* edge_name,
                          const uv_buf_t& value,
                          const char* node_name = nullptr);

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

@@ -12,6 +12,10 @@ namespace node {
 
 class Environment;
 
+namespace contextify {
+class ContextifyContext;
+}
+
 namespace loader {
 
 enum ScriptType : int {
@@ -28,6 +32,14 @@ enum HostDefinedOptions : int {
 
 class ModuleWrap : public BaseObject {
  public:
+  enum InternalFields {
+    kModuleWrapBaseField = BaseObject::kInternalFieldCount,
+    kURLSlot,
+    kSyntheticEvaluationStepsSlot,
+    kContextObjectSlot,  // Object whose creation context is the target Context
+    kInternalFieldCount
+  };
+
   static void Initialize(v8::Local<v8::Object> target,
                          v8::Local<v8::Value> unused,
                          v8::Local<v8::Context> context,
@@ -38,16 +50,22 @@ class ModuleWrap : public BaseObject {
       v8::Local<v8::Object> meta);
 
   void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("url", url_);
     tracker->TrackField("resolve_cache", resolve_cache_);
   }
 
   inline uint32_t id() { return id_; }
+  v8::Local<v8::Context> context() const;
   static ModuleWrap* GetFromID(node::Environment*, uint32_t id);
 
   SET_MEMORY_INFO_NAME(ModuleWrap)
   SET_SELF_SIZE(ModuleWrap)
 
+  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
+    // XXX: The garbage collection rules for ModuleWrap are *super* unclear.
+    // Do these objects ever get GC'd? Are we just okay with leaking them?
+    return true;
+  }
+
  private:
   ModuleWrap(Environment* env,
              v8::Local<v8::Object> object,
@@ -75,19 +93,18 @@ class ModuleWrap : public BaseObject {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void CreateCachedData(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-  static v8::MaybeLocal<v8::Module> ResolveCallback(
+  static v8::MaybeLocal<v8::Module> ResolveModuleCallback(
       v8::Local<v8::Context> context,
       v8::Local<v8::String> specifier,
+      v8::Local<v8::FixedArray> import_assertions,
       v8::Local<v8::Module> referrer);
   static ModuleWrap* GetFromModule(node::Environment*, v8::Local<v8::Module>);
 
-  v8::Global<v8::Function> synthetic_evaluation_steps_;
-  bool synthetic_ = false;
   v8::Global<v8::Module> module_;
-  v8::Global<v8::String> url_;
-  bool linked_ = false;
   std::unordered_map<std::string, v8::Global<v8::Promise>> resolve_cache_;
-  v8::Global<v8::Context> context_;
+  contextify::ContextifyContext* contextify_context_ = nullptr;
+  bool synthetic_ = false;
+  bool linked_ = false;
   uint32_t id_;
 };