lib: convert transfer sequence to array in js

This commit lets `tranfer` passed to `structuredClone` get validated at
JS layer by doing webidl conversion. This avoids the C++ to JS function
call overhead in the native implementaiton of `structuredClone`
PR-URL: #55317Fixes: #55280
Refs: #50330
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Matthew Aitken <maitken033380023@gmail.com>

Author: jazelly

lib/internal/bootstrap/web/exposed-window-or-worker.js

@@ -38,8 +38,11 @@ const {
 }=require('internal/process/task_queues');
 defineOperation(globalThis,'queueMicrotask',queueMicrotask);
 
-const{ structuredClone }=internalBinding('messaging');
-defineOperation(globalThis,'structuredClone',structuredClone);
+defineLazyProperties(
+globalThis,
+'internal/worker/js_transferable',
+['structuredClone'],
+);
 defineLazyProperties(globalThis,'buffer',['atob','btoa']);
 
 // https://html.spec.whatwg.org/multipage/web-messaging.html#broadcasting-to-other-browsing-contexts

lib/internal/perf/usertiming.js

@@ -31,7 +31,7 @@ const {
 },
 }=require('internal/errors');
 
-const{ structuredClone }=internalBinding('messaging');
+const{ structuredClone }=require('internal/worker/js_transferable');
 const{
  lazyDOMException,
  kEnumerableProperty,

lib/internal/webidl.js

@@ -38,6 +38,16 @@ converters.any = (V) => {
 returnV;
 };
 
+converters.object=(V,opts=kEmptyObject)=>{
+if(type(V)!=='Object'){
+throwmakeException(
+'is not an object',
+kEmptyObject,
+);
+}
+returnV;
+};
+
 // https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
 constintegerPart=MathTrunc;
 
@@ -189,6 +199,8 @@ converters.DOMString = function DOMString(V) {
 returnString(V);
 };
 
+converters['sequence<object>']=createSequenceConverter(converters.object);
+
 functioncodedTypeError(message,errorProperties=kEmptyObject){
 // eslint-disable-next-line no-restricted-syntax
 consterr=newTypeError(message);

lib/internal/webstreams/readablestream.js

@@ -74,6 +74,7 @@ const {
  kTransfer,
  kTransferList,
  markTransferMode,
+ structuredClone,
 }=require('internal/worker/js_transferable');
 
 const{
@@ -88,8 +89,6 @@ const {
  kControllerErrorFunction,
 }=require('internal/streams/utils');
 
-const{ structuredClone }=internalBinding('messaging');
-
 const{
  ArrayBufferViewGetBuffer,
  ArrayBufferViewGetByteLength,

lib/internal/worker/js_transferable.js

@@ -3,6 +3,13 @@ const {
  Error,
  StringPrototypeSplit,
 }=primordials;
+const{
+codes: {
+ERR_INVALID_ARG_TYPE,
+ERR_MISSING_ARGS,
+},
+}=require('internal/errors');
+constwebidl=require('internal/webidl');
 const{
  messaging_deserialize_symbol,
  messaging_transfer_symbol,
@@ -11,6 +18,7 @@ const {
 }=internalBinding('symbols');
 const{
  setDeserializerCreateObjectFunction,
+structuredClone: nativeStructuredClone,
 }=internalBinding('messaging');
 const{
 privateSymbols: {
@@ -90,9 +98,38 @@ function markTransferMode(obj, cloneable = false, transferable = false) {
 obj[transfer_mode_private_symbol]=mode;
 }
 
+functionstructuredClone(value,options){
+if(arguments.length===0){
+thrownewERR_MISSING_ARGS('The value argument must be specified');
+}
+
+// TODO(jazelly): implement generic webidl dictionary converter
+constprefix='Options';
+constoptionsType=webidl.type(options);
+if(optionsType!=='Undefined'&&optionsType!=='Null'&&optionsType!=='Object'){
+thrownewERR_INVALID_ARG_TYPE(
+prefix,
+['object','null','undefined'],
+options,
+);
+}
+constkey='transfer';
+constidlOptions={__proto__: null,[key]: []};
+if(options!=null&&keyinoptions&&options[key]!==undefined){
+idlOptions[key]=webidl.converters['sequence<object>'](options[key],{
+__proto__: null,
+context: 'Transfer',
+});
+}
+
+constserializedData=nativeStructuredClone(value,idlOptions);
+returnserializedData;
+}
+
 module.exports={
  markTransferMode,
  setup,
+ structuredClone,
 kClone: messaging_clone_symbol,
 kDeserialize: messaging_deserialize_symbol,
 kTransfer: messaging_transfer_symbol,

src/node_messaging.cc

@@ -1578,28 +1578,21 @@ static void StructuredClone(const FunctionCallbackInfo<Value>& args) {
  Realm* realm = Realm::GetCurrent(context);
  Environment* env = realm->env();
 
-if (args.Length() == 0) {
-returnTHROW_ERR_MISSING_ARGS(env, "The value argument must be specified");
- }
-
  Local<Value> value = args[0];
 
  TransferList transfer_list;
-if (!args[1]->IsNullOrUndefined()) {
-if (!args[1]->IsObject()) {
-returnTHROW_ERR_INVALID_ARG_TYPE(
- env, "The options argument must be either an object or undefined");
- }
- Local<Object> options = args[1].As<Object>();
- Local<Value> transfer_list_v;
-if (!options->Get(context, env->transfer_string())
- .ToLocal(&transfer_list_v)) {
-return;
- }
+ Local<Object> options = args[1].As<Object>();
+ Local<Value> transfer_list_v;
+if (!options->Get(context, env->transfer_string())
+ .ToLocal(&transfer_list_v)) {
+return;
+ }
 
-// TODO(joyeecheung): implement this in JS land to avoid the C++ -> JS
-// cost to convert a sequence into an array.
-if (!GetTransferList(env, context, transfer_list_v, &transfer_list)) {
+ Local<Array> arr = transfer_list_v.As<Array>();
+size_t length = arr->Length();
+ transfer_list.AllocateSufficientStorage(length);
+for (size_t i = 0; i < length; i++) {
+if (!arr->Get(context, i).ToLocal(&transfer_list[i])) {
 return;
  }
  }

test/parallel/test-structuredClone-global.js

@@ -8,12 +8,12 @@ assert.throws(() => structuredClone(undefined, ''), { code: 'ERR_INVALID_ARG_TYP
 assert.throws(()=>structuredClone(undefined,1),{code: 'ERR_INVALID_ARG_TYPE'});
 assert.throws(()=>structuredClone(undefined,{transfer: 1}),{code: 'ERR_INVALID_ARG_TYPE'});
 assert.throws(()=>structuredClone(undefined,{transfer: ''}),{code: 'ERR_INVALID_ARG_TYPE'});
+assert.throws(()=>structuredClone(undefined,{transfer: null}),{code: 'ERR_INVALID_ARG_TYPE'});
 
 // Options can be null or undefined.
 assert.strictEqual(structuredClone(undefined),undefined);
 assert.strictEqual(structuredClone(undefined,null),undefined);
 // Transfer can be null or undefined.
-assert.strictEqual(structuredClone(undefined,{transfer: null}),undefined);
 assert.strictEqual(structuredClone(undefined,{}),undefined);
 
 // Transferables or its subclasses should be received with its closest transferable superclass
@@ -43,6 +43,27 @@ for (const Transferrable of [File, Blob]) {
 assert.ok(extendedTransferinstanceofTransferrable);
 }
 
+// Transfer can be iterable
+{
+constvalue={
+a: newReadableStream(),
+b: newWritableStream(),
+};
+constcloned=structuredClone(value,{
+transfer: {
+*[Symbol.iterator](){
+for(constkeyinvalue){
+yieldvalue[key];
+}
+}
+}
+});
+for(constkeyinvalue){
+assert.ok(value[key].locked);
+assert.ok(!cloned[key].locked);
+}
+}
+
 {
 // See: https://github.com/nodejs/node/issues/49940
 constcloned=structuredClone({},{