src: add Env::AddCleanupHook

napi-inl.h

@@ -334,6 +334,22 @@ struct AccessorCallbackData {
   void* data;
 };
 
+template <typename Hook, typename Hint = void>
+struct CleanupHookDetails {
+  static inline void Wrapper(void* data) NAPI_NOEXCEPT {
+    auto* cleanupData =
+        static_cast<typename Napi::CleanupHook<Hook, Hint>::CleanupData*>(data);
+    cleanupData->hook();
+    delete cleanupData;
+  }
+
+  static inline void WrapperWithHint(void* data) NAPI_NOEXCEPT {
+    auto* cleanupData =
+        static_cast<typename Napi::CleanupHook<Hook, Hint>::CleanupData*>(data);
+    cleanupData->hook(static_cast<Hint*>(cleanupData->hint));
+    delete cleanupData;
+  }
+};
 }  // namespace details
 
 #ifndef NODE_ADDON_API_DISABLE_DEPRECATED
@@ -5692,6 +5708,43 @@ Addon<T>::DefineProperties(Object object,
 }
 #endif  // NAPI_VERSION > 5
 
+template <typename Hook, typename Hint>
+CleanupHook<Hook, Hint> Env::AddCleanupHook(Hook hook, Hint* arg) {
+  return CleanupHook<Hook, Hint>(
+      *this,
+      details::CleanupHookDetails<Hook, Hint>::WrapperWithHint,
+      hook,
+      arg);
+}
+
+template <typename Hook>
+CleanupHook<Hook> Env::AddCleanupHook(Hook hook) {
+  return CleanupHook<Hook>(
+      *this, details::CleanupHookDetails<Hook>::Wrapper, hook, nullptr);
+}
+
+template <class Hook, class Hint>
+CleanupHook<Hook, Hint>::CleanupHook(Napi::Env env,
+                                     void (*wrapper)(void* arg),
+                                     Hook hook,
+                                     Hint* hint)
+    : wrapper(wrapper) {
+  data = new CleanupData{std::move(hook), hint};
+  napi_status status = napi_add_env_cleanup_hook(env, wrapper, data);
+  NAPI_FATAL_IF_FAILED(status,
+                       "CleanupHook<Hook, Hint>::CleanupHook",
+                       "napi_add_env_cleanup_hook");
+}
+
+template <class Hook, class Hint>
+void CleanupHook<Hook, Hint>::Remove(Env env) {
+  napi_status status = napi_remove_env_cleanup_hook(env, wrapper, data);
+  NAPI_FATAL_IF_FAILED(status,
+                       "CleanupHook<Hook, Hint>::Remove",
+                       "napi_remove_env_cleanup_hook");
+  delete data;
+}
+
 } // namespace Napi
 
 #endif // SRC_NAPI_INL_H_

napi.h

@@ -135,6 +135,8 @@ namespace Napi {
   class CallbackInfo;
   class TypedArray;
   template <typename T> class TypedArrayOf;
+  template <typename Hook, typename Hint = void>
+  class CleanupHook;
 
   using Int8Array =
       TypedArrayOf<int8_t>;  ///< Typed-array of signed 8-bit integers
@@ -201,6 +203,12 @@ namespace Napi {
     Value RunScript(const std::string& utf8script);
     Value RunScript(String script);
 
+    template <typename Hook>
+    CleanupHook<Hook> AddCleanupHook(Hook hook);
+
+    template <typename Hook, typename Hint>
+    CleanupHook<Hook, Hint> AddCleanupHook(Hook hook, Hint* hint);
+
 #if NAPI_VERSION > 5
     template <typename T> T* GetInstanceData();
 
@@ -221,6 +229,21 @@ namespace Napi {
     napi_env _env;
   };
 
+  template <typename Hook, typename Hint>
+  class CleanupHook {
+   public:
+    struct CleanupData {
+      Hook hook;
+      Hint* hint;
+    };
+    CleanupHook(Env env, void (*wrapper)(void* arg), Hook hook, Hint* hint);
+    void Remove(Env env);
+
+   private:
+    void (*wrapper)(void* arg);
+    CleanupData* data;
+  };
+
   /// A JavaScript value of unknown type.
   ///
   /// For type-specific operations, convert to one of the Value subclasses using a `To*` or `As()`

test/binding.cc

@@ -30,6 +30,7 @@ Object InitDate(Env env);
 #endif
 Object InitDataView(Env env);
 Object InitDataViewReadWrite(Env env);
+Object InitEnvCleanup(Env env);
 Object InitError(Env env);
 Object InitExternal(Env env);
 Object InitFunction(Env env);
@@ -103,6 +104,7 @@ Object Init(Env env, Object exports) {
   exports.Set("dataview", InitDataView(env));
   exports.Set("dataview_read_write", InitDataView(env));
   exports.Set("dataview_read_write", InitDataViewReadWrite(env));
+  exports.Set("env_cleanup", InitEnvCleanup(env));
   exports.Set("error", InitError(env));
   exports.Set("external", InitExternal(env));
   exports.Set("function", InitFunction(env));

test/binding.gyp

@@ -22,6 +22,7 @@
         'callbackscope.cc',
         'dataview/dataview.cc',
         'dataview/dataview_read_write.cc',
+        'env_cleanup.cc',
         'error.cc',
         'external.cc',
         'function.cc',

test/env_cleanup.cc

@@ -0,0 +1,64 @@
+#include <stdio.h>
+#include "napi.h"
+
+using namespace Napi;
+
+static void cleanup(void* arg) {
+  printf("static cleanup(%d)\n", *(int*)(arg));
+}
+static void cleanupInt(int* arg) {
+  printf("static cleanup(%d)\n", *(arg));
+}
+
+static void cleanupVoid() {
+  printf("static cleanup()\n");
+}
+
+static int secret1 = 42;
+static int secret2 = 43;
+
+Value AddHooks(const CallbackInfo& info) {
+  auto env = info.Env();
+
+  bool shouldRemove = info[0].As<Boolean>().Value();
+
+  // hook: void (*)(void *arg), hint: int
+  auto hook1 = env.AddCleanupHook(cleanup, &secret1);
+
+  // hook: void (*)(int *arg), hint: int
+  auto hook2 = env.AddCleanupHook(cleanupInt, &secret2);
+
+  // hook: void (*)(int *arg), hint: void
+  auto hook3 = env.AddCleanupHook(cleanupVoid);
+
+  // hook: lambda []void (int *arg)->void, hint: int
+  auto hook4 = env.AddCleanupHook(
+      [&](int* arg) { printf("lambda cleanup(%d)\n", *arg); }, &secret1);
+
+  // hook: lambda []void (void *)->void, hint: void
+  auto hook5 =
+      env.AddCleanupHook([&](void*) { printf("lambda cleanup(void)\n"); },
+                         static_cast<void*>(nullptr));
+
+  // hook: lambda []void ()->void, hint: void (default)
+  auto hook6 = env.AddCleanupHook([&]() { printf("lambda cleanup()\n"); });
+
+  if (shouldRemove) {
+    hook1.Remove(env);
+    hook2.Remove(env);
+    hook3.Remove(env);
+    hook4.Remove(env);
+    hook5.Remove(env);
+    hook6.Remove(env);
+  }
+
+  return env.Undefined();
+}
+
+Object InitEnvCleanup(Env env) {
+  Object exports = Object::New(env);
+
+  exports["addHooks"] = Function::New(env, AddHooks);
+
+  return exports;
+}

test/env_cleanup.js

@@ -0,0 +1,50 @@
+// @ts-check
+
+'use strict';
+
+const assert = require('assert');
+
+if (process.argv[2] === 'runInChildProcess') {
+    const binding_path = process.argv[3];
+    const remove_hooks = process.argv[4] === "true";
+
+    const binding = require(binding_path);
+    binding.env_cleanup.addHooks(remove_hooks);
+}
+else {
+    module.exports = require('./common').runTestWithBindingPath(test);
+}
+
+function test(bindingPath) {
+    for (const remove_hooks of [false, true]) {
+        const { status, output } = require('./napi_child').spawnSync(
+            process.execPath,
+            [
+                __filename,
+                'runInChildProcess',
+                bindingPath,
+                remove_hooks,
+            ],
+            { encoding: 'utf8' }
+        );
+
+        const stdout = output[1].trim();
+        const lines = stdout.split(/\n/).sort();
+
+        assert(status === 0, `Process aborted with status ${status}`);
+
+        if (remove_hooks) {
+            assert.deepStrictEqual(lines, [''], 'Child process had console output when none expected')
+        } else {
+            assert.deepStrictEqual(lines, [
+                "lambda cleanup()",
+                "lambda cleanup(42)",
+                "lambda cleanup(void)",
+                "static cleanup()",
+                "static cleanup(42)",
+                "static cleanup(43)",
+            ],  'Child process console output mismisatch')
+        }
+    }
+}
+