mirror of
https://github.com/ksyasuda/SubMiner.git
synced 2026-02-27 18:22:41 -08:00
488 lines
15 KiB
JavaScript
488 lines
15 KiB
JavaScript
/*
|
|
* Copyright (C) 2023-2025 Yomitan Authors
|
|
* Copyright (C) 2020-2022 Yomichan Authors
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
import {extendApiMap, invokeApiMapHandler} from '../core/api-map.js';
|
|
import {EventDispatcher} from '../core/event-dispatcher.js';
|
|
import {EventListenerCollection} from '../core/event-listener-collection.js';
|
|
import {ExtensionError} from '../core/extension-error.js';
|
|
import {parseJson} from '../core/json.js';
|
|
import {log} from '../core/log.js';
|
|
import {safePerformance} from '../core/safe-performance.js';
|
|
|
|
/**
|
|
* @augments EventDispatcher<import('cross-frame-api').CrossFrameAPIPortEvents>
|
|
*/
|
|
export class CrossFrameAPIPort extends EventDispatcher {
|
|
/**
|
|
* @param {number} otherTabId
|
|
* @param {number} otherFrameId
|
|
* @param {chrome.runtime.Port} port
|
|
* @param {import('cross-frame-api').ApiMap} apiMap
|
|
*/
|
|
constructor(otherTabId, otherFrameId, port, apiMap) {
|
|
super();
|
|
/** @type {number} */
|
|
this._otherTabId = otherTabId;
|
|
/** @type {number} */
|
|
this._otherFrameId = otherFrameId;
|
|
/** @type {?chrome.runtime.Port} */
|
|
this._port = port;
|
|
/** @type {import('cross-frame-api').ApiMap} */
|
|
this._apiMap = apiMap;
|
|
/** @type {Map<number, import('cross-frame-api').Invocation>} */
|
|
this._activeInvocations = new Map();
|
|
/** @type {number} */
|
|
this._invocationId = 0;
|
|
/** @type {EventListenerCollection} */
|
|
this._eventListeners = new EventListenerCollection();
|
|
}
|
|
|
|
/** @type {number} */
|
|
get otherTabId() {
|
|
return this._otherTabId;
|
|
}
|
|
|
|
/** @type {number} */
|
|
get otherFrameId() {
|
|
return this._otherFrameId;
|
|
}
|
|
|
|
/**
|
|
* @throws {Error}
|
|
*/
|
|
prepare() {
|
|
if (this._port === null) { throw new Error('Invalid state'); }
|
|
this._eventListeners.addListener(this._port.onDisconnect, this._onDisconnect.bind(this));
|
|
this._eventListeners.addListener(this._port.onMessage, this._onMessage.bind(this));
|
|
this._eventListeners.addEventListener(window, 'pageshow', this._onPageShow.bind(this));
|
|
this._eventListeners.addEventListener(document, 'resume', this._onResume.bind(this));
|
|
}
|
|
|
|
/**
|
|
* @template {import('cross-frame-api').ApiNames} TName
|
|
* @param {TName} action
|
|
* @param {import('cross-frame-api').ApiParams<TName>} params
|
|
* @param {number} ackTimeout
|
|
* @param {number} responseTimeout
|
|
* @returns {Promise<import('cross-frame-api').ApiReturn<TName>>}
|
|
*/
|
|
invoke(action, params, ackTimeout, responseTimeout) {
|
|
return new Promise((resolve, reject) => {
|
|
if (this._port === null) {
|
|
reject(new Error(`Port is disconnected (${action})`));
|
|
return;
|
|
}
|
|
|
|
const id = this._invocationId++;
|
|
/** @type {import('cross-frame-api').Invocation} */
|
|
const invocation = {
|
|
id,
|
|
resolve,
|
|
reject,
|
|
responseTimeout,
|
|
action,
|
|
ack: false,
|
|
timer: null,
|
|
};
|
|
this._activeInvocations.set(id, invocation);
|
|
|
|
if (ackTimeout !== null) {
|
|
try {
|
|
invocation.timer = setTimeout(() => this._onError(id, 'Acknowledgement timeout'), ackTimeout);
|
|
} catch (e) {
|
|
this._onError(id, 'Failed to set timeout');
|
|
return;
|
|
}
|
|
}
|
|
safePerformance.mark(`cross-frame-api:invoke:${action}`);
|
|
try {
|
|
this._port.postMessage(/** @type {import('cross-frame-api').InvokeMessage} */ ({type: 'invoke', id, data: {action, params}}));
|
|
} catch (e) {
|
|
this._onError(id, e);
|
|
}
|
|
});
|
|
}
|
|
|
|
/** */
|
|
disconnect() {
|
|
this._onDisconnect();
|
|
}
|
|
|
|
// Private
|
|
|
|
/**
|
|
* @param {Event} e
|
|
*/
|
|
_onResume(e) {
|
|
// Page Resumed after being frozen
|
|
log.log('Yomitan cross frame reset. Resuming after page frozen.', e);
|
|
this._onDisconnect();
|
|
}
|
|
|
|
/**
|
|
* @param {PageTransitionEvent} e
|
|
*/
|
|
_onPageShow(e) {
|
|
// Page restored from BFCache
|
|
if (e.persisted) {
|
|
log.log('Yomitan cross frame reset. Page restored from BFCache.', e);
|
|
this._onDisconnect();
|
|
}
|
|
}
|
|
|
|
/** */
|
|
_onDisconnect() {
|
|
if (this._port === null) { return; }
|
|
this._eventListeners.removeAllEventListeners();
|
|
this._port = null;
|
|
for (const id of this._activeInvocations.keys()) {
|
|
this._onError(id, 'Disconnected');
|
|
}
|
|
this.trigger('disconnect', this);
|
|
}
|
|
|
|
/**
|
|
* @param {import('cross-frame-api').Message} details
|
|
*/
|
|
_onMessage(details) {
|
|
const {type, id} = details;
|
|
switch (type) {
|
|
case 'invoke':
|
|
this._onInvoke(id, details.data);
|
|
break;
|
|
case 'ack':
|
|
this._onAck(id);
|
|
break;
|
|
case 'result':
|
|
this._onResult(id, details.data);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Response handlers
|
|
|
|
/**
|
|
* @param {number} id
|
|
*/
|
|
_onAck(id) {
|
|
const invocation = this._activeInvocations.get(id);
|
|
if (typeof invocation === 'undefined') {
|
|
log.warn(new Error(`Request ${id} not found for acknowledgement`));
|
|
return;
|
|
}
|
|
|
|
if (invocation.ack) {
|
|
this._onError(id, `Request ${id} already acknowledged`);
|
|
return;
|
|
}
|
|
|
|
invocation.ack = true;
|
|
|
|
if (invocation.timer !== null) {
|
|
clearTimeout(invocation.timer);
|
|
invocation.timer = null;
|
|
}
|
|
|
|
const responseTimeout = invocation.responseTimeout;
|
|
if (responseTimeout !== null) {
|
|
try {
|
|
invocation.timer = setTimeout(() => this._onError(id, 'Response timeout'), responseTimeout);
|
|
} catch (e) {
|
|
this._onError(id, 'Failed to set timeout');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {import('core').Response<import('cross-frame-api').ApiReturnAny>} data
|
|
*/
|
|
_onResult(id, data) {
|
|
const invocation = this._activeInvocations.get(id);
|
|
if (typeof invocation === 'undefined') {
|
|
log.warn(new Error(`Request ${id} not found`));
|
|
return;
|
|
}
|
|
|
|
if (!invocation.ack) {
|
|
this._onError(id, `Request ${id} not acknowledged`);
|
|
return;
|
|
}
|
|
|
|
this._activeInvocations.delete(id);
|
|
|
|
if (invocation.timer !== null) {
|
|
clearTimeout(invocation.timer);
|
|
invocation.timer = null;
|
|
}
|
|
|
|
const error = data.error;
|
|
if (typeof error !== 'undefined') {
|
|
invocation.reject(ExtensionError.deserialize(error));
|
|
} else {
|
|
invocation.resolve(data.result);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {unknown} errorOrMessage
|
|
*/
|
|
_onError(id, errorOrMessage) {
|
|
const invocation = this._activeInvocations.get(id);
|
|
if (typeof invocation === 'undefined') { return; }
|
|
|
|
const error = errorOrMessage instanceof Error ? errorOrMessage : new Error(`${errorOrMessage} (${invocation.action})`);
|
|
|
|
this._activeInvocations.delete(id);
|
|
if (invocation.timer !== null) {
|
|
clearTimeout(invocation.timer);
|
|
invocation.timer = null;
|
|
}
|
|
invocation.reject(error);
|
|
}
|
|
|
|
// Invocation
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {import('cross-frame-api').ApiMessageAny} details
|
|
*/
|
|
_onInvoke(id, {action, params}) {
|
|
this._sendAck(id);
|
|
invokeApiMapHandler(
|
|
this._apiMap,
|
|
action,
|
|
params,
|
|
[],
|
|
(data) => this._sendResult(id, data),
|
|
() => this._sendError(id, new Error(`Unknown action: ${action}`)),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @param {import('cross-frame-api').Message} data
|
|
*/
|
|
_sendResponse(data) {
|
|
if (this._port === null) { return; }
|
|
try {
|
|
this._port.postMessage(data);
|
|
} catch (e) {
|
|
// NOP
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
*/
|
|
_sendAck(id) {
|
|
this._sendResponse({type: 'ack', id});
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {import('core').Response<import('cross-frame-api').ApiReturnAny>} data
|
|
*/
|
|
_sendResult(id, data) {
|
|
this._sendResponse({type: 'result', id, data});
|
|
}
|
|
|
|
/**
|
|
* @param {number} id
|
|
* @param {Error} error
|
|
*/
|
|
_sendError(id, error) {
|
|
this._sendResponse({type: 'result', id, data: {error: ExtensionError.serialize(error)}});
|
|
}
|
|
}
|
|
|
|
export class CrossFrameAPI {
|
|
/**
|
|
* @param {import('../comm/api.js').API} api
|
|
* @param {?number} tabId
|
|
* @param {?number} frameId
|
|
*/
|
|
constructor(api, tabId, frameId) {
|
|
/** @type {import('../comm/api.js').API} */
|
|
this._api = api;
|
|
/** @type {number} */
|
|
this._ackTimeout = 3000; // 3 seconds
|
|
/** @type {number} */
|
|
this._responseTimeout = 10000; // 10 seconds
|
|
/** @type {Map<number, Map<number, CrossFrameAPIPort>>} */
|
|
this._commPorts = new Map();
|
|
/** @type {import('cross-frame-api').ApiMap} */
|
|
this._apiMap = new Map();
|
|
/** @type {(port: CrossFrameAPIPort) => void} */
|
|
this._onDisconnectBind = this._onDisconnect.bind(this);
|
|
/** @type {?number} */
|
|
this._tabId = tabId;
|
|
/** @type {?number} */
|
|
this._frameId = frameId;
|
|
}
|
|
|
|
/**
|
|
* @type {?number}
|
|
*/
|
|
get tabId() {
|
|
return this._tabId;
|
|
}
|
|
|
|
/**
|
|
* @type {?number}
|
|
*/
|
|
get frameId() {
|
|
return this._frameId;
|
|
}
|
|
|
|
/** */
|
|
prepare() {
|
|
chrome.runtime.onConnect.addListener(this._onConnect.bind(this));
|
|
}
|
|
|
|
/**
|
|
* @template {import('cross-frame-api').ApiNames} TName
|
|
* @param {number} targetFrameId
|
|
* @param {TName} action
|
|
* @param {import('cross-frame-api').ApiParams<TName>} params
|
|
* @returns {Promise<import('cross-frame-api').ApiReturn<TName>>}
|
|
*/
|
|
invoke(targetFrameId, action, params) {
|
|
return this.invokeTab(null, targetFrameId, action, params);
|
|
}
|
|
|
|
/**
|
|
* @template {import('cross-frame-api').ApiNames} TName
|
|
* @param {?number} targetTabId
|
|
* @param {number} targetFrameId
|
|
* @param {TName} action
|
|
* @param {import('cross-frame-api').ApiParams<TName>} params
|
|
* @returns {Promise<import('cross-frame-api').ApiReturn<TName>>}
|
|
*/
|
|
async invokeTab(targetTabId, targetFrameId, action, params) {
|
|
if (typeof targetTabId !== 'number') {
|
|
targetTabId = this._tabId;
|
|
if (typeof targetTabId !== 'number') {
|
|
throw new Error('Unknown target tab id for invocation');
|
|
}
|
|
}
|
|
const commPort = await this._getOrCreateCommPort(targetTabId, targetFrameId);
|
|
return await commPort.invoke(action, params, this._ackTimeout, this._responseTimeout);
|
|
}
|
|
|
|
/**
|
|
* @param {import('cross-frame-api').ApiMapInit} handlers
|
|
*/
|
|
registerHandlers(handlers) {
|
|
extendApiMap(this._apiMap, handlers);
|
|
}
|
|
|
|
// Private
|
|
|
|
/**
|
|
* @param {chrome.runtime.Port} port
|
|
*/
|
|
_onConnect(port) {
|
|
try {
|
|
/** @type {import('cross-frame-api').PortDetails} */
|
|
let details;
|
|
try {
|
|
details = parseJson(port.name);
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
if (details.name !== 'cross-frame-communication-port') { return; }
|
|
|
|
const otherTabId = details.otherTabId;
|
|
const otherFrameId = details.otherFrameId;
|
|
this._setupCommPort(otherTabId, otherFrameId, port);
|
|
} catch (e) {
|
|
port.disconnect();
|
|
log.error(e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {CrossFrameAPIPort} commPort
|
|
*/
|
|
_onDisconnect(commPort) {
|
|
commPort.off('disconnect', this._onDisconnectBind);
|
|
const {otherTabId, otherFrameId} = commPort;
|
|
const tabPorts = this._commPorts.get(otherTabId);
|
|
if (typeof tabPorts !== 'undefined') {
|
|
tabPorts.delete(otherFrameId);
|
|
if (tabPorts.size === 0) {
|
|
this._commPorts.delete(otherTabId);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {number} otherTabId
|
|
* @param {number} otherFrameId
|
|
* @returns {Promise<CrossFrameAPIPort>}
|
|
*/
|
|
async _getOrCreateCommPort(otherTabId, otherFrameId) {
|
|
const tabPorts = this._commPorts.get(otherTabId);
|
|
if (typeof tabPorts !== 'undefined') {
|
|
const commPort = tabPorts.get(otherFrameId);
|
|
if (typeof commPort !== 'undefined') {
|
|
return commPort;
|
|
}
|
|
}
|
|
return await this._createCommPort(otherTabId, otherFrameId);
|
|
}
|
|
|
|
/**
|
|
* @param {number} otherTabId
|
|
* @param {number} otherFrameId
|
|
* @returns {Promise<CrossFrameAPIPort>}
|
|
*/
|
|
async _createCommPort(otherTabId, otherFrameId) {
|
|
await this._api.openCrossFramePort(otherTabId, otherFrameId);
|
|
|
|
const tabPorts = this._commPorts.get(otherTabId);
|
|
if (typeof tabPorts !== 'undefined') {
|
|
const commPort = tabPorts.get(otherFrameId);
|
|
if (typeof commPort !== 'undefined') {
|
|
return commPort;
|
|
}
|
|
}
|
|
throw new Error('Comm port didn\'t open');
|
|
}
|
|
|
|
/**
|
|
* @param {number} otherTabId
|
|
* @param {number} otherFrameId
|
|
* @param {chrome.runtime.Port} port
|
|
* @returns {CrossFrameAPIPort}
|
|
*/
|
|
_setupCommPort(otherTabId, otherFrameId, port) {
|
|
const commPort = new CrossFrameAPIPort(otherTabId, otherFrameId, port, this._apiMap);
|
|
let tabPorts = this._commPorts.get(otherTabId);
|
|
if (typeof tabPorts === 'undefined') {
|
|
tabPorts = new Map();
|
|
this._commPorts.set(otherTabId, tabPorts);
|
|
}
|
|
tabPorts.set(otherFrameId, commPort);
|
|
commPort.prepare();
|
|
commPort.on('disconnect', this._onDisconnectBind);
|
|
return commPort;
|
|
}
|
|
}
|