diff options
Diffstat (limited to 'toolkit/components/workerloader')
18 files changed, 680 insertions, 0 deletions
diff --git a/toolkit/components/workerloader/moz.build b/toolkit/components/workerloader/moz.build new file mode 100644 index 0000000000..8e20e1d61b --- /dev/null +++ b/toolkit/components/workerloader/moz.build @@ -0,0 +1,12 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +MOCHITEST_CHROME_MANIFESTS += ["tests/chrome.toml"] + +EXTRA_JS_MODULES.workers += ["require.js"] + +with Files("**"): + BUG_COMPONENT = ("Toolkit", "Async Tooling") diff --git a/toolkit/components/workerloader/require.js b/toolkit/components/workerloader/require.js new file mode 100644 index 0000000000..246c4a1884 --- /dev/null +++ b/toolkit/components/workerloader/require.js @@ -0,0 +1,182 @@ +/* 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/. */ + +/** + * Implementation of a CommonJS module loader for workers. + * + * Use: + * // in the .js file loaded by the constructor of the worker + * importScripts("resource://gre/modules/workers/require.js"); + * let module = require("resource://gre/modules/worker/myModule.js"); + * + * // in myModule.js + * // Load dependencies + * let SimpleTest = require("resource://gre/modules/workers/SimpleTest.js"); + * let Logger = require("resource://gre/modules/workers/Logger.js"); + * + * // Define things that will not be exported + * let someValue = // ... + * + * // Export symbols + * exports.foo = // ... + * exports.bar = // ... + * + * + * Note #1: + * Properties |fileName| and |stack| of errors triggered from a module + * contain file names that do not correspond to human-readable module paths. + * Human readers should rather use properties |moduleName| and |moduleStack|. + * + * Note #2: + * By opposition to some other module loader implementations, this module + * loader does not enforce separation of global objects. Consequently, if + * a module modifies a global object (e.g. |String.prototype|), all other + * modules in the same worker may be affected. + */ + +/* global require */ +/* exported require */ + +(function (exports) { + "use strict"; + + if (exports.require) { + // Avoid double-imports + return; + } + + // Simple implementation of |require| + let require = (function () { + /** + * Mapping from module URI to module exports. + * + * @keys {string} The absolute URI to a module. + * @values {object} The |exports| objects for that module. + */ + let modules = new Map(); + + /** + * A human-readable version of |stack|. + * + * @type {string} + */ + Object.defineProperty(Error.prototype, "moduleStack", { + get() { + return this.stack; + }, + }); + /** + * A human-readable version of |fileName|. + * + * @type {string} + */ + Object.defineProperty(Error.prototype, "moduleName", { + get() { + let match = this.stack.match(/\@(.*):.*:/); + if (match) { + return match[1]; + } + return "(unknown module)"; + }, + }); + + /** + * Import a module + * + * @param {string} baseURL The URL of the modules from which we load a new module. + * This will be null for the first loaded module and so expect an absolute URI in path. + * Note that this first parameter is bound before `require` method is passed outside + * of this module. So that typical callsites will only path the second `path` parameter. + * @param {string} path The path to the module. + * @return {*} An object containing the properties exported by the module. + */ + return function require(baseURL, path) { + let startTime = performance.now(); + if (typeof path != "string") { + throw new TypeError( + "The argument to require() must be a string got " + path + ); + } + + // Resolve relative paths + if ((path.startsWith("./") || path.startsWith("../")) && baseURL) { + path = new URL(path, baseURL).href; + } + + if (!path.includes("://")) { + throw new TypeError( + "The argument to require() must be a string uri, got " + path + ); + } + // Automatically add ".js" if there is no extension + let uri; + if (path.lastIndexOf(".") <= path.lastIndexOf("/")) { + uri = path + ".js"; + } else { + uri = path; + } + + // Exports provided by the module + let exports = Object.create(null); + + // Identification of the module + let module = { + id: path, + uri, + exports, + }; + + // Make module available immediately + // (necessary in case of circular dependencies) + if (modules.has(uri)) { + return modules.get(uri).exports; + } + modules.set(uri, module); + + try { + // Load source of module, synchronously + let xhr = new XMLHttpRequest(); + xhr.open("GET", uri, false); + xhr.responseType = "text"; + xhr.send(); + + let source = xhr.responseText; + if (source == "") { + // There doesn't seem to be a better way to detect that the file couldn't be found + throw new Error("Could not find module " + path); + } + // Use `Function` to leave this scope, use `eval` to start the line + // number from 1 that is observed by `source` and the error message + // thrown from the module, and also use `arguments` for accessing + // `source` and `uri` to avoid polluting the module's environment. + let code = new Function( + "exports", + "require", + "module", + `eval(arguments[3] + "\\n//# sourceURL=" + arguments[4] + "\\n")` + ); + code(exports, require.bind(null, path), module, source, uri); + } catch (ex) { + // Module loading has failed, exports should not be made available + // after all. + modules.delete(uri); + throw ex; + } finally { + ChromeUtils.addProfilerMarker("require", startTime, path); + } + + Object.freeze(module.exports); + Object.freeze(module); + return module.exports; + }; + })(); + + Object.freeze(require); + + Object.defineProperty(exports, "require", { + value: require.bind(null, null), + enumerable: true, + configurable: false, + }); +})(this); diff --git a/toolkit/components/workerloader/tests/chrome.toml b/toolkit/components/workerloader/tests/chrome.toml new file mode 100644 index 0000000000..653491e05c --- /dev/null +++ b/toolkit/components/workerloader/tests/chrome.toml @@ -0,0 +1,18 @@ +[DEFAULT] +support-files = [ + "moduleA-depends.js", + "moduleB-dependency.js", + "moduleC-circular.js", + "moduleD-circular.js", + "moduleE-throws-during-require.js", + "moduleF-syntax-error.js", + "moduleG-throws-later.js", + "moduleH-module-dot-exports.js", + "moduleI-depends.js", + "moduleJ-dependency.js", + "utils_mainthread.js", + "utils_worker.js", + "worker_test_loading.js", +] + +["test_loading.xhtml"] diff --git a/toolkit/components/workerloader/tests/moduleA-depends.js b/toolkit/components/workerloader/tests/moduleA-depends.js new file mode 100644 index 0000000000..0b531b399c --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleA-depends.js @@ -0,0 +1,16 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// A trivial module that depends on an equally trivial module +var B = require("chrome://mochitests/content/chrome/toolkit/components/workerloader/tests/moduleB-dependency.js"); + +// Ensure that the initial set of exports is empty +if (Object.keys(exports).length) { + throw new Error("exports should be empty, initially"); +} + +// Export some values +exports.A = true; +exports.importedFoo = B.foo; diff --git a/toolkit/components/workerloader/tests/moduleB-dependency.js b/toolkit/components/workerloader/tests/moduleB-dependency.js new file mode 100644 index 0000000000..e8c8549bd5 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleB-dependency.js @@ -0,0 +1,13 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +exports.B = true; +exports.foo = "foo"; + +// Side-effect to detect if we attempt to re-execute this module. +if ("loadedB" in self) { + throw new Error("B has been evaluted twice"); +} +self.loadedB = true; diff --git a/toolkit/components/workerloader/tests/moduleC-circular.js b/toolkit/components/workerloader/tests/moduleC-circular.js new file mode 100644 index 0000000000..103c20b05c --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleC-circular.js @@ -0,0 +1,20 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// Module C and module D have circular dependencies. +// This should not prevent from loading them. + +// This value is set before any circular dependency, it should be visible +// in D. +exports.enteredC = true; + +var D = require("chrome://mochitests/content/chrome/toolkit/components/workerloader/tests/moduleD-circular.js"); + +// The following values are set after importing D. +// copiedFromD.copiedFromC should have only one field |enteredC| +exports.copiedFromD = JSON.parse(JSON.stringify(D)); +// exportedFromD.copiedFromC should have all the fields defined in |exports| +exports.exportedFromD = D; +exports.finishedC = true; diff --git a/toolkit/components/workerloader/tests/moduleD-circular.js b/toolkit/components/workerloader/tests/moduleD-circular.js new file mode 100644 index 0000000000..a84b99ac37 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleD-circular.js @@ -0,0 +1,13 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// Module C and module D have circular dependencies. +// This should not prevent from loading them. + +exports.enteredD = true; +var C = require("chrome://mochitests/content/chrome/toolkit/components/workerloader/tests/moduleC-circular.js"); +exports.copiedFromC = JSON.parse(JSON.stringify(C)); +exports.exportedFromC = C; +exports.finishedD = true; diff --git a/toolkit/components/workerloader/tests/moduleE-throws-during-require.js b/toolkit/components/workerloader/tests/moduleE-throws-during-require.js new file mode 100644 index 0000000000..deafc3faa2 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleE-throws-during-require.js @@ -0,0 +1,12 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// Skip a few lines +// 7 +// 8 +// 9 +// 10 +// 11 +throw new Error("Let's see if this error is obtained with the right origin"); diff --git a/toolkit/components/workerloader/tests/moduleF-syntax-error.js b/toolkit/components/workerloader/tests/moduleF-syntax-error.js new file mode 100644 index 0000000000..c03fa32f8a --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleF-syntax-error.js @@ -0,0 +1,6 @@ +<!-- +Any copyright is dedicated to the Public Domain. +http://creativecommons.org/publicdomain/zero/1.0/ +--> +<?xml version="1.0" encoding="UTF-8" ?> +<foo>Anything that doesn't parse as JavaScript</foo> diff --git a/toolkit/components/workerloader/tests/moduleG-throws-later.js b/toolkit/components/workerloader/tests/moduleG-throws-later.js new file mode 100644 index 0000000000..21abe36c95 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleG-throws-later.js @@ -0,0 +1,14 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// Skip a few lines +// 7 +// 8 +// 9 +// 10 +// 11 +exports.doThrow = function doThrow() { + Array.prototype.sort.apply("foo"); // This will raise a native TypeError +}; diff --git a/toolkit/components/workerloader/tests/moduleH-module-dot-exports.js b/toolkit/components/workerloader/tests/moduleH-module-dot-exports.js new file mode 100644 index 0000000000..953b229d47 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleH-module-dot-exports.js @@ -0,0 +1,14 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// This should be overwritten by module.exports +exports.key = "wrong value"; + +module.exports = { + key: "value", +}; + +// This should also be overwritten by module.exports +exports.key = "another wrong value"; diff --git a/toolkit/components/workerloader/tests/moduleI-depends.js b/toolkit/components/workerloader/tests/moduleI-depends.js new file mode 100644 index 0000000000..7d251305e7 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleI-depends.js @@ -0,0 +1,16 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +// I trivial module that depends on an equally trivial module +var J = require("./moduleJ-dependency.js"); + +// Ensure that the initial set of exports is empty +if (Object.keys(exports).length) { + throw new Error("exports should be empty, initially"); +} + +// Export some values +exports.I = true; +exports.importedFoo = J.foo; diff --git a/toolkit/components/workerloader/tests/moduleJ-dependency.js b/toolkit/components/workerloader/tests/moduleJ-dependency.js new file mode 100644 index 0000000000..53114f4fd6 --- /dev/null +++ b/toolkit/components/workerloader/tests/moduleJ-dependency.js @@ -0,0 +1,13 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env commonjs */ + +exports.J = true; +exports.foo = "foo"; + +// Side-effect to detect if we attempt to re-execute this module. +if ("loadedJ" in self) { + throw new Error("J has been evaluted twice"); +} +self.loadedJ = true; diff --git a/toolkit/components/workerloader/tests/test_loading.xhtml b/toolkit/components/workerloader/tests/test_loading.xhtml new file mode 100644 index 0000000000..0301eeb294 --- /dev/null +++ b/toolkit/components/workerloader/tests/test_loading.xhtml @@ -0,0 +1,39 @@ +<?xml version="1.0"?> +<!-- + Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ +--> +<window title="Testing the worker loader" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + onload="test();"> + + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/> + <script src="chrome://mochikit/content/tests/SimpleTest/EventUtils.js"/> + <script type="application/javascript" + src="utils_mainthread.js"/> + <script type="application/javascript"> + <![CDATA[ + +let worker; +let main = this; + +function test() { + info("Starting test " + document.uri); + + worker = new ChromeWorker("worker_test_loading.js"); + SimpleTest.waitForExplicitFinish(); + info("Chrome worker created"); + worker_handler(worker); + worker.postMessage(document.uri); + ok(true, "Test in progress"); +}; +]]> + </script> + + <body xmlns="http://www.w3.org/1999/xhtml"> + <p id="display"></p> + <div id="content" style="display:none;"></div> + <pre id="test"></pre> + </body> + <label id="test-result"/> +</window> diff --git a/toolkit/components/workerloader/tests/utils_mainthread.js b/toolkit/components/workerloader/tests/utils_mainthread.js new file mode 100644 index 0000000000..6a3891b6fc --- /dev/null +++ b/toolkit/components/workerloader/tests/utils_mainthread.js @@ -0,0 +1,40 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function worker_handler(worker) { + worker.onerror = function (error) { + error.preventDefault(); + ok(false, "error " + error.message); + }; + worker.onmessage = function (msg) { + // ok(true, "MAIN: onmessage " + JSON.stringify(msg.data)); + switch (msg.data.kind) { + case "is": + SimpleTest.ok( + msg.data.outcome, + msg.data.description + "( " + msg.data.a + " ==? " + msg.data.b + ")" + ); + return; + case "isnot": + SimpleTest.ok( + msg.data.outcome, + msg.data.description + "( " + msg.data.a + " !=? " + msg.data.b + ")" + ); + return; + case "ok": + SimpleTest.ok(msg.data.condition, msg.data.description); + return; + case "info": + SimpleTest.info(msg.data.description); + return; + case "finish": + SimpleTest.finish(); + return; + default: + SimpleTest.ok( + false, + "test_osfile.xul: wrong message " + JSON.stringify(msg.data) + ); + } + }; +} diff --git a/toolkit/components/workerloader/tests/utils_worker.js b/toolkit/components/workerloader/tests/utils_worker.js new file mode 100644 index 0000000000..ce4848d7af --- /dev/null +++ b/toolkit/components/workerloader/tests/utils_worker.js @@ -0,0 +1,44 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function log(text) { + dump("WORKER " + text + "\n"); +} + +function send(message) { + self.postMessage(message); +} + +function finish() { + send({ kind: "finish" }); +} + +function ok(condition, description) { + send({ kind: "ok", condition: !!condition, description: "" + description }); +} + +function is(a, b, description) { + let outcome = a == b; // Need to decide outcome here, as not everything can be serialized + send({ + kind: "is", + outcome, + description: "" + description, + a: "" + a, + b: "" + b, + }); +} + +function isnot(a, b, description) { + let outcome = a != b; // Need to decide outcome here, as not everything can be serialized + send({ + kind: "isnot", + outcome, + description: "" + description, + a: "" + a, + b: "" + b, + }); +} + +function info(description) { + send({ kind: "info", description: "" + description }); +} diff --git a/toolkit/components/workerloader/tests/worker_handler.js b/toolkit/components/workerloader/tests/worker_handler.js new file mode 100644 index 0000000000..f8154f421e --- /dev/null +++ b/toolkit/components/workerloader/tests/worker_handler.js @@ -0,0 +1,40 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +function worker_handler(worker) { + worker.onerror = function (error) { + error.preventDefault(); + ok(false, "error " + error); + }; + worker.onmessage = function (msg) { + ok(true, "MAIN: onmessage " + JSON.stringify(msg.data)); + switch (msg.data.kind) { + case "is": + SimpleTest.ok( + msg.data.outcome, + msg.data.description + "( " + msg.data.a + " ==? " + msg.data.b + ")" + ); + return; + case "isnot": + SimpleTest.ok( + msg.data.outcome, + msg.data.description + "( " + msg.data.a + " !=? " + msg.data.b + ")" + ); + return; + case "ok": + SimpleTest.ok(msg.data.condition, msg.data.description); + return; + case "info": + SimpleTest.info(msg.data.description); + return; + case "finish": + SimpleTest.finish(); + return; + default: + SimpleTest.ok( + false, + "test_osfile.xul: wrong message " + JSON.stringify(msg.data) + ); + } + }; +} diff --git a/toolkit/components/workerloader/tests/worker_test_loading.js b/toolkit/components/workerloader/tests/worker_test_loading.js new file mode 100644 index 0000000000..551c56d7d3 --- /dev/null +++ b/toolkit/components/workerloader/tests/worker_test_loading.js @@ -0,0 +1,168 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* eslint-env worker */ + +"use strict"; + +importScripts("utils_worker.js"); // Test suite code +info("Test suite configured"); + +/* import-globals-from /toolkit/components/workerloader/require.js */ +importScripts("resource://gre/modules/workers/require.js"); +info("Loader imported"); + +var PATH = + "chrome://mochitests/content/chrome/toolkit/components/workerloader/tests/"; +var tests = []; +var add_test = function (test) { + tests.push(test); +}; + +add_test(function test_setup() { + ok(typeof require != "undefined", "Function |require| is defined"); +}); + +// Test simple loading (moduleA-depends.js requires moduleB-dependency.js) +add_test(function test_load() { + let A = require(PATH + "moduleA-depends.js"); + ok(true, "Opened module A"); + + is(A.A, true, "Module A exported value A"); + ok(!("B" in A), "Module A did not export value B"); + is(A.importedFoo, "foo", "Module A re-exported B.foo"); + + // re-evaluating moduleB-dependency.js would cause an error, but re-requiring it shouldn't + let B = require(PATH + "moduleB-dependency.js"); + ok(true, "Managed to re-require module B"); + is(B.B, true, "Module B exported value B"); + is(B.foo, "foo", "Module B exported value foo"); +}); + +// Test simple circular loading (moduleC-circular.js and moduleD-circular.js require each other) +add_test(function test_circular() { + let C = require(PATH + "moduleC-circular.js"); + ok(true, "Loaded circular modules C and D"); + is( + C.copiedFromD.copiedFromC.enteredC, + true, + "Properties exported by C before requiring D can be seen by D immediately" + ); + + let D = require(PATH + "moduleD-circular.js"); + is( + D.exportedFromC.finishedC, + true, + "Properties exported by C after requiring D can be seen by D eventually" + ); +}); + +// Testing error cases +add_test(function test_exceptions() { + let should_throw = function (f) { + try { + f(); + return null; + } catch (ex) { + return ex; + } + }; + + let exn = should_throw(() => require(PATH + "this module doesn't exist")); + ok(!!exn, "Attempting to load a module that doesn't exist raises an error"); + + exn = should_throw(() => require(PATH + "moduleE-throws-during-require.js")); + ok( + !!exn, + "Attempting to load a module that throws at toplevel raises an error" + ); + is( + exn.moduleName, + PATH + "moduleE-throws-during-require.js", + "moduleName is correct" + ); + isnot( + exn.moduleStack.indexOf("moduleE-throws-during-require.js"), + -1, + "moduleStack contains the name of the module" + ); + is(exn.lineNumber, 12, "The error comes with the right line number"); + + exn = should_throw(() => require(PATH + "moduleF-syntaxerror.xml")); + ok(!!exn, "Attempting to load a non-well formatted module raises an error"); + + exn = should_throw(() => require(PATH + "moduleG-throws-later.js").doThrow()); + ok(!!exn, "G.doThrow() has raised an error"); + info(exn); + ok(exn.toString().startsWith("TypeError"), "The exception is a TypeError."); + is( + exn.moduleName, + PATH + "moduleG-throws-later.js", + "The name of the module is correct" + ); + isnot( + exn.moduleStack.indexOf("moduleG-throws-later.js"), + -1, + "The name of the right file appears somewhere in the stack" + ); + is(exn.lineNumber, 13, "The error comes with the right line number"); +}); + +function get_exn(f) { + try { + f(); + return undefined; + } catch (ex) { + return ex; + } +} + +// Test module.exports +add_test(function test_module_dot_exports() { + let H = require(PATH + "moduleH-module-dot-exports.js"); + is(H.key, "value", "module.exports worked"); + let H2 = require(PATH + "moduleH-module-dot-exports.js"); + is(H2.key, "value", "module.exports returned the same key"); + ok(H2 === H, "module.exports returned the same module the second time"); + let exn = get_exn(() => (H.key = "this should not be accepted")); + ok( + exn instanceof TypeError, + "Cannot alter value in module.exports after export" + ); + exn = get_exn(() => (H.key2 = "this should not be accepted, either")); + ok( + exn instanceof TypeError, + "Cannot add value to module.exports after export" + ); +}); + +// Test relative imports (moduleI-depends.js requires moduleJ-dependency.js) +add_test(function test_load() { + let I = require(PATH + "moduleI-depends.js"); + ok(true, "Opened module I"); + + is(I.I, true, "Module I exported value I"); + ok(!("J" in I), "Module I did not export value J"); + is(I.importedFoo, "foo", "Module I re-exported J.foo"); + + // re-evaluating moduleJ-dependency.js would cause an error, but re-requiring it shouldn't + let J = require(PATH + "moduleJ-dependency.js"); + ok(true, "Managed to re-require module J"); + is(J.J, true, "Module J exported value J"); + is(J.foo, "foo", "Module J exported value foo"); +}); + +self.onmessage = function (message) { + for (let test of tests) { + info("Entering " + test.name); + try { + test(); + } catch (ex) { + ok(false, "Test " + test.name + " failed"); + info(ex); + info(ex.stack); + } + info("Leaving " + test.name); + } + finish(); +}; |