Upload Kmake

test/js-native-api/6_object_wrap/binding.gyp

@@ -0,0 +1,28 @@
+{
+  "targets": [
+    {
+      "target_name": "myobject",
+      "sources": [
+        "myobject.cc",
+        "myobject.h",
+      ]
+    },
+    {
+      "target_name": "myobject_basic_finalizer",
+      "defines": [ "NAPI_EXPERIMENTAL" ],
+      "sources": [
+        "myobject.cc",
+        "myobject.h",
+      ]
+    },
+    {
+      "target_name": "nested_wrap",
+      # Test without basic finalizers as it schedules differently.
+      "defines": [ "NAPI_VERSION=10" ],
+      "sources": [
+        "nested_wrap.cc",
+        "nested_wrap.h",
+      ],
+    },
+  ]
+}

test/js-native-api/6_object_wrap/myobject.cc

@@ -0,0 +1,270 @@
+#include "myobject.h"
+#include "../common.h"
+#include "../entry_point.h"
+#include "assert.h"
+
+typedef int32_t FinalizerData;
+
+napi_ref MyObject::constructor;
+
+MyObject::MyObject(double value)
+    : value_(value), env_(nullptr), wrapper_(nullptr) {}
+
+MyObject::~MyObject() {
+  napi_delete_reference(env_, wrapper_);
+}
+
+void MyObject::Destructor(node_api_basic_env env,
+                          void* nativeObject,
+                          void* /*finalize_hint*/) {
+  MyObject* obj = static_cast<MyObject*>(nativeObject);
+  delete obj;
+
+  FinalizerData* data;
+  NODE_API_BASIC_CALL_RETURN_VOID(
+      env, napi_get_instance_data(env, reinterpret_cast<void**>(&data)));
+  *data += 1;
+}
+
+void MyObject::Init(napi_env env, napi_value exports) {
+  napi_property_descriptor properties[] = {
+      {"value", nullptr, nullptr, GetValue, SetValue, 0, napi_default, 0},
+      {"valueReadonly",
+       nullptr,
+       nullptr,
+       GetValue,
+       nullptr,
+       0,
+       napi_default,
+       0},
+      DECLARE_NODE_API_PROPERTY("plusOne", PlusOne),
+      DECLARE_NODE_API_PROPERTY("multiply", Multiply),
+  };
+
+  napi_value cons;
+  NODE_API_CALL_RETURN_VOID(
+      env,
+      napi_define_class(env,
+                        "MyObject",
+                        -1,
+                        New,
+                        nullptr,
+                        sizeof(properties) / sizeof(napi_property_descriptor),
+                        properties,
+                        &cons));
+
+  NODE_API_CALL_RETURN_VOID(env,
+                            napi_create_reference(env, cons, 1, &constructor));
+
+  NODE_API_CALL_RETURN_VOID(
+      env, napi_set_named_property(env, exports, "MyObject", cons));
+}
+
+napi_value MyObject::New(napi_env env, napi_callback_info info) {
+  napi_value new_target;
+  NODE_API_CALL(env, napi_get_new_target(env, info, &new_target));
+  bool is_constructor = (new_target != nullptr);
+
+  size_t argc = 1;
+  napi_value args[1];
+  napi_value _this;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
+
+  if (is_constructor) {
+    // Invoked as constructor: `new MyObject(...)`
+    double value = 0;
+
+    napi_valuetype valuetype;
+    NODE_API_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+    if (valuetype != napi_undefined) {
+      NODE_API_CALL(env, napi_get_value_double(env, args[0], &value));
+    }
+
+    MyObject* obj = new MyObject(value);
+
+    obj->env_ = env;
+    NODE_API_CALL(env,
+                  napi_wrap(env,
+                            _this,
+                            obj,
+                            MyObject::Destructor,
+                            nullptr /* finalize_hint */,
+                            &obj->wrapper_));
+
+    return _this;
+  }
+
+  // Invoked as plain function `MyObject(...)`, turn into construct call.
+  argc = 1;
+  napi_value argv[1] = {args[0]};
+
+  napi_value cons;
+  NODE_API_CALL(env, napi_get_reference_value(env, constructor, &cons));
+
+  napi_value instance;
+  NODE_API_CALL(env, napi_new_instance(env, cons, argc, argv, &instance));
+
+  return instance;
+}
+
+napi_value MyObject::GetValue(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
+
+  MyObject* obj;
+  NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
+
+  napi_value num;
+  NODE_API_CALL(env, napi_create_double(env, obj->value_, &num));
+
+  return num;
+}
+
+napi_value MyObject::SetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_value _this;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
+
+  MyObject* obj;
+  NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
+
+  NODE_API_CALL(env, napi_get_value_double(env, args[0], &obj->value_));
+
+  return nullptr;
+}
+
+napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
+
+  MyObject* obj;
+  NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
+
+  obj->value_ += 1;
+
+  napi_value num;
+  NODE_API_CALL(env, napi_create_double(env, obj->value_, &num));
+
+  return num;
+}
+
+napi_value MyObject::Multiply(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_value _this;
+  NODE_API_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
+
+  double multiple = 1;
+  if (argc >= 1) {
+    NODE_API_CALL(env, napi_get_value_double(env, args[0], &multiple));
+  }
+
+  MyObject* obj;
+  NODE_API_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
+
+  napi_value cons;
+  NODE_API_CALL(env, napi_get_reference_value(env, constructor, &cons));
+
+  const int kArgCount = 1;
+  napi_value argv[kArgCount];
+  NODE_API_CALL(env, napi_create_double(env, obj->value_ * multiple, argv));
+
+  napi_value instance;
+  NODE_API_CALL(env, napi_new_instance(env, cons, kArgCount, argv, &instance));
+
+  return instance;
+}
+
+// This finalizer should never be invoked.
+void ObjectWrapDanglingReferenceFinalizer(node_api_basic_env env,
+                                          void* finalize_data,
+                                          void* finalize_hint) {
+  assert(0 && "unreachable");
+}
+
+napi_ref dangling_ref;
+napi_value ObjectWrapDanglingReference(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  // Create a napi_wrap and remove it immediately, whilst leaving the out-param
+  // ref dangling (not deleted).
+  NODE_API_CALL(env,
+                napi_wrap(env,
+                          args[0],
+                          nullptr,
+                          ObjectWrapDanglingReferenceFinalizer,
+                          nullptr,
+                          &dangling_ref));
+  NODE_API_CALL(env, napi_remove_wrap(env, args[0], nullptr));
+
+  return args[0];
+}
+
+napi_value ObjectWrapDanglingReferenceTest(napi_env env,
+                                           napi_callback_info info) {
+  napi_value out;
+  napi_value ret;
+  NODE_API_CALL(env, napi_get_reference_value(env, dangling_ref, &out));
+
+  if (out == nullptr) {
+    // If the napi_ref has been invalidated, delete it.
+    NODE_API_CALL(env, napi_delete_reference(env, dangling_ref));
+    NODE_API_CALL(env, napi_get_boolean(env, true, &ret));
+  } else {
+    // The dangling napi_ref is still valid.
+    NODE_API_CALL(env, napi_get_boolean(env, false, &ret));
+  }
+  return ret;
+}
+
+static napi_value GetFinalizerCallCount(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  FinalizerData* data;
+  napi_value result;
+
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, &argc, argv, nullptr, nullptr));
+  NODE_API_CALL(env,
+                napi_get_instance_data(env, reinterpret_cast<void**>(&data)));
+  NODE_API_CALL(env, napi_create_int32(env, *data, &result));
+  return result;
+}
+
+static void finalizeData(napi_env env, void* data, void* hint) {
+  delete reinterpret_cast<FinalizerData*>(data);
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  FinalizerData* data = new FinalizerData;
+  *data = 0;
+  NODE_API_CALL(env, napi_set_instance_data(env, data, finalizeData, nullptr));
+
+  MyObject::Init(env, exports);
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NODE_API_PROPERTY("objectWrapDanglingReference",
+                                ObjectWrapDanglingReference),
+      DECLARE_NODE_API_PROPERTY("objectWrapDanglingReferenceTest",
+                                ObjectWrapDanglingReferenceTest),
+      DECLARE_NODE_API_PROPERTY("getFinalizerCallCount", GetFinalizerCallCount),
+  };
+
+  NODE_API_CALL(
+      env,
+      napi_define_properties(env,
+                             exports,
+                             sizeof(descriptors) / sizeof(*descriptors),
+                             descriptors));
+
+  return exports;
+}
+EXTERN_C_END

test/js-native-api/6_object_wrap/myobject.h

@@ -0,0 +1,28 @@
+#ifndef TEST_JS_NATIVE_API_6_OBJECT_WRAP_MYOBJECT_H_
+#define TEST_JS_NATIVE_API_6_OBJECT_WRAP_MYOBJECT_H_
+
+#include <js_native_api.h>
+
+class MyObject {
+ public:
+  static void Init(napi_env env, napi_value exports);
+  static void Destructor(node_api_basic_env env,
+                         void* nativeObject,
+                         void* finalize_hint);
+
+ private:
+  explicit MyObject(double value_ = 0);
+  ~MyObject();
+
+  static napi_value New(napi_env env, napi_callback_info info);
+  static napi_value GetValue(napi_env env, napi_callback_info info);
+  static napi_value SetValue(napi_env env, napi_callback_info info);
+  static napi_value PlusOne(napi_env env, napi_callback_info info);
+  static napi_value Multiply(napi_env env, napi_callback_info info);
+  static napi_ref constructor;
+  double value_;
+  napi_env env_;
+  napi_ref wrapper_;
+};
+
+#endif  // TEST_JS_NATIVE_API_6_OBJECT_WRAP_MYOBJECT_H_

test/js-native-api/6_object_wrap/nested_wrap.cc

@@ -0,0 +1,99 @@
+#include "nested_wrap.h"
+#include "../common.h"
+#include "../entry_point.h"
+
+napi_ref NestedWrap::constructor{};
+static int finalization_count = 0;
+
+NestedWrap::NestedWrap() {}
+
+NestedWrap::~NestedWrap() {
+  napi_delete_reference(env_, wrapper_);
+
+  // Delete the nested reference as well.
+  napi_delete_reference(env_, nested_);
+}
+
+void NestedWrap::Destructor(node_api_basic_env env,
+                            void* nativeObject,
+                            void* /*finalize_hint*/) {
+  // Once this destructor is called, it cancels all pending
+  // finalizers for the object by deleting the references.
+  NestedWrap* obj = static_cast<NestedWrap*>(nativeObject);
+  delete obj;
+
+  finalization_count++;
+}
+
+void NestedWrap::Init(napi_env env, napi_value exports) {
+  napi_value cons;
+  NODE_API_CALL_RETURN_VOID(
+      env,
+      napi_define_class(
+          env, "NestedWrap", -1, New, nullptr, 0, nullptr, &cons));
+
+  NODE_API_CALL_RETURN_VOID(env,
+                            napi_create_reference(env, cons, 1, &constructor));
+
+  NODE_API_CALL_RETURN_VOID(
+      env, napi_set_named_property(env, exports, "NestedWrap", cons));
+}
+
+napi_value NestedWrap::New(napi_env env, napi_callback_info info) {
+  napi_value new_target;
+  NODE_API_CALL(env, napi_get_new_target(env, info, &new_target));
+  bool is_constructor = (new_target != nullptr);
+  NODE_API_BASIC_ASSERT_BASE(
+      is_constructor, "Constructor called without new", nullptr);
+
+  napi_value this_val;
+  NODE_API_CALL(env,
+                napi_get_cb_info(env, info, 0, nullptr, &this_val, nullptr));
+
+  NestedWrap* obj = new NestedWrap();
+
+  obj->env_ = env;
+  NODE_API_CALL(env,
+                napi_wrap(env,
+                          this_val,
+                          obj,
+                          NestedWrap::Destructor,
+                          nullptr /* finalize_hint */,
+                          &obj->wrapper_));
+
+  // Create a second napi_ref to be deleted in the destructor.
+  NODE_API_CALL(env,
+                napi_add_finalizer(env,
+                                   this_val,
+                                   obj,
+                                   NestedWrap::Destructor,
+                                   nullptr /* finalize_hint */,
+                                   &obj->nested_));
+
+  return this_val;
+}
+
+static napi_value GetFinalizerCallCount(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NODE_API_CALL(env, napi_create_int32(env, finalization_count, &result));
+  return result;
+}
+
+EXTERN_C_START
+napi_value Init(napi_env env, napi_value exports) {
+  NestedWrap::Init(env, exports);
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NODE_API_PROPERTY("getFinalizerCallCount", GetFinalizerCallCount),
+  };
+
+  NODE_API_CALL(
+      env,
+      napi_define_properties(env,
+                             exports,
+                             sizeof(descriptors) / sizeof(*descriptors),
+                             descriptors));
+
+  return exports;
+}
+EXTERN_C_END

test/js-native-api/6_object_wrap/nested_wrap.h

@@ -0,0 +1,33 @@
+#ifndef TEST_JS_NATIVE_API_6_OBJECT_WRAP_NESTED_WRAP_H_
+#define TEST_JS_NATIVE_API_6_OBJECT_WRAP_NESTED_WRAP_H_
+
+#include <js_native_api.h>
+
+/**
+ * Test that an napi_ref can be nested inside another ObjectWrap.
+ *
+ * This test shows a critical case where a finalizer deletes an napi_ref
+ * whose finalizer is also scheduled.
+ */
+
+class NestedWrap {
+ public:
+  static void Init(napi_env env, napi_value exports);
+  static void Destructor(node_api_basic_env env,
+                         void* nativeObject,
+                         void* finalize_hint);
+
+ private:
+  explicit NestedWrap();
+  ~NestedWrap();
+
+  static napi_value New(napi_env env, napi_callback_info info);
+
+  static napi_ref constructor;
+
+  napi_env env_{};
+  napi_ref wrapper_{};
+  napi_ref nested_{};
+};
+
+#endif  // TEST_JS_NATIVE_API_6_OBJECT_WRAP_NESTED_WRAP_H_

test/js-native-api/6_object_wrap/nested_wrap.js

@@ -0,0 +1,20 @@
+// Flags: --expose-gc
+
+'use strict';
+const common = require('../../common');
+const { gcUntil } = require('../../common/gc');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/nested_wrap`);
+
+// This test verifies that ObjectWrap and napi_ref can be nested and finalized
+// correctly with a non-basic finalizer.
+(() => {
+  let obj = new addon.NestedWrap();
+  obj = null;
+  // Silent eslint about unused variables.
+  assert.strictEqual(obj, null);
+})();
+
+gcUntil('object-wrap-ref', () => {
+  return addon.getFinalizerCallCount() === 1;
+});

test/js-native-api/6_object_wrap/test-basic-finalizer.js

@@ -0,0 +1,24 @@
+// Flags: --expose-gc
+
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/myobject_basic_finalizer`);
+
+// This test verifies that ObjectWrap can be correctly finalized with a node_api_basic_finalizer
+// in the current JS loop tick
+(() => {
+  let obj = new addon.MyObject(9);
+  obj = null;
+  // Silent eslint about unused variables.
+  assert.strictEqual(obj, null);
+})();
+
+for (let i = 0; i < 10; ++i) {
+  global.gc();
+  if (addon.getFinalizerCallCount() === 1) {
+    break;
+  }
+}
+
+assert.strictEqual(addon.getFinalizerCallCount(), 1);

test/js-native-api/6_object_wrap/test-object-wrap-ref.js

@@ -0,0 +1,14 @@
+// Flags: --expose-gc
+
+'use strict';
+const common = require('../../common');
+const addon = require(`./build/${common.buildType}/myobject`);
+const { gcUntil } = require('../../common/gc');
+
+(function scope() {
+  addon.objectWrapDanglingReference({});
+})();
+
+gcUntil('object-wrap-ref', () => {
+  return addon.objectWrapDanglingReferenceTest();
+});

test/js-native-api/6_object_wrap/test.js

@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/myobject`);
+
+const getterOnlyErrorRE =
+  /^TypeError: Cannot set property .* of #<.*> which has only a getter$/;
+
+const valueDescriptor = Object.getOwnPropertyDescriptor(
+  addon.MyObject.prototype, 'value');
+const valueReadonlyDescriptor = Object.getOwnPropertyDescriptor(
+  addon.MyObject.prototype, 'valueReadonly');
+const plusOneDescriptor = Object.getOwnPropertyDescriptor(
+  addon.MyObject.prototype, 'plusOne');
+assert.strictEqual(typeof valueDescriptor.get, 'function');
+assert.strictEqual(typeof valueDescriptor.set, 'function');
+assert.strictEqual(valueDescriptor.value, undefined);
+assert.strictEqual(valueDescriptor.enumerable, false);
+assert.strictEqual(valueDescriptor.configurable, false);
+assert.strictEqual(typeof valueReadonlyDescriptor.get, 'function');
+assert.strictEqual(valueReadonlyDescriptor.set, undefined);
+assert.strictEqual(valueReadonlyDescriptor.value, undefined);
+assert.strictEqual(valueReadonlyDescriptor.enumerable, false);
+assert.strictEqual(valueReadonlyDescriptor.configurable, false);
+
+assert.strictEqual(plusOneDescriptor.get, undefined);
+assert.strictEqual(plusOneDescriptor.set, undefined);
+assert.strictEqual(typeof plusOneDescriptor.value, 'function');
+assert.strictEqual(plusOneDescriptor.enumerable, false);
+assert.strictEqual(plusOneDescriptor.configurable, false);
+
+const obj = new addon.MyObject(9);
+assert.strictEqual(obj.value, 9);
+obj.value = 10;
+assert.strictEqual(obj.value, 10);
+assert.strictEqual(obj.valueReadonly, 10);
+assert.throws(() => { obj.valueReadonly = 14; }, getterOnlyErrorRE);
+assert.strictEqual(obj.plusOne(), 11);
+assert.strictEqual(obj.plusOne(), 12);
+assert.strictEqual(obj.plusOne(), 13);
+
+assert.strictEqual(obj.multiply().value, 13);
+assert.strictEqual(obj.multiply(10).value, 130);
+
+const newobj = obj.multiply(-1);
+assert.strictEqual(newobj.value, -13);
+assert.strictEqual(newobj.valueReadonly, -13);
+assert.notStrictEqual(obj, newobj);