async_wrap: mode constructor/destructor to .cc

The constructor and destructor shouldn't have been placed in the -inl.h
file from the beginning.

PR-URL: https://github.com/nodejs/node/pull/10096
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>

src/async-wrap-inl.h

@@ -15,77 +15,6 @@
 
 namespace node {
 
-inline AsyncWrap::AsyncWrap(Environment* env,
-                            v8::Local<v8::Object> object,
-                            ProviderType provider,
-                            AsyncWrap* parent)
-    : BaseObject(env, object), bits_(static_cast<uint32_t>(provider) << 1),
-      uid_(env->get_async_wrap_uid()) {
-  CHECK_NE(provider, PROVIDER_NONE);
-  CHECK_GE(object->InternalFieldCount(), 1);
-
-  // Shift provider value over to prevent id collision.
-  persistent().SetWrapperClassId(NODE_ASYNC_ID_OFFSET + provider);
-
-  v8::Local<v8::Function> init_fn = env->async_hooks_init_function();
-
-  // No init callback exists, no reason to go on.
-  if (init_fn.IsEmpty())
-    return;
-
-  // If async wrap callbacks are disabled and no parent was passed that has
-  // run the init callback then return.
-  if (!env->async_wrap_callbacks_enabled() &&
-      (parent == nullptr || !parent->ran_init_callback()))
-    return;
-
-  v8::HandleScope scope(env->isolate());
-
-  v8::Local<v8::Value> argv[] = {
-    v8::Number::New(env->isolate(), get_uid()),
-    v8::Int32::New(env->isolate(), provider),
-    Null(env->isolate()),
-    Null(env->isolate())
-  };
-
-  if (parent != nullptr) {
-    argv[2] = v8::Number::New(env->isolate(), parent->get_uid());
-    argv[3] = parent->object();
-  }
-
-  v8::TryCatch try_catch(env->isolate());
-
-  v8::MaybeLocal<v8::Value> ret =
-      init_fn->Call(env->context(), object, arraysize(argv), argv);
-
-  if (ret.IsEmpty()) {
-    ClearFatalExceptionHandlers(env);
-    FatalException(env->isolate(), try_catch);
-  }
-
-  bits_ |= 1;  // ran_init_callback() is true now.
-}
-
-
-inline AsyncWrap::~AsyncWrap() {
-  if (!ran_init_callback())
-    return;
-
-  v8::Local<v8::Function> fn = env()->async_hooks_destroy_function();
-  if (!fn.IsEmpty()) {
-    v8::HandleScope scope(env()->isolate());
-    v8::Local<v8::Value> uid = v8::Number::New(env()->isolate(), get_uid());
-    v8::TryCatch try_catch(env()->isolate());
-    v8::MaybeLocal<v8::Value> ret =
-        fn->Call(env()->context(), v8::Null(env()->isolate()), 1, &uid);
-    if (ret.IsEmpty()) {
-      ClearFatalExceptionHandlers(env());
-      FatalException(env()->isolate(), try_catch);
-    }
-  }
-}
-
-
 inline bool AsyncWrap::ran_init_callback() const {
   return static_cast<bool>(bits_ & 1);
 }

src/async-wrap.cc

@@ -191,6 +191,77 @@ void LoadAsyncWrapperInfo(Environment* env) {
 }
 
 
+AsyncWrap::AsyncWrap(Environment* env,
+                     Local<Object> object,
+                     ProviderType provider,
+                     AsyncWrap* parent)
+    : BaseObject(env,object), bits_(static_cast<uint32_t>(provider) << 1),
+      uid_(env->get_async_wrap_uid()) {
+  CHECK_NE(provider, PROVIDER_NONE);
+  CHECK_GE(object->InternalFieldCount(), 1);
+
+  // Shift provider value over to prevent id collision.
+  persistent().SetWrapperClassId(NODE_ASYNC_ID_OFFSET + provider);
+
+  Local<Function> init_fn = env->async_hooks_init_function();
+
+  // No init callback exists, no reason to go on.
+  if (init_fn.IsEmpty())
+    return;
+
+  // If async wrap callbacks are disabled and no parent was passed that has
+  // run the init callback then return.
+  if (!env->async_wrap_callbacks_enabled() &&
+      (parent == nullptr || !parent->ran_init_callback()))
+    return;
+
+  HandleScope scope(env->isolate());
+
+  Local<Value> argv[] = {
+    Number::New(env->isolate(), get_uid()),
+    Int32::New(env->isolate(), provider),
+    Null(env->isolate()),
+    Null(env->isolate())
+  };
+
+  if (parent != nullptr) {
+    argv[2] = Number::New(env->isolate(), parent->get_uid());
+    argv[3] = parent->object();
+  }
+
+  TryCatch try_catch(env->isolate());
+
+  MaybeLocal<Value> ret =
+      init_fn->Call(env->context(), object, arraysize(argv), argv);
+
+  if (ret.IsEmpty()) {
+    ClearFatalExceptionHandlers(env);
+    FatalException(env->isolate(), try_catch);
+  }
+
+  bits_ |= 1;  // ran_init_callback() is true now.
+}
+
+
+AsyncWrap::~AsyncWrap() {
+  if (!ran_init_callback())
+    return;
+
+  Local<Function> fn = env()->async_hooks_destroy_function();
+  if (!fn.IsEmpty()) {
+    HandleScope scope(env()->isolate());
+    Local<Value> uid = Number::New(env()->isolate(), get_uid());
+    TryCatch try_catch(env()->isolate());
+    MaybeLocal<Value> ret =
+        fn->Call(env()->context(), Null(env()->isolate()), 1, &uid);
+    if (ret.IsEmpty()) {
+      ClearFatalExceptionHandlers(env());
+      FatalException(env()->isolate(), try_catch);
+    }
+  }
+}
+
+
 Local<Value> AsyncWrap::MakeCallback(const Local<Function> cb,
                                      int argc,
                                      Local<Value>* argv) {

src/async-wrap.h

@@ -49,12 +49,12 @@ class AsyncWrap : public BaseObject {
 #undef V
   };
 
-  inline AsyncWrap(Environment* env,
+  AsyncWrap(Environment* env,
-                   v8::Local<v8::Object> object,
+            v8::Local<v8::Object> object,
-                   ProviderType provider,
+            ProviderType provider,
-                   AsyncWrap* parent = nullptr);
+            AsyncWrap* parent = nullptr);
 
-  inline virtual ~AsyncWrap();
+  virtual ~AsyncWrap();
 
   inline ProviderType provider_type() const;