// Copyright 2023 The Chromium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. import type {Chrome} from '../../../extension-api/ExtensionAPI.js'; import type {ModuleConfigurations} from './ModuleConfiguration.js'; import {type SerializedWasmType, serializeWasmValue, type WasmValue} from './WasmTypes.js'; export interface WorkerInterface extends Chrome.DevTools.LanguageExtensionPlugin { hello(moduleConfigurations: ModuleConfigurations, logPluginApiCalls: boolean): void; } export interface AsyncHostInterface { getWasmLinearMemory(offset: number, length: number, stopId: unknown): Promise; getWasmLocal(local: number, stopId: unknown): Promise; getWasmGlobal(global: number, stopId: unknown): Promise; getWasmOp(op: number, stopId: unknown): Promise; reportResourceLoad(resourceUrl: string, status: {success: boolean, errorMessage?: string, size?: number}): Promise; } export interface HostInterface { getWasmLinearMemory(offset: number, length: number, stopId: unknown): ArrayBuffer; getWasmLocal(local: number, stopId: unknown): WasmValue; getWasmGlobal(global: number, stopId: unknown): WasmValue; getWasmOp(op: number, stopId: unknown): WasmValue; reportResourceLoad(resourceUrl: string, status: {success: boolean, errorMessage?: string, size?: number}): Promise; } /* eslint-disable-next-line @typescript-eslint/no-explicit-any */ type AllMessages> = { [k in keyof Interface]: {method: k, params: Parameters} }; type Message = { requestId: number, }&({request: AllMessages[keyof AllMessages]}|{ /* eslint-disable-next-line @typescript-eslint/naming-convention */ sync_request: { request: AllMessages[keyof AllMessages], /* eslint-disable-next-line @typescript-eslint/naming-convention */ io_buffer: {semaphore: SharedArrayBuffer, data: SharedArrayBuffer}, }, }); export interface Channel { /* eslint-disable-next-line @typescript-eslint/no-explicit-any */ postMessage(message: /* Response|Message*/ any): any; /* eslint-disable-next-line @typescript-eslint/no-explicit-any */ onmessage: ((e: MessageEvent|Response>) => any)|null; } /* eslint-disable-next-line @typescript-eslint/no-explicit-any */ type AllResponses> = { [k in keyof Interface]: ReturnType }; type Response = { requestId: number, }&({error: string}|{response: AllResponses[keyof AllResponses]}); export abstract class SynchronousIOMessage { readonly buffer: SharedArrayBuffer; constructor(bufferSize: number) { this.buffer = new SharedArrayBuffer(bufferSize); } abstract deserialize(response: number): T; static serialize(value: ArrayBuffer|WasmValue, buffer: SharedArrayBuffer): SerializedWasmType { return serializeWasmValue(value, buffer); } } /* eslint-disable-next-line @typescript-eslint/no-explicit-any */ export class WorkerRPC, RemoteInterface extends Record> { private nextRequestId = 0; private readonly channel: Channel; private readonly localHandler: LocalInterface; private readonly requests = new Map void, reject: (message: Error) => void}>(); private readonly semaphore = new Int32Array(new SharedArrayBuffer(4)); constructor(channel: Channel, localHandler: LocalInterface) { this.channel = channel; this.channel.onmessage = this.onmessage.bind(this); this.localHandler = localHandler; } sendMessage(method: Method, ...params: Parameters): ReturnType { const requestId = this.nextRequestId++; const promise = new Promise((resolve, reject) => { this.requests.set(requestId, {resolve, reject}); }); this.channel.postMessage({requestId, request: {method, params}}); return promise as ReturnType; } sendMessageSync( message: SynchronousIOMessage>, method: Method, ...params: Parameters): ReturnType { const requestId = this.nextRequestId++; Atomics.store(this.semaphore, 0, 0); this.channel.postMessage({ requestId, sync_request: { request: {method, params}, io_buffer: {semaphore: this.semaphore.buffer as SharedArrayBuffer, data: message.buffer}, }, }); while (Atomics.wait(this.semaphore, 0, 0) !== 'not-equal') { // Await the semaphore to be equal } const [response] = this.semaphore; return message.deserialize(response); } private async onmessage( event: MessageEvent|Message|Response>): Promise { if ('request' in event.data) { const {requestId, request} = event.data; try { const response = await this.localHandler[request.method](...request.params); this.channel.postMessage({requestId, response}); } catch (error) { this.channel.postMessage({requestId, error: `${error}`}); } } else if ('sync_request' in event.data) { /* eslint-disable-next-line @typescript-eslint/naming-convention */ const {sync_request: {request, io_buffer}} = event.data; let signal = -1; try { const response = await this.localHandler[request.method](...request.params); signal = SynchronousIOMessage.serialize(response, io_buffer.data); } catch (error) { throw error; } finally { const semaphore = new Int32Array(io_buffer.semaphore); Atomics.store(semaphore, 0, signal); Atomics.notify(semaphore, 0); } } else { const {requestId} = event.data; const callbacks = this.requests.get(requestId); if (callbacks) { const {resolve, reject} = callbacks; if ('error' in event.data) { reject(new Error(event.data.error)); } else { resolve(event.data.response); } } } } }