Make postMessage across window boundaries synchronous

Author: Avaer Kazmer

src/Window.js

@@ -687,21 +687,25 @@ self.onrunasync = req => {
   switch (method) {
     case 'tickAnimationFrame': {
       self.tickAnimationFrame(req);
-      return Promise.resolve();
+      break;
     }
     case 'enterXr': {
       console.log('handle enter xr', GlobalContext.id);
       self.vrdisplaypresentchange();
-      return Promise.all(windows.map(win => win.runAsync({
-        method: 'enterXr',
-      }))).then(() => {});
+      for (let i = 0; i < windows.length; i++) {
+        windows[i].runAsync({
+          method: 'enterXr',
+        });
+      }
       break;
     }
     case 'exitXr': {
       self.vrdisplaypresentchange();
-      return Promise.all(windows.map(win => win.runAsync({
-        method: 'exitXr',
-      }))).then(() => {});
+      for (let i = 0; i < windows.length; i++) {
+        windows[i].runAsync({
+          method: 'exitXr',
+        });
+      }
       break;
     }
     case 'response': {
@@ -710,10 +714,8 @@ self.onrunasync = req => {
       if (keypath.length === 0) {
         if (vrPresentState.responseAccepts.length > 0) {
           vrPresentState.responseAccepts.shift()(req);
-
-          return Promise.resolve();
         } else {
-          return Promise.reject(new Error(`unexpected response at window ${method}`));
+          throw new Error(`unexpected response at window ${method}`);
         }
       } else {
         const windowId = keypath.pop();
@@ -729,8 +731,8 @@ self.onrunasync = req => {
         } else {
           console.warn('ignoring unknown response', req, {windowId});
         }
-        return Promise.resolve();
       }
+      break;
     }
     /* case 'keyEvent': {
       const {event} = request;
@@ -806,9 +808,11 @@ self.onrunasync = req => {
       }
       break;
     } */
-    case 'eval': // used in tests
-      return Promise.resolve([(0, eval)(req.scriptString), []]);
+    case 'eval': {// used in tests
+      (0, eval)(req.scriptString);
+      break;
+    }
     default:
-      return Promise.reject(new Error(`invalid window async request: ${JSON.stringify(req)}`));
+      throw new Error(`invalid window async request: ${JSON.stringify(req)}`);
   }
 };

src/WindowBase.js

@@ -141,7 +141,7 @@ const _oninitmessage = async e => {
     self._onbootstrap = undefined;
   };
   self._postMessageUp = function _postMessageUp(data, transfer) {
-    messagePort.postMessage(data, transfer);
+    messagePort.postMessageSync(data, transfer);
   };
   const _onmessageHandle = e => {
     const {data: m} = e;
@@ -163,26 +163,23 @@ const _oninitmessage = async e => {
         break;
       }
       case 'runAsync': {
-        let result, err;
+        let resultSpec, err;
         try {
-          result = self.onrunasync ? self.onrunasync(m.request) : null;
+          resultSpec = self.onrunasync ? self.onrunasync(m.request) : null;
         } catch(e) {
           err = e.stack;
         }
         if (!err) {
-          Promise.resolve(result)
-            .then(resultSpec => {
-              let result, transfers;
-              if (resultSpec) {
-                result = resultSpec[0];
-                transfers = resultSpec[1];
-              }
-              self._postMessageUp({
-                method: 'response',
-                requestKey: m.requestKey,
-                result,
-              }, transfers);
-            });
+          let result, transfers;
+          if (resultSpec) {
+            result = resultSpec[0];
+            transfers = resultSpec[1];
+          }
+          self._postMessageUp({
+            method: 'response',
+            requestKey: m.requestKey,
+            result,
+          }, transfers);
         } else {
           self._postMessageUp({
             method: 'response',

src/WindowVm.js

@@ -87,6 +87,12 @@ class WorkerVm extends EventTarget {
       });
 
     const messageChannel = new MessageChannel2();
+    messageChannel.port2.postMessageSync = (data, transfers) => {
+      messageChannel.port1.dispatchEvent(new MessageEvent('message', {data}));
+    };
+    messageChannel.port1.postMessageSync = (data, transfers) => {
+      messageChannel.port2.dispatchEvent(new MessageEvent('message', {data}));
+    };
     messageChannel.port1.addEventListener('message', e => {
       const {data: m} = e;
       switch (m.method) {
@@ -145,7 +151,7 @@ class WorkerVm extends EventTarget {
     messageChannel.port1.start();
 
     iframe._postMessageDown = function _postMessageDown(data, transfer) {
-      messageChannel.port1.postMessage(data, transfer);
+      messageChannel.port1.postMessageSync(data, transfer);
     };
     iframe.cleanup = () => {
       iframe.contentWindow.removeEventListener('postmessage', _postmessage);
@@ -185,20 +191,21 @@ class WorkerVm extends EventTarget {
     });
   }
   runAsync(request, transferList) {
-    return new Promise((accept, reject) => {
-      const requestKey = this.queueRequest((err, result) => {
-        if (!err) {
-          accept(result);
-        } else {
-          reject(err);
-        }
-      });
-      this.iframe._postMessageDown({
-        method: 'runAsync',
-        request,
-        requestKey,
-      }, transferList);
+    let result, error;
+    const requestKey = this.queueRequest((err, res) => {
+      error = err;
+      result = res;
     });
+    this.iframe._postMessageDown({
+      method: 'runAsync',
+      request,
+      requestKey,
+    }, transferList);
+    if (!error) {
+      return result;
+    } else {
+      throw error;
+    }
   }
   postMessage(message, transferList) {
     this.iframe._postMessageDown({

src/index.js

@@ -453,12 +453,7 @@ const _tickAnimationFrame = win => {
   return win.runAsync({
     method: 'tickAnimationFrame',
     layered: true,
-  })
-    .catch(err => {
-      if (err.code !== 'ECANCEL') {
-        console.warn(err);
-      }
-    });
+  });
 };
 const _tickAnimationFrames = () => {
   for (let i = 0; i < windows.length; i++) {