worker: make MessageEvent class more Web-compatible

PR-URL: #35496Fixes: #35495 Reviewed-By: Rich Trott <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Joyee Cheung <[email protected]> Reviewed-By: Myles Borins <[email protected]> Reviewed-By: Shelley Vohr <[email protected]> Reviewed-By: Michael Dawson <[email protected]> Reviewed-By: Khaidi Chu <[email protected]>

Author: addaleax

lib/internal/worker/io.js

@@ -4,6 +4,7 @@ const{
  ObjectAssign,
  ObjectCreate,
  ObjectDefineProperty,
+ ObjectDefineProperties,
  ObjectGetOwnPropertyDescriptors,
  ObjectGetPrototypeOf,
  ObjectSetPrototypeOf,
@@ -21,7 +22,8 @@ const{
  drainMessagePort,
  moveMessagePortToContext,
 receiveMessageOnPort: receiveMessageOnPort_,
- stopMessagePort
+ stopMessagePort,
+ checkMessagePort
 }=internalBinding('messaging');
 const{
  getEnvMessagePort
@@ -38,12 +40,20 @@ const{
  kRemoveListener,
 }=require('internal/event_target');
 const{ inspect }=require('internal/util/inspect');
+const{
+ERR_INVALID_ARG_TYPE
+}=require('internal/errors').codes;
 
+constkData=Symbol('kData');
 constkIncrementsPortRef=Symbol('kIncrementsPortRef');
+constkLastEventId=Symbol('kLastEventId');
 constkName=Symbol('kName');
+constkOrigin=Symbol('kOrigin');
 constkPort=Symbol('kPort');
+constkPorts=Symbol('kPorts');
 constkWaitingStreams=Symbol('kWaitingStreams');
 constkWritableCallbacks=Symbol('kWritableCallbacks');
+constkSource=Symbol('kSource');
 constkStartedReading=Symbol('kStartedReading');
 constkStdioWantsMoreDataCallback=Symbol('kStdioWantsMoreDataCallback');
 
@@ -72,19 +82,57 @@ ObjectSetPrototypeOf(MessagePort.prototype, NodeEventTarget.prototype);
 MessagePort.prototype.ref=MessagePortPrototype.ref;
 MessagePort.prototype.unref=MessagePortPrototype.unref;
 
+functionvalidateMessagePort(port,name){
+if(!checkMessagePort(port))
+thrownewERR_INVALID_ARG_TYPE(name,'MessagePort',port);
+}
+
 classMessageEventextendsEvent{
-constructor(data,target,type){
+constructor(type,{
+ data =null,
+ origin ='',
+ lastEventId ='',
+ source =null,
+ ports =[],
+}={}){
 super(type);
-this.data=data;
+this[kData]=data;
+this[kOrigin]=`${origin}`;
+this[kLastEventId]=`${lastEventId}`;
+this[kSource]=source;
+this[kPorts]=[...ports];
+
+if(this[kSource]!==null)
+validateMessagePort(this[kSource],'init.source');
+for(leti=0;i<this[kPorts].length;i++)
+validateMessagePort(this[kPorts][i],`init.ports[${i}]`);
 }
 }
 
+ObjectDefineProperties(MessageEvent.prototype,{
+data: {
+get(){returnthis[kData];},enumerable: true,configurable: true
+},
+origin: {
+get(){returnthis[kOrigin];},enumerable: true,configurable: true
+},
+lastEventId: {
+get(){returnthis[kLastEventId];},enumerable: true,configurable: true
+},
+source: {
+get(){returnthis[kSource];},enumerable: true,configurable: true
+},
+ports: {
+get(){returnthis[kPorts];},enumerable: true,configurable: true
+},
+});
+
 ObjectDefineProperty(
 MessagePort.prototype,
 kCreateEvent,
 {
 value: function(data,type){
-returnnewMessageEvent(data,this,type);
+returnnewMessageEvent(type,{ data });
 },
 configurable: false,
 writable: false,
@@ -283,6 +331,7 @@ module.exports ={
  moveMessagePortToContext,
  MessagePort,
  MessageChannel,
+ MessageEvent,
  receiveMessageOnPort,
  setupPortReferencing,
  ReadableWorkerStdio,

src/node_messaging.cc

@@ -1004,6 +1004,12 @@ void MessagePort::Stop(const FunctionCallbackInfo<Value>& args){
  port->Stop();
 }
 
+voidMessagePort::CheckType(const FunctionCallbackInfo<Value>& args){
+ Environment* env = Environment::GetCurrent(args);
+ args.GetReturnValue().Set(
+GetMessagePortConstructorTemplate(env)->HasInstance(args[0]));
+}
+
 voidMessagePort::Drain(const FunctionCallbackInfo<Value>& args){
  MessagePort* port;
 ASSIGN_OR_RETURN_UNWRAP(&port, args[0].As<Object>());
@@ -1339,6 +1345,7 @@ static void InitMessaging(Local<Object> target,
 // These are not methods on the MessagePort prototype, because
 // the browser equivalents do not provide them.
  env->SetMethod(target, "stopMessagePort", MessagePort::Stop);
+ env->SetMethod(target, "checkMessagePort", MessagePort::CheckType);
  env->SetMethod(target, "drainMessagePort", MessagePort::Drain);
  env->SetMethod(target, "receiveMessageOnPort", MessagePort::ReceiveMessage);
  env->SetMethod(target, "moveMessagePortToContext",
@@ -1363,6 +1370,7 @@ static void RegisterExternalReferences(ExternalReferenceRegistry* registry){
  registry->Register(MessagePort::PostMessage);
  registry->Register(MessagePort::Start);
  registry->Register(MessagePort::Stop);
+ registry->Register(MessagePort::CheckType);
  registry->Register(MessagePort::Drain);
  registry->Register(MessagePort::ReceiveMessage);
  registry->Register(MessagePort::MoveToContext);

src/node_messaging.h

@@ -195,6 +195,7 @@ class MessagePort : public HandleWrap{
 staticvoidPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidStart(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidStop(const v8::FunctionCallbackInfo<v8::Value>& args);
+staticvoidCheckType(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidDrain(const v8::FunctionCallbackInfo<v8::Value>& args);
 staticvoidReceiveMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
 

test/parallel/test-worker-message-event.js

@@ -0,0 +1,92 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+constassert=require('assert');
+const{ MessageEvent, MessageChannel }=require('internal/worker/io');
+
+constdummyPort=newMessageChannel().port1;
+
+{
+for(const[args,expected]of[
+[
+['message'],
+{
+type: 'message',data: null,origin: '',
+lastEventId: '',source: null,ports: []
+}
+],
+[
+['message',{data: undefined,origin: 'foo'}],
+{
+type: 'message',data: null,origin: 'foo',
+lastEventId: '',source: null,ports: []
+}
+],
+[
+['message',{data: 2,origin: 1,lastEventId: 0}],
+{
+type: 'message',data: 2,origin: '1',
+lastEventId: '0',source: null,ports: []
+}
+],
+[
+['message',{lastEventId: 'foo'}],
+{
+type: 'message',data: null,origin: '',
+lastEventId: 'foo',source: null,ports: []
+}
+],
+[
+['messageerror',{lastEventId: 'foo',source: dummyPort}],
+{
+type: 'messageerror',data: null,origin: '',
+lastEventId: 'foo',source: dummyPort,ports: []
+}
+],
+[
+['message',{ports: [dummyPort],source: null}],
+{
+type: 'message',data: null,origin: '',
+lastEventId: '',source: null,ports: [dummyPort]
+}
+],
+]){
+constev=newMessageEvent(...args);
+const{ type, data, origin, lastEventId, source, ports }=ev;
+assert.deepStrictEqual(expected,{
+ type, data, origin, lastEventId, source, ports
+});
+}
+}
+
+{
+assert.throws(()=>{
+newMessageEvent('message',{source: 1});
+},{
+code: 'ERR_INVALID_ARG_TYPE',
+message: /The"init\.source"propertymustbeaninstanceofMessagePort/,
+});
+assert.throws(()=>{
+newMessageEvent('message',{source: {}});
+},{
+code: 'ERR_INVALID_ARG_TYPE',
+message: /The"init\.source"propertymustbeaninstanceofMessagePort/,
+});
+assert.throws(()=>{
+newMessageEvent('message',{ports: 0});
+},{
+message: /portsisnotiterable/,
+});
+assert.throws(()=>{
+newMessageEvent('message',{ports: [null]});
+},{
+code: 'ERR_INVALID_ARG_TYPE',
+message: /The"init\.ports\[0\]"propertymustbeaninstanceofMessagePort/,
+});
+assert.throws(()=>{
+newMessageEvent('message',{ports: [{}]});
+},{
+code: 'ERR_INVALID_ARG_TYPE',
+message: /The"init\.ports\[0\]"propertymustbeaninstanceofMessagePort/,
+});
+}