lib: refactor internal webidl converters

benchmark/misc/webcrypto-webidl.js

@@ -0,0 +1,109 @@
+'use strict';
+
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  op: [
+    'normalizeAlgorithm-string',
+    'normalizeAlgorithm-dict',
+    'webidl-dict',
+    'webidl-algorithm-identifier-string',
+    'webidl-algorithm-identifier-object',
+    'webidl-dict-enforce-range',
+    'webidl-dict-ensure-sha',
+    'webidl-dict-null',
+  ],
+  n: [1e6],
+}, { flags: ['--expose-internals'] });
+
+function main({ n, op }) {
+  const { normalizeAlgorithm } = require('internal/crypto/util');
+
+  switch (op) {
+    case 'normalizeAlgorithm-string': {
+      // String shortcut + null dictionary (cheapest path).
+      bench.start();
+      for (let i = 0; i < n; i++)
+        normalizeAlgorithm('SHA-256', 'digest');
+      bench.end(n);
+      break;
+    }
+    case 'normalizeAlgorithm-dict': {
+      // Object input with a dictionary type and no BufferSource members.
+      const alg = { name: 'ECDSA', hash: 'SHA-256' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        normalizeAlgorithm(alg, 'sign');
+      bench.end(n);
+      break;
+    }
+    case 'webidl-dict': {
+      // WebIDL dictionary converter in isolation.
+      const webidl = require('internal/crypto/webidl');
+      const input = { name: 'AES-GCM', iv: new Uint8Array(12) };
+      const opts = { prefix: 'test', context: 'test' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        webidl.converters.AeadParams(input, opts);
+      bench.end(n);
+      break;
+    }
+    case 'webidl-algorithm-identifier-string': {
+      // Exercises converters.AlgorithmIdentifier string path.
+      const webidl = require('internal/crypto/webidl');
+      const opts = { prefix: 'test', context: 'test' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        webidl.converters.AlgorithmIdentifier('SHA-256', opts);
+      bench.end(n);
+      break;
+    }
+    case 'webidl-algorithm-identifier-object': {
+      // Exercises converters.AlgorithmIdentifier object path.
+      const webidl = require('internal/crypto/webidl');
+      const input = { name: 'SHA-256' };
+      const opts = { prefix: 'test', context: 'test' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        webidl.converters.AlgorithmIdentifier(input, opts);
+      bench.end(n);
+      break;
+    }
+    case 'webidl-dict-enforce-range': {
+      // Exercises [EnforceRange] integer dictionary members.
+      const webidl = require('internal/crypto/webidl');
+      const input = {
+        name: 'RSASSA-PKCS1-v1_5',
+        modulusLength: 2048,
+        publicExponent: new Uint8Array([1, 0, 1]),
+      };
+      const opts = { prefix: 'test', context: 'test' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        webidl.converters.RsaKeyGenParams(input, opts);
+      bench.end(n);
+      break;
+    }
+    case 'webidl-dict-ensure-sha': {
+      // Exercises ensureSHA on a hash member.
+      const webidl = require('internal/crypto/webidl');
+      const input = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' };
+      const opts = { prefix: 'test', context: 'test' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        webidl.converters.RsaHashedImportParams(input, opts);
+      bench.end(n);
+      break;
+    }
+    case 'webidl-dict-null': {
+      // Exercises the null/undefined path in createDictionaryConverter().
+      const webidl = require('internal/crypto/webidl');
+      const opts = { prefix: 'test', context: 'test' };
+      bench.start();
+      for (let i = 0; i < n; i++)
+        webidl.converters.JsonWebKey(undefined, opts);
+      bench.end(n);
+      break;
+    }
+  }
+}

benchmark/misc/webidl-convert-to-int.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common.js');
+
+const bench = common.createBenchmark(main, {
+  converter: [
+    'byte',
+    'octet',
+    'unsigned short',
+    'unsigned long',
+    'long long',
+  ],
+  input: [
+    'integer',
+    'fractional',
+    'wrap',
+    'clamp',
+    'enforce-range',
+    'object',
+  ],
+  n: [1e6],
+}, { flags: ['--expose-internals'] });
+
+function getConverter(converter) {
+  switch (converter) {
+    case 'byte':
+      return { bitLength: 8, signedness: 'signed' };
+    case 'octet':
+      return { bitLength: 8 };
+    case 'unsigned short':
+      return { bitLength: 16 };
+    case 'unsigned long':
+      return { bitLength: 32 };
+    case 'long long':
+      return { bitLength: 64, signedness: 'signed' };
+    default:
+      throw new Error(`Unsupported converter: ${converter}`);
+  }
+}
+
+function getInput(input) {
+  switch (input) {
+    case 'integer':
+      return { value: 7 };
+    case 'fractional':
+      return { value: 7.9 };
+    case 'wrap':
+      return { value: 2 ** 63 + 2 ** 11 };
+    case 'clamp':
+      return { value: 300.8, options: { clamp: true } };
+    case 'enforce-range':
+      return { value: 7.9, options: { enforceRange: true } };
+    case 'object':
+      return {
+        value: {
+          valueOf() { return 7; },
+        },
+      };
+    default:
+      throw new Error(`Unsupported input: ${input}`);
+  }
+}
+
+function main({ n, converter, input }) {
+  const { convertToInt } = require('internal/webidl');
+  const { bitLength, signedness } = getConverter(converter);
+  const { value, options } = getInput(input);
+
+  let noDead;
+  bench.start();
+  if (options === undefined) {
+    for (let i = 0; i < n; i++)
+      noDead = convertToInt(value, bitLength, signedness);
+  } else {
+    for (let i = 0; i < n; i++)
+      noDead = convertToInt(value, bitLength, signedness, options);
+  }
+  bench.end(n);
+
+  assert.strictEqual(typeof noDead, 'number');
+}

lib/internal/blob.js

@@ -54,7 +54,6 @@ const {
 const { inspect } = require('internal/util/inspect');
 const {
   converters,
-  convertToInt,
   createSequenceConverter,
 } = require('internal/webidl');
 
@@ -245,10 +244,14 @@ class Blob {
     if (!isBlob(this))
       throw new ERR_INVALID_THIS('Blob');
 
-    // Coerce values to int
-    const opts = { __proto__: null, signed: true };
-    start = convertToInt('start', start, 64, opts);
-    end = convertToInt('end', end, 64, opts);
+    start = converters['long long'](
+      start,
+      { __proto__: null, context: 'start' },
+    );
+    end = converters['long long'](
+      end,
+      { __proto__: null, context: 'end' },
+    );
 
     if (start < 0) {
       start = MathMax(this[kLength] + start, 0);