async_wrap: use kTotals to enable PromiseHook

Keep a total of enabled hook callbacks in kTotals. This value is used to
track whether node::PromiseHook (src/async-wrap.cc) should be enabled or
disabled.

Don't enable node::PromiseHook, using enablePromiseHook(), until a hook
has been added. Then, using disablePromiseHook(), disable
node::PromiseHook when all hooks have been disabled.

Need to use a native test in order to check the internal field of the
Promise and check for a PromiseWrap.

PR-URL: https://github.com/nodejs/node/pull/13509
Reviewed-By: Andreas Madsen <amwebdk@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>

3 files changed, 95 insertions, 0 deletions

diff --git a/test/addons/async-hooks-promise/binding.cc b/test/addons/async-hooks-promise/binding.cc
new file mode 100644
index 0000000000..fb91b936e6
--- /dev/null
+++ b/test/addons/async-hooks-promise/binding.cc
@@ -0,0 +1,43 @@
+#include <node.h>
+#include <v8.h>
+
+namespace {
+
+using v8::FunctionCallbackInfo;
+using v8::Isolate;
+using v8::Local;
+using v8::NewStringType;
+using v8::Object;
+using v8::Promise;
+using v8::String;
+using v8::Value;
+
+static void ThrowError(Isolate* isolate, const char* err_msg) {
+  Local<String> str = String::NewFromOneByte(
+      isolate,
+      reinterpret_cast<const uint8_t*>(err_msg),
+      NewStringType::kNormal).ToLocalChecked();
+  isolate->ThrowException(str);
+}
+
+static void GetPromiseField(const FunctionCallbackInfo<Value>& args) {
+  auto isolate = args.GetIsolate();
+
+  if (!args[0]->IsPromise())
+    return ThrowError(isolate, "arg is not an Promise");
+
+  auto p = args[0].As<Promise>();
+  if (p->InternalFieldCount() < 1)
+    return ThrowError(isolate, "Promise has no internal field");
+
+  auto l = p->GetInternalField(0);
+  args.GetReturnValue().Set(l);
+}
+
+inline void Initialize(v8::Local<v8::Object> binding) {
+  NODE_SET_METHOD(binding, "getPromiseField", GetPromiseField);
+}
+
+NODE_MODULE(binding, Initialize)
+
+}  // anonymous namespace
diff --git a/test/addons/async-hooks-promise/binding.gyp b/test/addons/async-hooks-promise/binding.gyp
new file mode 100644
index 0000000000..7ede63d94a
--- /dev/null
+++ b/test/addons/async-hooks-promise/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/test/addons/async-hooks-promise/test.js b/test/addons/async-hooks-promise/test.js
new file mode 100644
index 0000000000..bbe11dd3c5
--- /dev/null
+++ b/test/addons/async-hooks-promise/test.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const async_hooks = require('async_hooks');
+const binding = require(`./build/${common.buildType}/binding`);
+
+// Baseline to make sure the internal field isn't being set.
+assert.strictEqual(
+  binding.getPromiseField(Promise.resolve(1)),
+  0,
+  'Promise internal field used despite missing enabled AsyncHook');
+
+const hook0 = async_hooks.createHook({}).enable();
+
+// Check that no PromiseWrap is created when there are no hook callbacks.
+assert.strictEqual(
+  binding.getPromiseField(Promise.resolve(1)),
+  0,
+  'Promise internal field used despite missing enabled AsyncHook');
+
+hook0.disable();
+
+let pwrap = null;
+const hook1 = async_hooks.createHook({
+  init(id, type, tid, resource) {
+    pwrap = resource;
+  }
+}).enable();
+
+// Check that the internal field returns the same PromiseWrap passed to init().
+assert.strictEqual(
+  binding.getPromiseField(Promise.resolve(1)),
+  pwrap,
+  'Unexpected PromiseWrap');
+
+hook1.disable();
+
+// Check that internal fields are no longer being set.
+assert.strictEqual(
+  binding.getPromiseField(Promise.resolve(1)),
+  0,
+  'Promise internal field used despite missing enabled AsyncHook');