async_hooks: C++ Embedder API overhaul

* Fix AsyncHooksGetTriggerAsyncId such it corresponds to
async_hooks.triggerAsyncId and not async_hooks.initTriggerId.
* Use an async_context struct instead of two async_uid values.
  This change was necessary since the fixing
  AsyncHooksGetTriggerAsyncId otherwise makes it impossible to
  get the correct default trigger id. It also prevents an invalid
  triggerAsyncId in MakeCallback.
* Rename async_uid to async_id for consistency
* Rename get_uid to get_async_id
* Add get_trigger_async_id to AsyncResource class

PR-URL: #14040
Backport-PR-URL: #14109
Reviewed-By: Refael Ackermann <[email protected]>
Reviewed-By: Andreas Madsen <[email protected]>
Reviewed-By: James M Snell <[email protected]>

Author: AndreasMadsen

src/async-wrap.cc

@@ -634,9 +634,10 @@ void AsyncWrap::AsyncReset(bool silent) {
 
   if (silent) return;
 
-  EmitAsyncInit(env(), object(),
-                env()->async_hooks()->provider_string(provider_type()),
-                async_id_, trigger_id_);
+  AsyncWrap::EmitAsyncInit(
+      env(), object(),
+      env()->async_hooks()->provider_string(provider_type()),
+      async_id_, trigger_id_);
 }
 
 
@@ -741,42 +742,106 @@ Local<Value> AsyncWrap::MakeCallback(const Local<Function> cb,
 /* Public C++ embedder API */
 
 
-async_uid AsyncHooksGetExecutionAsyncId(Isolate* isolate) {
+async_id AsyncHooksGetExecutionAsyncId(Isolate* isolate) {
   return Environment::GetCurrent(isolate)->current_async_id();
 }
 
-async_uid AsyncHooksGetCurrentId(Isolate* isolate) {
+async_id AsyncHooksGetCurrentId(Isolate* isolate) {
   return AsyncHooksGetExecutionAsyncId(isolate);
 }
 
 
-async_uid AsyncHooksGetTriggerAsyncId(Isolate* isolate) {
-  return Environment::GetCurrent(isolate)->get_init_trigger_id();
+async_id AsyncHooksGetTriggerAsyncId(Isolate* isolate) {
+  return Environment::GetCurrent(isolate)->trigger_id();
 }
 
-async_uid AsyncHooksGetTriggerId(Isolate* isolate) {
+async_id AsyncHooksGetTriggerId(Isolate* isolate) {
   return AsyncHooksGetTriggerAsyncId(isolate);
 }
 
 
-async_uid EmitAsyncInit(Isolate* isolate,
-                     Local<Object> resource,
-                     const char* name,
-                     async_uid trigger_id) {
+async_context EmitAsyncInit(Isolate* isolate,
+                            Local<Object> resource,
+                            const char* name,
+                            async_id trigger_async_id) {
   Environment* env = Environment::GetCurrent(isolate);
-  async_uid async_id = env->new_async_id();
 
+  // Initialize async context struct
+  if (trigger_async_id == -1)
+    trigger_async_id = env->get_init_trigger_id();
+
+  async_context context = {
+    env->new_async_id(),  // async_id_
+    trigger_async_id  // trigger_async_id_
+  };
+
+  // Run init hooks
   Local<String> type =
       String::NewFromUtf8(isolate, name, v8::NewStringType::kInternalized)
           .ToLocalChecked();
-  AsyncWrap::EmitAsyncInit(env, resource, type, async_id, trigger_id);
-  return async_id;
+  AsyncWrap::EmitAsyncInit(env, resource, type, context.async_id,
+                           context.trigger_async_id);
+
+  return context;
 }
 
-void EmitAsyncDestroy(Isolate* isolate, async_uid id) {
-  PushBackDestroyId(Environment::GetCurrent(isolate), id);
+void EmitAsyncDestroy(Isolate* isolate, async_context asyncContext) {
+  PushBackDestroyId(Environment::GetCurrent(isolate), asyncContext.async_id);
 }
 
 }  // namespace node
 
 NODE_MODULE_CONTEXT_AWARE_BUILTIN(async_wrap, node::AsyncWrap::Initialize)
+
+
+// Only legacy public API below this line.
+
+namespace node {
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+                               Local<Object> recv,
+                               Local<Function> callback,
+                               int argc,
+                               Local<Value>* argv,
+                               async_id asyncId,
+                               async_id triggerAsyncId) {
+  return MakeCallback(isolate, recv, callback, argc, argv,
+                      {asyncId, triggerAsyncId});
+}
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+                               Local<Object> recv,
+                               const char* method,
+                               int argc,
+                               Local<Value>* argv,
+                               async_id asyncId,
+                               async_id triggerAsyncId) {
+  return MakeCallback(isolate, recv, method, argc, argv,
+                      {asyncId, triggerAsyncId});
+}
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+                               Local<Object> recv,
+                               Local<String> symbol,
+                               int argc,
+                               Local<Value>* argv,
+                               async_id asyncId,
+                               async_id triggerAsyncId) {
+  return MakeCallback(isolate, recv, symbol, argc, argv,
+                      {asyncId, triggerAsyncId});
+}
+
+// Undo the Node-8.x-only alias from node.h
+#undef EmitAsyncInit
+
+async_uid EmitAsyncInit(Isolate* isolate,
+                        Local<Object> resource,
+                        const char* name,
+                        async_id trigger_async_id) {
+  return EmitAsyncInit__New(isolate,
+                            resource,
+                            name,
+                            trigger_async_id).async_id;
+}
+
+}  // namespace node

src/async-wrap.h

@@ -26,6 +26,7 @@
 
 #include "base-object.h"
 #include "v8.h"
+#include "node.h"
 
 #include <stdint.h>
 

src/inspector_agent.cc

@@ -604,7 +604,7 @@ bool Agent::StartIoThread(bool wait_for_connect) {
     message
   };
   MakeCallback(parent_env_->isolate(), process_object, emit_fn.As<Function>(),
-               arraysize(argv), argv, 0, 0);
+               arraysize(argv), argv, {0, 0});
 
   return true;
 }

src/node.cc

@@ -363,7 +363,7 @@ static void CheckImmediate(uv_check_t* handle) {
                env->immediate_callback_string(),
                0,
                nullptr,
-               0, 0).ToLocalChecked();
+               {0, 0}).ToLocalChecked();
 }
 
 
@@ -1298,8 +1298,7 @@ MaybeLocal<Value> MakeCallback(Environment* env,
                                const Local<Function> callback,
                                int argc,
                                Local<Value> argv[],
-                               double async_id,
-                               double trigger_id) {
+                               async_context asyncContext) {
   // If you hit this assertion, you forgot to enter the v8::Context first.
   CHECK_EQ(env->context(), env->isolate()->GetCurrentContext());
 
@@ -1321,10 +1320,12 @@ MaybeLocal<Value> MakeCallback(Environment* env,
   MaybeLocal<Value> ret;
 
   {
-    AsyncHooks::ExecScope exec_scope(env, async_id, trigger_id);
+    AsyncHooks::ExecScope exec_scope(env, asyncContext.async_id,
+                                     asyncContext.trigger_async_id);
 
-    if (async_id != 0) {
-      if (!AsyncWrap::EmitBefore(env, async_id)) return Local<Value>();
+    if (asyncContext.async_id != 0) {
+      if (!AsyncWrap::EmitBefore(env, asyncContext.async_id))
+        return Local<Value>();
     }
 
     ret = callback->Call(env->context(), recv, argc, argv);
@@ -1336,8 +1337,9 @@ MaybeLocal<Value> MakeCallback(Environment* env,
           ret : Undefined(env->isolate());
     }
 
-    if (async_id != 0) {
-      if (!AsyncWrap::EmitAfter(env, async_id)) return Local<Value>();
+    if (asyncContext.async_id != 0) {
+      if (!AsyncWrap::EmitAfter(env, asyncContext.async_id))
+        return Local<Value>();
     }
   }
 
@@ -1358,8 +1360,8 @@ MaybeLocal<Value> MakeCallback(Environment* env,
 
   // Make sure the stack unwound properly. If there are nested MakeCallback's
   // then it should return early and not reach this code.
-  CHECK_EQ(env->current_async_id(), async_id);
-  CHECK_EQ(env->trigger_id(), trigger_id);
+  CHECK_EQ(env->current_async_id(), asyncContext.async_id);
+  CHECK_EQ(env->trigger_id(), asyncContext.trigger_async_id);
 
   Local<Object> process = env->process_object();
 
@@ -1384,13 +1386,11 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
                                const char* method,
                                int argc,
                                Local<Value> argv[],
-                               async_uid async_id,
-                               async_uid trigger_id) {
+                               async_context asyncContext) {
   Local<String> method_string =
       String::NewFromUtf8(isolate, method, v8::NewStringType::kNormal)
           .ToLocalChecked();
-  return MakeCallback(isolate, recv, method_string, argc, argv,
-                      async_id, trigger_id);
+  return MakeCallback(isolate, recv, method_string, argc, argv, asyncContext);
 }
 
 
@@ -1399,14 +1399,12 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
                                Local<String> symbol,
                                int argc,
                                Local<Value> argv[],
-                               async_uid async_id,
-                               async_uid trigger_id) {
+                               async_context asyncContext) {
   Local<Value> callback_v = recv->Get(symbol);
   if (callback_v.IsEmpty()) return Local<Value>();
   if (!callback_v->IsFunction()) return Local<Value>();
   Local<Function> callback = callback_v.As<Function>();
-  return MakeCallback(isolate, recv, callback, argc, argv,
-                      async_id, trigger_id);
+  return MakeCallback(isolate, recv, callback, argc, argv, asyncContext);
 }
 
 
@@ -1415,8 +1413,7 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
                                Local<Function> callback,
                                int argc,
                                Local<Value> argv[],
-                               async_uid async_id,
-                               async_uid trigger_id) {
+                               async_context asyncContext) {
   // Observe the following two subtleties:
   //
   // 1. The environment is retrieved from the callback function's context.
@@ -1427,7 +1424,7 @@ MaybeLocal<Value> MakeCallback(Isolate* isolate,
   Environment* env = Environment::GetCurrent(callback->CreationContext());
   Context::Scope context_scope(env->context());
   return MakeCallback(env, recv.As<Value>(), callback, argc, argv,
-                      async_id, trigger_id);
+                      asyncContext);
 }
 
 
@@ -1440,7 +1437,7 @@ Local<Value> MakeCallback(Isolate* isolate,
                           Local<Value>* argv) {
   EscapableHandleScope handle_scope(isolate);
   return handle_scope.Escape(
-      MakeCallback(isolate, recv, method, argc, argv, 0, 0)
+      MakeCallback(isolate, recv, method, argc, argv, {0, 0})
           .FromMaybe(Local<Value>()));
 }
 
@@ -1452,7 +1449,7 @@ Local<Value> MakeCallback(Isolate* isolate,
     Local<Value>* argv) {
   EscapableHandleScope handle_scope(isolate);
   return handle_scope.Escape(
-      MakeCallback(isolate, recv, symbol, argc, argv, 0, 0)
+      MakeCallback(isolate, recv, symbol, argc, argv, {0, 0})
           .FromMaybe(Local<Value>()));
 }
 
@@ -1464,7 +1461,7 @@ Local<Value> MakeCallback(Isolate* isolate,
     Local<Value>* argv) {
   EscapableHandleScope handle_scope(isolate);
   return handle_scope.Escape(
-      MakeCallback(isolate, recv, callback, argc, argv, 0, 0)
+      MakeCallback(isolate, recv, callback, argc, argv, {0, 0})
           .FromMaybe(Local<Value>()));
 }
 
@@ -4448,7 +4445,7 @@ void EmitBeforeExit(Environment* env) {
   };
   MakeCallback(env->isolate(),
                process_object, "emit", arraysize(args), args,
-               0, 0).ToLocalChecked();
+               {0, 0}).ToLocalChecked();
 }
 
 
@@ -4469,7 +4466,7 @@ int EmitExit(Environment* env) {
 
   MakeCallback(env->isolate(),
                process_object, "emit", arraysize(args), args,
-               0, 0).ToLocalChecked();
+               {0, 0}).ToLocalChecked();
 
   // Reload exit code, it may be changed by `emit('exit')`
   return process_object->Get(exitCode)->Int32Value();