lib: refactor to use validateCallback

lib/_tls_wrap.js

@@ -67,7 +67,6 @@ const { connResetException, codes } = require('internal/errors');
 const {
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
-  ERR_INVALID_CALLBACK,
   ERR_MULTIPLE_CALLBACK,
   ERR_SOCKET_CLOSED,
   ERR_TLS_DH_PARAM_SIZE,
@@ -85,6 +84,7 @@ const {
   getAllowUnauthorized,
 } = require('internal/options');
 const {
+  validateCallback,
   validateString,
   validateBuffer,
   validateUint32
@@ -825,8 +825,9 @@ TLSSocket.prototype._init = function(socket, wrap) {
 TLSSocket.prototype.renegotiate = function(options, callback) {
   if (options === null || typeof options !== 'object')
     throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
-  if (callback !== undefined && typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  if (callback !== undefined) {
+    validateCallback(callback);
+  }
 
   debug('%s renegotiate()',
         this._tlsOptions.isServer ? 'server' : 'client',

lib/dns.js

@@ -45,10 +45,10 @@ const {
 const {
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_ARG_VALUE,
-  ERR_INVALID_CALLBACK,
   ERR_MISSING_ARGS,
 } = errors.codes;
 const {
+  validateCallback,
   validatePort,
   validateString,
   validateOneOf,
@@ -101,20 +101,24 @@ function lookup(hostname, options, callback) {
   // Parse arguments
   if (hostname && typeof hostname !== 'string') {
     throw new ERR_INVALID_ARG_TYPE('hostname', 'string', hostname);
-  } else if (typeof options === 'function') {
+  }
+
+  if (typeof options === 'function') {
     callback = options;
     family = 0;
-  } else if (typeof callback !== 'function') {
-    throw new ERR_INVALID_CALLBACK(callback);
-  } else if (options !== null && typeof options === 'object') {
-    hints = options.hints >>> 0;
-    family = options.family >>> 0;
-    all = options.all === true;
-    verbatim = options.verbatim === true;
-
-    validateHints(hints);
   } else {
-    family = options >>> 0;
+    validateCallback(callback);
+
+    if (options !== null && typeof options === 'object') {
+      hints = options.hints >>> 0;
+      family = options.family >>> 0;
+      all = options.all === true;
+      verbatim = options.verbatim === true;
+
+      validateHints(hints);
+    } else {
+      family = options >>> 0;
+    }
   }
 
   validateOneOf(family, 'family', [0, 4, 6]);
@@ -177,8 +181,7 @@ function lookupService(address, port, callback) {
 
   validatePort(port);
 
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
 
   port = +port;
 
@@ -217,9 +220,7 @@ function resolver(bindingName) {
     }
 
     validateString(name, 'name');
-    if (typeof callback !== 'function') {
-      throw new ERR_INVALID_CALLBACK(callback);
-    }
+    validateCallback(callback);
 
     const req = new QueryReqWrap();
     req.bindingName = bindingName;

lib/fs.js

@@ -75,7 +75,6 @@ const {
     ERR_FS_FILE_TOO_LARGE,
     ERR_INVALID_ARG_VALUE,
     ERR_INVALID_ARG_TYPE,
-    ERR_INVALID_CALLBACK,
     ERR_FEATURE_UNAVAILABLE_ON_PLATFORM
   },
   hideStackFrames,
@@ -125,6 +124,7 @@ const {
   isUint32,
   parseFileMode,
   validateBuffer,
+  validateCallback,
   validateInteger,
   validateInt32
 } = require('internal/validators');
@@ -170,19 +170,16 @@ function showTruncateDeprecation() {
 }
 
 function maybeCallback(cb) {
-  if (typeof cb === 'function')
-    return cb;
+  validateCallback(cb);
 
-  throw new ERR_INVALID_CALLBACK(cb);
+  return cb;
 }
 
 // Ensure that callbacks run in the global context. Only use this function
 // for callbacks that are passed to the binding layer, callbacks that are
 // invoked from JS already run in the proper scope.
 function makeCallback(cb) {
-  if (typeof cb !== 'function') {
-    throw new ERR_INVALID_CALLBACK(cb);
-  }
+  validateCallback(cb);
 
   return (...args) => cb(...args);
 }
@@ -191,9 +188,7 @@ function makeCallback(cb) {
 // an optimization, since the data passed back to the callback needs to be
 // transformed anyway.
 function makeStatsCallback(cb) {
-  if (typeof cb !== 'function') {
-    throw new ERR_INVALID_CALLBACK(cb);
-  }
+  validateCallback(cb);
 
   return (err, stats) => {
     if (err) return cb(err);
@@ -2014,8 +2009,8 @@ function copyFile(src, dest, mode, callback) {
   if (typeof mode === 'function') {
     callback = mode;
     mode = 0;
-  } else if (typeof callback !== 'function') {
-    throw new ERR_INVALID_CALLBACK(callback);
+  } else {
+    validateCallback(callback);
   }
 
   src = getValidatedPath(src, 'src');

lib/inspector.js

@@ -17,7 +17,6 @@ const {
   ERR_INSPECTOR_NOT_ACTIVE,
   ERR_INSPECTOR_NOT_WORKER,
   ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_CALLBACK
 } = require('internal/errors').codes;
 
 const { hasInspector } = internalBinding('config');
@@ -26,7 +25,10 @@ if (!hasInspector)
 
 const EventEmitter = require('events');
 const { queueMicrotask } = require('internal/process/task_queues');
-const { validateString } = require('internal/validators');
+const {
+  validateCallback,
+  validateString,
+} = require('internal/validators');
 const { isMainThread } = require('worker_threads');
 
 const {
@@ -100,8 +102,8 @@ class Session extends EventEmitter {
     if (params && typeof params !== 'object') {
       throw new ERR_INVALID_ARG_TYPE('params', 'Object', params);
     }
-    if (callback && typeof callback !== 'function') {
-      throw new ERR_INVALID_CALLBACK(callback);
+    if (callback) {
+      validateCallback(callback);
     }
 
     if (!this[connectionSymbol]) {

lib/internal/crypto/diffiehellman.js

@@ -31,11 +31,11 @@ const {
     ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE,
     ERR_INVALID_ARG_TYPE,
     ERR_INVALID_ARG_VALUE,
-    ERR_INVALID_CALLBACK,
   }
 } = require('internal/errors');
 
 const {
+  validateCallback,
   validateInt32,
   validateObject,
   validateString,
@@ -325,8 +325,7 @@ function deriveBitsECDH(name, publicKey, privateKey, callback) {
   validateString(name, 'name');
   validateObject(publicKey, 'publicKey');
   validateObject(privateKey, 'privateKey');
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
   const job = new ECDHBitsJob(kCryptoJobAsync, name, publicKey, privateKey);
   job.ondone = (error, bits) => {
     if (error) return FunctionPrototypeCall(callback, job, error);
@@ -340,8 +339,7 @@ function deriveBitsECDH(name, publicKey, privateKey, callback) {
 function deriveBitsDH(publicKey, privateKey, callback) {
   validateObject(publicKey, 'publicKey');
   validateObject(privateKey, 'privateKey');
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
   const job = new DHBitsJob(kCryptoJobAsync, publicKey, privateKey);
   job.ondone = (error, bits) => {
     if (error) return FunctionPrototypeCall(callback, job, error);

lib/internal/crypto/hkdf.js

@@ -13,6 +13,7 @@ const {
 } = internalBinding('crypto');
 
 const {
+  validateCallback,
   validateInteger,
   validateString,
   validateUint32,
@@ -41,7 +42,6 @@ const {
 
 const {
   codes: {
-    ERR_INVALID_CALLBACK,
     ERR_INVALID_ARG_TYPE,
     ERR_OUT_OF_RANGE,
     ERR_MISSING_OPTION,
@@ -112,8 +112,7 @@ function hkdf(hash, key, salt, info, length, callback) {
     length,
   } = validateParameters(hash, key, salt, info, length));
 
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
 
   const job = new HKDFJob(kCryptoJobAsync, hash, key, salt, info, length);
 

lib/internal/crypto/keygen.js

@@ -40,6 +40,7 @@ const { customPromisifyArgs } = require('internal/util');
 
 const {
   isUint32,
+  validateCallback,
   validateString,
   validateInteger,
   validateObject,
@@ -50,7 +51,6 @@ const {
   codes: {
     ERR_INCOMPATIBLE_OPTION_PAIR,
     ERR_INVALID_ARG_VALUE,
-    ERR_INVALID_CALLBACK,
     ERR_MISSING_OPTION,
   }
 } = require('internal/errors');
@@ -68,8 +68,7 @@ function generateKeyPair(type, options, callback) {
     callback = options;
     options = undefined;
   }
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
 
   const job = createJob(kCryptoJobAsync, type, options);
 
@@ -353,8 +352,7 @@ function generateKey(type, options, callback) {
     options = undefined;
   }
 
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
 
   const job = generateKeyJob(kCryptoJobAsync, type, options);
 

lib/internal/crypto/pbkdf2.js

@@ -14,13 +14,13 @@ const {
 } = internalBinding('crypto');
 
 const {
+  validateCallback,
   validateInteger,
   validateUint32,
 } = require('internal/validators');
 
 const {
   ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_CALLBACK,
   ERR_MISSING_OPTION,
 } = require('internal/errors').codes;
 
@@ -41,8 +41,7 @@ function pbkdf2(password, salt, iterations, keylen, digest, callback) {
   ({ password, salt, iterations, keylen, digest } =
     check(password, salt, iterations, keylen, digest));
 
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
 
   const job = new PBKDF2Job(
     kCryptoJobAsync,

lib/internal/crypto/random.js

@@ -23,12 +23,14 @@ const { kMaxLength } = require('buffer');
 const {
   codes: {
     ERR_INVALID_ARG_TYPE,
-    ERR_INVALID_CALLBACK,
     ERR_OUT_OF_RANGE,
   }
 } = require('internal/errors');
 
-const { validateNumber } = require('internal/validators');
+const {
+  validateNumber,
+  validateCallback,
+} = require('internal/validators');
 
 const {
   isArrayBufferView,
@@ -73,8 +75,9 @@ function assertSize(size, elementSize, offset, length) {
 
 function randomBytes(size, callback) {
   size = assertSize(size, 1, 0, Infinity);
-  if (callback !== undefined && typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  if (callback !== undefined) {
+    validateCallback(callback);
+  }
 
   const buf = new FastBuffer(size);
 
@@ -141,8 +144,8 @@ function randomFill(buf, offset, size, callback) {
   } else if (typeof size === 'function') {
     callback = size;
     size = buf.byteLength - offset;
-  } else if (typeof callback !== 'function') {
-    throw new ERR_INVALID_CALLBACK(callback);
+  } else {
+    validateCallback(callback);
   }
 
   offset = assertOffset(offset, elementSize, buf.byteLength);
@@ -188,8 +191,8 @@ function randomInt(min, max, callback) {
   }
 
   const isSync = typeof callback === 'undefined';
-  if (!isSync && typeof callback !== 'function') {
-    throw new ERR_INVALID_CALLBACK(callback);
+  if (!isSync) {
+    validateCallback(callback);
   }
   if (!NumberIsSafeInteger(min)) {
     throw new ERR_INVALID_ARG_TYPE('min', 'a safe integer', min);

lib/internal/crypto/scrypt.js

@@ -14,6 +14,7 @@ const {
 } = internalBinding('crypto');
 
 const {
+  validateCallback,
   validateInteger,
   validateUint32,
 } = require('internal/validators');
@@ -22,7 +23,6 @@ const {
   codes: {
     ERR_CRYPTO_SCRYPT_INVALID_PARAMETER,
     ERR_CRYPTO_SCRYPT_NOT_SUPPORTED,
-    ERR_INVALID_CALLBACK,
   }
 } = require('internal/errors');
 
@@ -50,8 +50,7 @@ function scrypt(password, salt, keylen, options, callback = defaults) {
   const { N, r, p, maxmem } = options;
   ({ password, salt, keylen } = options);
 
-  if (typeof callback !== 'function')
-    throw new ERR_INVALID_CALLBACK(callback);
+  validateCallback(callback);
 
   const job = new ScryptJob(
     kCryptoJobAsync, password, salt, N, r, p, maxmem, keylen);