@swf2es/desktop 0.1.22 → 0.1.24

package/src/main/sockets.ts

@@ -1,9 +1,15 @@
 // flash.net.Socket's TCP connections, made here for the page, which has
 // no network of its own beyond fetch, and carried over IPC. Each page's
-// connections (connections.ts) close as it navigates, reloads or goes.
+// connections (connections.ts) close as it navigates, reloads or goes, and
+// their events go to it gathered, a message a millisecond at most
+// (relay.ts).
 import { type IpcMainEvent, ipcMain, type WebContents } from "electron";
+import type { SocketEvent } from "../shared/api.js";
 import { type ConnectionOptions, Connections, validEndpoint } from "./connections.ts";
 import { socketDataLine, socketLine } from "./netlog.ts";
+import { Relay } from "./relay.ts";
+
+const dataEvent = (bytes: Uint8Array): SocketEvent => ({ type: "data", bytes });
 
 /**
  * Carry socket messages from pages that `trusted` accepts, each connection
@@ -28,6 +34,11 @@ export function bridgeSockets(
       return known;
     }
 
+    const relay = new Relay<SocketEvent>((batch) => {
+      if (!contents.isDestroyed()) {
+        contents.send("socket:events", batch);
+      }
+    });
     const connections = new Connections((id, event) => {
       if (log && event.type !== "data") {
         log(socketLine(id, event.type === "error" ? `error: ${event.message}` : event.type));
@@ -35,52 +46,61 @@ export function bridgeSockets(
         log(socketDataLine(id, false, event.bytes));
       }
 
-      if (!contents.isDestroyed()) {
-        contents.send("socket:event", id, event);
+      if (event.type === "data") {
+        relay.bytes(id, event.bytes, dataEvent);
+      } else {
+        relay.push(id, event);
       }
     }, options);
     pages.set(contents, connections);
     contents.on("did-start-navigation", (details) => {
       if (details.isMainFrame && !details.isSameDocument) {
         connections.closeAll();
+        relay.drop();
       }
     });
     contents.once("destroyed", () => {
       connections.closeAll();
+      relay.drop();
       pages.delete(contents);
     });
     return connections;
   };
 
-  ipcMain.on("socket:connect", (event, id: unknown, host: unknown, port: unknown) => {
-    if (!trusted(event) || typeof id !== "number") {
-      return;
-    }
+  ipcMain.on(
+    "socket:connect",
+    (event, id: unknown, host: unknown, port: unknown, asked: unknown) => {
+      if (!trusted(event) || typeof id !== "number") {
+        return;
+      }
 
-    const connections = connectionsOf(event.sender);
-    if (!validEndpoint(host, port)) {
-      connections.refuse(id);
-      return;
-    }
+      // At once unless the SWF set tcpNoDelay to false (connections.ts).
+      const noDelay = asked !== false;
+      const connections = connectionsOf(event.sender);
+      if (!validEndpoint(host, port)) {
+        connections.refuse(id);
+        return;
+      }
 
-    const generation = connections.generation;
-    void permit(host, port as number)
-      .catch(() => null)
-      .then((allowed) => {
-        // The page that asked may have gone while the user was asked.
-        if (connections.generation !== generation) {
-          return;
-        }
+      const generation = connections.generation;
+      void permit(host, port as number)
+        .catch(() => null)
+        .then((allowed) => {
+          // The page that asked may have gone while the user was asked.
+          if (connections.generation !== generation) {
+            return;
+          }
 
-        const via = allowed && options.proxy ? " via proxy" : "";
-        log?.(socketLine(id, `${allowed ? "connecting to" : "refused"} ${host}:${port}${via}`));
-        if (allowed) {
-          connections.connect(id, host, port, allowed.address);
-        } else {
-          connections.refuse(id);
-        }
-      });
-  });
+          const via = allowed && options.proxy ? " via proxy" : "";
+          log?.(socketLine(id, `${allowed ? "connecting to" : "refused"} ${host}:${port}${via}`));
+          if (allowed) {
+            connections.connect(id, host, port, allowed.address, noDelay);
+          } else {
+            connections.refuse(id);
+          }
+        });
+    },
+  );
 
   ipcMain.on("socket:send", (event, id: unknown, bytes: unknown) => {
     if (trusted(event) && typeof id === "number" && bytes instanceof Uint8Array) {

package/src/main/websockets.ts

@@ -1,9 +1,13 @@
 // air.net.WebSocket's connections, made here for the page, which has no
 // network of its own, and carried over IPC as flash.net.Socket's are
 // (sockets.ts). Each page's connections (websocket-connections.ts) close
-// as it navigates, reloads or goes.
+// as it navigates, reloads or goes, and their events go to it gathered,
+// a message a millisecond at most (relay.ts), each message an event of its
+// own.
 import { type IpcMainEvent, ipcMain, type WebContents } from "electron";
+import type { WebSocketEvent } from "../shared/api.js";
 import { webSocketDataLine, webSocketLine } from "./netlog.ts";
+import { Relay } from "./relay.ts";
 import {
   type Opener,
   validProtocols,
@@ -11,6 +15,10 @@ import {
   WebSocketConnections,
 } from "./websocket-connections.ts";
 
+/** About what a message takes to send: a string's UTF-16 is two bytes a unit. */
+const messageSize = (data: string | Uint8Array): number =>
+  typeof data === "string" ? data.length * 2 : data.length;
+
 /**
  * Carry WebSocket messages from pages that `trusted` accepts, each
  * connection made only where `permit` allows its URL, with `open` if
@@ -35,6 +43,11 @@ export function bridgeWebSockets(
       return known;
     }
 
+    const relay = new Relay<WebSocketEvent>((batch) => {
+      if (!contents.isDestroyed()) {
+        contents.send("websocket:events", batch);
+      }
+    });
     const connections = new WebSocketConnections((id, event) => {
       if (log) {
         switch (event.type) {
@@ -56,18 +69,18 @@ export function bridgeWebSockets(
         }
       }
 
-      if (!contents.isDestroyed()) {
-        contents.send("websocket:event", id, event);
-      }
+      relay.push(id, event, event.type === "message" ? messageSize(event.data) : 0);
     }, open);
     pages.set(contents, connections);
     contents.on("did-start-navigation", (details) => {
       if (details.isMainFrame && !details.isSameDocument) {
         connections.closeAll();
+        relay.drop();
       }
     });
     contents.once("destroyed", () => {
       connections.closeAll();
+      relay.drop();
       pages.delete(contents);
     });
     return connections;

package/src/preload/preload.cts

@@ -2,6 +2,7 @@
 // each checked again by the main process. A sandboxed preload is a
 // CommonJS script that may require only Electron's renderer modules.
 import type {
+  ConnectionEvents,
   DesktopApi,
   LibraryName,
   NetworkResponse,
@@ -48,16 +49,17 @@ const api: DesktopApi = {
   openDropped: (file) => ipcRenderer.send("desktop:open-path", webUtils.getPathForFile(file)),
   chooseLibrary: (name: LibraryName) => ipcRenderer.send("desktop:choose-library", name),
   sockets: {
-    connect: (host, port) => {
+    connect: (host, port, noDelay) => {
       const id = nextSocket++;
-      ipcRenderer.send("socket:connect", id, String(host), Number(port));
+      const asked = typeof noDelay === "boolean" ? noDelay : undefined;
+      ipcRenderer.send("socket:connect", id, String(host), Number(port), asked);
       return id;
     },
     send: (id, bytes) => ipcRenderer.send("socket:send", id, bytes),
     close: (id) => ipcRenderer.send("socket:close", id),
-    onEvent: (listener) => {
-      ipcRenderer.on("socket:event", (_event, id: number, event: SocketEvent) =>
-        listener(id, event),
+    onEvents: (listener) => {
+      ipcRenderer.on("socket:events", (_event, events: ConnectionEvents<SocketEvent>) =>
+        listener(events),
       );
     },
   },
@@ -69,9 +71,9 @@ const api: DesktopApi = {
     },
     send: (id, data) => ipcRenderer.send("websocket:send", id, data),
     close: (id, code) => ipcRenderer.send("websocket:close", id, code),
-    onEvent: (listener) => {
-      ipcRenderer.on("websocket:event", (_event, id: number, event: WebSocketEvent) =>
-        listener(id, event),
+    onEvents: (listener) => {
+      ipcRenderer.on("websocket:events", (_event, events: ConnectionEvents<WebSocketEvent>) =>
+        listener(events),
       );
     },
   },

package/src/renderer/sockets.ts

@@ -6,32 +6,41 @@ import type { DesktopSockets } from "../shared/api.js";
 export function shellSocketHost(sockets: DesktopSockets): SocketHost {
   // Until its close, which the shell sends after an error and after a close asked for.
   const open = new Map<number, SocketEvents>();
-  sockets.onEvent((id, event) => {
-    const events = open.get(id);
-    if (!events) {
-      return;
-    }
+  // A batch is one task: its events go to their connections in one loop.
+  sockets.onEvents((batch) => {
+    for (let i = 0; i < batch.length; i++) {
+      const [id, event] = batch[i];
+      const events = open.get(id);
+      if (!events) {
+        continue;
+      }
 
-    switch (event.type) {
-      case "open":
-        events.open(event);
-        break;
-      case "data":
-        events.data(event.bytes);
-        break;
-      case "error":
-        events.error(event.message);
-        break;
-      case "close":
-        open.delete(id);
-        events.close();
-        break;
+      // One that throws leaves the rest to run, as when each came in a message of its own.
+      try {
+        switch (event.type) {
+          case "open":
+            events.open(event);
+            break;
+          case "data":
+            events.data(event.bytes);
+            break;
+          case "error":
+            events.error(event.message);
+            break;
+          case "close":
+            open.delete(id);
+            events.close();
+            break;
+        }
+      } catch (error) {
+        reportError(error);
+      }
     }
   });
 
   return {
-    connect(host, port, events) {
-      const id = sockets.connect(host, port);
+    connect(host, port, events, options) {
+      const id = sockets.connect(host, port, options?.noDelay);
       open.set(id, events);
       return {
         send: (bytes) => sockets.send(id, bytes),

package/src/renderer/websockets.ts

@@ -7,26 +7,35 @@ import type { DesktopWebSockets } from "../shared/api.js";
 export function shellWebSocketHost(webSockets: DesktopWebSockets): WebSocketHost {
   // Until its close, which the shell sends after a failure too.
   const open = new Map<number, WebSocketEvents>();
-  webSockets.onEvent((id, event) => {
-    const events = open.get(id);
-    if (!events) {
-      return;
-    }
+  // A batch is one task: its events, a message each, go to their connections in one loop.
+  webSockets.onEvents((batch) => {
+    for (let i = 0; i < batch.length; i++) {
+      const [id, event] = batch[i];
+      const events = open.get(id);
+      if (!events) {
+        continue;
+      }
 
-    switch (event.type) {
-      case "open":
-        events.open(event.protocol);
-        break;
-      case "message":
-        events.message(event.data);
-        break;
-      case "error":
-        events.error();
-        break;
-      case "close":
-        open.delete(id);
-        events.close(event.code);
-        break;
+      // One that throws leaves the rest to run, as when each came in a message of its own.
+      try {
+        switch (event.type) {
+          case "open":
+            events.open(event.protocol);
+            break;
+          case "message":
+            events.message(event.data);
+            break;
+          case "error":
+            events.error();
+            break;
+          case "close":
+            open.delete(id);
+            events.close(event.code);
+            break;
+        }
+      } catch (error) {
+        reportError(error);
+      }
     }
   });
 

package/src/shared/api.ts

@@ -135,13 +135,22 @@ export type SocketEvent =
   | { type: "close" }
   | { type: "error"; message: string };
 
+/**
+ * Events as the shell sends them, gathered over a millisecond at most:
+ * each with its connection's id, in the order they came.
+ */
+export type ConnectionEvents<E> = readonly (readonly [id: number, event: E])[];
+
 /** flash.net.Socket's TCP connections, opened by the shell. */
 export interface DesktopSockets {
-  /** A connection's id; its events follow, an "error" one if the shell refuses it. */
-  connect(host: string, port: number): number;
+  /**
+   * A connection's id; its events follow, an "error" one if the shell refuses it. `noDelay` is
+   * tcpNoDelay as the SWF set it, absent where it did not: the shell then sends at once.
+   */
+  connect(host: string, port: number, noDelay?: boolean): number;
   send(id: number, bytes: Uint8Array): void;
   close(id: number): void;
-  onEvent(listener: (id: number, event: SocketEvent) => void): void;
+  onEvents(listener: (events: ConnectionEvents<SocketEvent>) => void): void;
 }
 
 /** What befalls a WebSocket, as player's WebSocketEvents has it. */
@@ -158,7 +167,7 @@ export interface DesktopWebSockets {
   /** A text message for a string, a binary one for bytes. */
   send(id: number, data: string | Uint8Array): void;
   close(id: number, code?: number): void;
-  onEvent(listener: (id: number, event: WebSocketEvent) => void): void;
+  onEvents(listener: (events: ConnectionEvents<WebSocketEvent>) => void): void;
 }
 
 /** A request of a SWF's, as player's FetchRequest has it. */