lib: use deferred queue for all internal ticks calls

Refs: nodejs#51267

Author: ronag

lib/_http_client.js

@@ -339,7 +339,7 @@ function ClientRequest(input, options, cb) {
     if (typeof optsWithoutSignal.createConnection === 'function') {
       const oncreate = once((err, socket) => {
         if (err) {
-          process.nextTick(() => this.emit('error', err));
+          process._deferTick(() => this.emit('error', err));
         } else {
           this.onSocket(socket);
         }
@@ -402,7 +402,7 @@ ClientRequest.prototype.abort = function abort() {
     return;
   }
   this.aborted = true;
-  process.nextTick(emitAbortNT, this);
+  process._deferTick(emitAbortNT, this);
   this.destroy();
 };
 
@@ -723,7 +723,7 @@ function responseKeepAlive(req) {
   const asyncId = socket._handle ? socket._handle.getAsyncId() : undefined;
   // Mark this socket as available, AFTER user-added end
   // handlers have a chance to run.
-  defaultTriggerAsyncIdScope(asyncId, process.nextTick, emitFreeNT, req);
+  defaultTriggerAsyncIdScope(asyncId, process._deferTick, emitFreeNT, req);
 
   req.destroyed = true;
   if (req.res) {
@@ -857,7 +857,7 @@ function listenSocketTimeout(req) {
 ClientRequest.prototype.onSocket = function onSocket(socket, err) {
   // TODO(ronag): Between here and onSocketNT the socket
   // has no 'error' handler.
-  process.nextTick(onSocketNT, this, socket, err);
+  process._deferTick(onSocketNT, this, socket, err);
 };
 
 function onSocketNT(req, socket, err) {

lib/_http_incoming.js

@@ -236,10 +236,10 @@ IncomingMessage.prototype._destroy = function _destroy(err, cb) {
         e = null;
       }
       cleanup();
-      process.nextTick(onError, this, e || err, cb);
+      process._deferTick(onError, this, e || err, cb);
     });
   } else {
-    process.nextTick(onError, this, err, cb);
+    process._deferTick(onError, this, err, cb);
   }
 };
 

lib/_http_outgoing.js

@@ -895,7 +895,7 @@ OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {
 function onError(msg, err, callback) {
   const triggerAsyncId = msg.socket ? msg.socket[async_id_symbol] : undefined;
   defaultTriggerAsyncIdScope(triggerAsyncId,
-                             process.nextTick,
+                             process._deferTick,
                              emitErrorNt,
                              msg,
                              err,
@@ -942,7 +942,7 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
     if (!msg.destroyed) {
       onError(msg, err, callback);
     } else {
-      process.nextTick(callback, err);
+      process._deferTick(callback, err);
     }
     return false;
   }
@@ -976,14 +976,14 @@ function write_(msg, chunk, encoding, callback, fromEnd) {
     } else {
       debug('This type of response MUST NOT have a body. ' +
         'Ignoring write() calls.');
-      process.nextTick(callback);
+      process._deferTick(callback);
       return true;
     }
   }
 
   if (!fromEnd && msg.socket && !msg.socket.writableCorked) {
     msg.socket.cork();
-    process.nextTick(connectionCorkNT, msg.socket);
+    process._deferTick(connectionCorkNT, msg.socket);
   }
 
   let ret;
@@ -1117,7 +1117,7 @@ OutgoingMessage.prototype.end = function end(chunk, encoding, callback) {
   } else if (!this._headerSent || this.writableLength || chunk) {
     this._send('', 'latin1', finish);
   } else {
-    process.nextTick(finish);
+    process._deferTick(finish);
   }
 
   if (this[kSocket]) {

lib/_http_server.js

@@ -988,7 +988,7 @@ function resOnFinish(req, res, socket, state, server) {
 
   res.detachSocket(socket);
   clearIncoming(req);
-  process.nextTick(emitCloseNT, res);
+  process._deferTick(emitCloseNT, res);
 
   if (res._last) {
     if (typeof socket.destroySoon === 'function') {

lib/_tls_wrap.js

@@ -609,7 +609,7 @@ function TLSSocket(socket, opts) {
   }
 
   // Read on next tick so the caller has a chance to setup listeners
-  process.nextTick(initRead, this, socket);
+  process._deferTick(initRead, this, socket);
 }
 ObjectSetPrototypeOf(TLSSocket.prototype, net.Socket.prototype);
 ObjectSetPrototypeOf(TLSSocket, net.Socket);
@@ -999,7 +999,7 @@ TLSSocket.prototype.renegotiate = function(options, callback) {
     this._handle.renegotiate();
   } catch (err) {
     if (callback) {
-      process.nextTick(callback, err);
+      process._deferTick(callback, err);
     }
     return false;
   }

lib/child_process.js

@@ -783,7 +783,7 @@ function spawn(file, args, options) {
   if (options.signal) {
     const signal = options.signal;
     if (signal.aborted) {
-      process.nextTick(onAbortListener);
+      process._deferTick(onAbortListener);
     } else {
       addAbortListener ??= require('events').addAbortListener;
       const disposable = addAbortListener(signal, onAbortListener);

lib/dgram.js

@@ -436,7 +436,7 @@ function doConnect(ex, self, ip, address, port, callback) {
 
   if (ex) {
     state.connectState = CONNECT_STATE_DISCONNECTED;
-    return process.nextTick(() => {
+    return process._deferTick(() => {
       if (callback) {
         self.removeListener('connect', callback);
         callback(ex);
@@ -447,7 +447,7 @@ function doConnect(ex, self, ip, address, port, callback) {
   }
 
   state.connectState = CONNECT_STATE_CONNECTED;
-  process.nextTick(() => self.emit('connect'));
+  process._deferTick(() => self.emit('connect'));
 }
 
 
@@ -680,11 +680,11 @@ function doSend(ex, self, ip, list, address, port, callback) {
 
   if (ex) {
     if (typeof callback === 'function') {
-      process.nextTick(callback, ex);
+      process._deferTick(callback, ex);
       return;
     }
 
-    process.nextTick(() => self.emit('error', ex));
+    process._deferTick(() => self.emit('error', ex));
     return;
   } else if (!state.handle) {
     return;
@@ -709,14 +709,14 @@ function doSend(ex, self, ip, list, address, port, callback) {
     // Synchronous finish. The return code is msg_length + 1 so that we can
     // distinguish between synchronous success and asynchronous success.
     if (callback)
-      process.nextTick(callback, null, err - 1);
+      process._deferTick(callback, null, err - 1);
     return;
   }
 
   if (err && callback) {
     // Don't emit as error, dgram_legacy.js compatibility
     const ex = new ExceptionWithHostPort(err, 'send', address, port);
-    process.nextTick(callback, ex);
+    process._deferTick(callback, ex);
   }
 }
 
@@ -747,7 +747,7 @@ Socket.prototype.close = function(callback) {
   state.handle.close();
   state.handle = null;
   defaultTriggerAsyncIdScope(this[async_id_symbol],
-                             process.nextTick,
+                             process._deferTick,
                              socketCloseNT,
                              this);
 

lib/diagnostics_channel.js

@@ -82,7 +82,7 @@ function wrapStoreRun(store, data, next, transform = defaultTransform) {
     try {
       context = transform(data);
     } catch (err) {
-      process.nextTick(() => {
+      process._deferTick(() => {
         triggerUncaughtException(err, false);
       });
       return next();
@@ -141,7 +141,7 @@ class ActiveChannel {
         const onMessage = this._subscribers[i];
         onMessage(data, this.name);
       } catch (err) {
-        process.nextTick(() => {
+        process._deferTick(() => {
           triggerUncaughtException(err, false);
         });
       }

lib/dns.js

@@ -194,20 +194,20 @@ function lookup(hostname, options, callback) {
   if (!hostname) {
     emitInvalidHostnameWarning(hostname);
     if (all) {
-      process.nextTick(callback, null, []);
+      process._deferTick(callback, null, []);
     } else {
-      process.nextTick(callback, null, null, family === 6 ? 6 : 4);
+      process._deferTick(callback, null, null, family === 6 ? 6 : 4);
     }
     return {};
   }
 
   const matchedFamily = isIP(hostname);
   if (matchedFamily) {
     if (all) {
-      process.nextTick(
+      process._deferTick(
         callback, null, [{ address: hostname, family: matchedFamily }]);
     } else {
-      process.nextTick(callback, null, hostname, matchedFamily);
+      process._deferTick(callback, null, hostname, matchedFamily);
     }
     return {};
   }
@@ -222,7 +222,7 @@ function lookup(hostname, options, callback) {
     req, hostname, family, hints, verbatim,
   );
   if (err) {
-    process.nextTick(callback, new DNSException(err, 'getaddrinfo', hostname));
+    process._deferTick(callback, new DNSException(err, 'getaddrinfo', hostname));
     return {};
   }
   if (hasObserver('dns')) {

lib/events.js

@@ -377,7 +377,7 @@ function addCatch(that, promise, type, args) {
       then.call(promise, undefined, function(err) {
         // The callback is called with nextTick to avoid a follow-up
         // rejection from this promise.
-        process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args);
+        process._deferTick(emitUnhandledRejectionOrErr, that, err, type, args);
       });
     }
   } catch (err) {