From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../components/extensions/ExtensionUtils.sys.mjs | 349 +++++++++++++++++++++ 1 file changed, 349 insertions(+) create mode 100644 toolkit/components/extensions/ExtensionUtils.sys.mjs (limited to 'toolkit/components/extensions/ExtensionUtils.sys.mjs') diff --git a/toolkit/components/extensions/ExtensionUtils.sys.mjs b/toolkit/components/extensions/ExtensionUtils.sys.mjs new file mode 100644 index 0000000000..cbdf900d14 --- /dev/null +++ b/toolkit/components/extensions/ExtensionUtils.sys.mjs @@ -0,0 +1,349 @@ +/* -*- Mode: indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* vim: set sts=2 sw=2 et tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + setTimeout: "resource://gre/modules/Timer.sys.mjs", +}); + +// xpcshell doesn't handle idle callbacks well. +ChromeUtils.defineLazyGetter(lazy, "idleTimeout", () => + Services.appinfo.name === "XPCShell" ? 500 : undefined +); + +// It would be nicer to go through `Services.appinfo`, but some tests need to be +// able to replace that field with a custom implementation before it is first +// called. +// eslint-disable-next-line mozilla/use-services +const appinfo = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime); + +let nextId = 0; +const uniqueProcessID = appinfo.uniqueProcessID; +// Store the process ID in a 16 bit field left shifted to end of a +// double's mantissa. +// Note: We can't use bitwise ops here, since they truncate to a 32 bit +// integer and we need all 53 mantissa bits. +const processIDMask = (uniqueProcessID & 0xffff) * 2 ** 37; + +function getUniqueId() { + // Note: We can't use bitwise ops here, since they truncate to a 32 bit + // integer and we need all 53 mantissa bits. + return processIDMask + nextId++; +} + +function promiseTimeout(delay) { + return new Promise(resolve => lazy.setTimeout(resolve, delay)); +} + +/** + * An Error subclass for which complete error messages are always passed + * to extensions, rather than being interpreted as an unknown error. + */ +class ExtensionError extends DOMException { + constructor(message) { + super(message, "ExtensionError"); + } + // Custom JS classes can't survive IPC, so need to check error name. + static [Symbol.hasInstance](e) { + return DOMException.isInstance(e) && e.name === "ExtensionError"; + } +} + +function filterStack(error) { + return String(error.stack).replace( + /(^.*(Task\.jsm|Promise-backend\.js).*\n)+/gm, + "\n" + ); +} + +/** + * An Error subclass used to recognize the errors that should + * to be forwarded to the worker thread and being accessible + * to the extension worker script (vs. the errors that should be + * only logged internally and raised to the worker script as + * the generic unexpected error). + */ +class WorkerExtensionError extends DOMException { + constructor(message) { + super(message, "Error"); + } +} + +/** + * Similar to a WeakMap, but creates a new key with the given + * constructor if one is not present. + */ +// @ts-ignore (https://github.com/microsoft/TypeScript/issues/56664) +class DefaultWeakMap extends WeakMap { + constructor(defaultConstructor = undefined, init = undefined) { + super(init); + if (defaultConstructor) { + this.defaultConstructor = defaultConstructor; + } + } + + get(key) { + let value = super.get(key); + if (value === undefined && !this.has(key)) { + value = this.defaultConstructor(key); + this.set(key, value); + } + return value; + } +} + +class DefaultMap extends Map { + constructor(defaultConstructor = undefined, init = undefined) { + super(init); + if (defaultConstructor) { + this.defaultConstructor = defaultConstructor; + } + } + + get(key) { + let value = super.get(key); + if (value === undefined && !this.has(key)) { + value = this.defaultConstructor(key); + this.set(key, value); + } + return value; + } +} + +function getInnerWindowID(window) { + return window.windowGlobalChild?.innerWindowId; +} + +/** + * A set with a limited number of slots, which flushes older entries as + * newer ones are added. + * + * @param {integer} limit + * The maximum size to trim the set to after it grows too large. + * @param {integer} [slop = limit * .25] + * The number of extra entries to allow in the set after it + * reaches the size limit, before it is truncated to the limit. + * @param {Iterable} [iterable] + * An iterable of initial entries to add to the set. + */ +class LimitedSet extends Set { + constructor(limit, slop = Math.round(limit * 0.25), iterable = undefined) { + super(iterable); + this.limit = limit; + this.slop = slop; + } + + truncate(limit) { + for (let item of this) { + // Live set iterators can ge relatively expensive, since they need + // to be updated after every modification to the set. Since + // breaking out of the loop early will keep the iterator alive + // until the next full GC, we're currently better off finishing + // the entire loop even after we're done truncating. + if (this.size > limit) { + this.delete(item); + } + } + } + + add(item) { + if (this.size >= this.limit + this.slop && !this.has(item)) { + this.truncate(this.limit - 1); + } + return super.add(item); + } +} + +/** + * Returns a Promise which resolves when the given document's DOM has + * fully loaded. + * + * @param {Document} doc The document to await the load of. + * @returns {Promise} + */ +function promiseDocumentReady(doc) { + if (doc.readyState == "interactive" || doc.readyState == "complete") { + return Promise.resolve(doc); + } + + return new Promise(resolve => { + doc.addEventListener( + "DOMContentLoaded", + function onReady(event) { + if (event.target === event.currentTarget) { + doc.removeEventListener("DOMContentLoaded", onReady, true); + resolve(doc); + } + }, + true + ); + }); +} + +/** + * Returns a Promise which resolves when the given window's document's DOM has + * fully loaded, the stylesheets have fully loaded, and we have hit an + * idle time. + * + * @param {Window} window The window whose document we will await + the readiness of. + * @returns {Promise} + */ +function promiseDocumentIdle(window) { + return window.document.documentReadyForIdle.then(() => { + return new Promise(resolve => + window.requestIdleCallback(resolve, { timeout: lazy.idleTimeout }) + ); + }); +} + +/** + * Returns a Promise which resolves when the given document is fully + * loaded. + * + * @param {Document} doc The document to await the load of. + * @returns {Promise} + */ +function promiseDocumentLoaded(doc) { + if (doc.readyState == "complete") { + return Promise.resolve(doc); + } + + return new Promise(resolve => { + doc.defaultView.addEventListener("load", () => resolve(doc), { + once: true, + }); + }); +} + +/** + * Returns a Promise which resolves when the given event is dispatched to the + * given element. + * + * @param {Element} element + * The element on which to listen. + * @param {string} eventName + * The event to listen for. + * @param {boolean} [useCapture = true] + * If true, listen for the even in the capturing rather than + * bubbling phase. + * @param {function(Event): boolean} [test] + * An optional test function which, when called with the + * observer's subject and data, should return true if this is the + * expected event, false otherwise. + * @returns {Promise} + */ +function promiseEvent( + element, + eventName, + useCapture = true, + test = event => true +) { + return new Promise(resolve => { + function listener(event) { + if (test(event)) { + element.removeEventListener(eventName, listener, useCapture); + resolve(event); + } + } + element.addEventListener(eventName, listener, useCapture); + }); +} + +/** + * Returns a Promise which resolves the given observer topic has been + * observed. + * + * @param {string} topic + * The topic to observe. + * @param {function(any, string): boolean} [test] + * An optional test function which, when called with the + * observer's subject and data, should return true if this is the + * expected notification, false otherwise. + * @returns {Promise} + */ +function promiseObserved(topic, test = () => true) { + return new Promise(resolve => { + let observer = (subject, topic, data) => { + if (test(subject, data)) { + Services.obs.removeObserver(observer, topic); + resolve({ subject, data }); + } + }; + Services.obs.addObserver(observer, topic); + }); +} + +function getMessageManager(target) { + if (target.frameLoader) { + return target.frameLoader.messageManager; + } + return target; +} + +function flushJarCache(jarPath) { + Services.obs.notifyObservers(null, "flush-cache-entry", jarPath); +} +function parseMatchPatterns(patterns, options) { + try { + return new MatchPatternSet(patterns, options); + } catch (e) { + let pattern; + for (pattern of patterns) { + try { + new MatchPattern(pattern, options); + } catch (e) { + throw new ExtensionError(`Invalid url pattern: ${pattern}`); + } + } + // Unexpectedly MatchPatternSet threw, but MatchPattern did not. + throw e; + } +} + +/** + * Fetch icon content and convert it to a data: URI. + * + * @param {string} iconUrl Icon url to fetch. + * @returns {Promise} + */ +async function makeDataURI(iconUrl) { + let response; + try { + response = await fetch(iconUrl); + } catch (e) { + // Failed to fetch, ignore engine's favicon. + Cu.reportError(e); + return; + } + let buffer = await response.arrayBuffer(); + let contentType = response.headers.get("content-type"); + let bytes = new Uint8Array(buffer); + let str = String.fromCharCode.apply(null, bytes); + return `data:${contentType};base64,${btoa(str)}`; +} + +export var ExtensionUtils = { + flushJarCache, + getInnerWindowID, + getMessageManager, + getUniqueId, + filterStack, + makeDataURI, + parseMatchPatterns, + promiseDocumentIdle, + promiseDocumentLoaded, + promiseDocumentReady, + promiseEvent, + promiseObserved, + promiseTimeout, + DefaultMap, + DefaultWeakMap, + ExtensionError, + LimitedSet, + WorkerExtensionError, +}; -- cgit v1.2.3