Source code

Revision control

Other Tools

/* 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/. */
"use strict";
var EXPORTED_SYMBOLS = ["SpecialPowersParent"];
const { AppConstants } = ChromeUtils.import(
);
var { XPCOMUtils } = ChromeUtils.import(
);
var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
XPCOMUtils.defineLazyModuleGetters(this, {
});
class SpecialPowersError extends Error {
get name() {
return "SpecialPowersError";
}
}
function getTestPlugin(pluginName) {
var ph = Cc["@mozilla.org/plugin/host;1"].getService(Ci.nsIPluginHost);
var tags = ph.getPluginTags();
var name = pluginName || "Test Plug-in";
for (var tag of tags) {
if (tag.name == name) {
return tag;
}
}
return null;
}
const PREF_TYPES = {
[Ci.nsIPrefBranch.PREF_INVALID]: "INVALID",
[Ci.nsIPrefBranch.PREF_INT]: "INT",
[Ci.nsIPrefBranch.PREF_BOOL]: "BOOL",
[Ci.nsIPrefBranch.PREF_STRING]: "CHAR",
number: "INT",
boolean: "BOOL",
string: "CHAR",
};
// We share a single preference environment stack between all
// SpecialPowers instances, across all processes.
let prefUndoStack = [];
let inPrefEnvOp = false;
let permissionUndoStack = [];
function doPrefEnvOp(fn) {
if (inPrefEnvOp) {
throw new Error(
"Reentrant preference environment operations not supported"
);
}
inPrefEnvOp = true;
try {
return fn();
} finally {
inPrefEnvOp = false;
}
}
async function createWindowlessBrowser({ isPrivate = false } = {}) {
const {
promiseDocumentLoaded,
promiseEvent,
promiseObserved,
} = ChromeUtils.import(
).ExtensionUtils;
let windowlessBrowser = Services.appShell.createWindowlessBrowser(true);
if (isPrivate) {
let loadContext = windowlessBrowser.docShell.QueryInterface(
Ci.nsILoadContext
);
loadContext.usePrivateBrowsing = true;
}
let chromeShell = windowlessBrowser.docShell.QueryInterface(
Ci.nsIWebNavigation
);
const system = Services.scriptSecurityManager.getSystemPrincipal();
chromeShell.createAboutBlankContentViewer(system, system);
windowlessBrowser.browsingContext.useGlobalHistory = false;
chromeShell.loadURI("chrome://extensions/content/dummy.xhtml", {
triggeringPrincipal: system,
});
await promiseObserved(
"chrome-document-global-created",
win => win.document == chromeShell.document
);
let chromeDoc = await promiseDocumentLoaded(chromeShell.document);
let browser = chromeDoc.createXULElement("browser");
browser.setAttribute("type", "content");
browser.setAttribute("disableglobalhistory", "true");
browser.setAttribute("remote", "true");
let promise = promiseEvent(browser, "XULFrameLoaderCreated");
chromeDoc.documentElement.appendChild(browser);
await promise;
return { windowlessBrowser, browser };
}
// Supplies the unique IDs for tasks created by SpecialPowers.spawn(),
// used to bounce assertion messages back down to the correct child.
let nextTaskID = 1;
// The default actor to send assertions to if a task originated in a
// window without a test harness.
let defaultAssertHandler;
class SpecialPowersParent extends JSWindowActorParent {
constructor() {
super();
this._messageManager = Services.mm;
this._serviceWorkerListener = null;
this._observer = this.observe.bind(this);
this.didDestroy = this.uninit.bind(this);
this._registerObservers = {
_self: this,
_topics: [],
_add(topic) {
if (!this._topics.includes(topic)) {
this._topics.push(topic);
Services.obs.addObserver(this, topic);
}
},
observe(aSubject, aTopic, aData) {
var msg = { aData };
switch (aTopic) {
case "csp-on-violate-policy":
// the subject is either an nsIURI or an nsISupportsCString
let subject = null;
if (aSubject instanceof Ci.nsIURI) {
subject = aSubject.asciiSpec;
} else if (aSubject instanceof Ci.nsISupportsCString) {
subject = aSubject.data;
} else {
throw new Error("Subject must be nsIURI or nsISupportsCString");
}
msg = {
subject,
data: aData,
};
this._self.sendAsyncMessage("specialpowers-" + aTopic, msg);
return;
case "xfo-on-violate-policy":
let uriSpec = null;
if (aSubject instanceof Ci.nsIURI) {
uriSpec = aSubject.asciiSpec;
} else {
throw new Error("Subject must be nsIURI");
}
msg = {
subject: uriSpec,
data: aData,
};
this._self.sendAsyncMessage("specialpowers-" + aTopic, msg);
return;
default:
this._self.sendAsyncMessage("specialpowers-" + aTopic, msg);
}
},
};
this.init();
this._crashDumpDir = null;
this._processCrashObserversRegistered = false;
this._chromeScriptListeners = [];
this._extensions = new Map();
this._taskActors = new Map();
}
init() {
Services.obs.addObserver(this._observer, "http-on-modify-request");
// We would like to check that tests don't leave service workers around
// after they finish, but that information lives in the parent process.
// Ideally, we'd be able to tell the child processes whenever service
// workers are registered or unregistered so they would know at all times,
// but service worker lifetimes are complicated enough to make that
// difficult. For the time being, let the child process know when a test
// registers a service worker so it can ask, synchronously, at the end if
// the service worker had unregister called on it.
let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
Ci.nsIServiceWorkerManager
);
let self = this;
this._serviceWorkerListener = {
onRegister() {
self.onRegister();
},
onUnregister() {
// no-op
},
};
swm.addListener(this._serviceWorkerListener);
}
uninit() {
if (defaultAssertHandler === this) {
defaultAssertHandler = null;
}
var obs = Services.obs;
obs.removeObserver(this._observer, "http-on-modify-request");
this._registerObservers._topics.splice(0).forEach(element => {
obs.removeObserver(this._registerObservers, element);
});
this._removeProcessCrashObservers();
let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
Ci.nsIServiceWorkerManager
);
swm.removeListener(this._serviceWorkerListener);
}
observe(aSubject, aTopic, aData) {
function addDumpIDToMessage(propertyName) {
try {
var id = aSubject.getPropertyAsAString(propertyName);
} catch (ex) {
id = null;
}
if (id) {
message.dumpIDs.push({ id, extension: "dmp" });
message.dumpIDs.push({ id, extension: "extra" });
}
}
switch (aTopic) {
case "http-on-modify-request":
if (aSubject instanceof Ci.nsIChannel) {
let uri = aSubject.URI.spec;
this.sendAsyncMessage("specialpowers-http-notify-request", { uri });
}
break;
case "plugin-crashed":
case "ipc:content-shutdown":
var message = { type: "crash-observed", dumpIDs: [] };
aSubject = aSubject.QueryInterface(Ci.nsIPropertyBag2);
if (aTopic == "plugin-crashed") {
addDumpIDToMessage("pluginDumpID");
let pluginID = aSubject.getPropertyAsAString("pluginDumpID");
let additionalMinidumps = aSubject.getPropertyAsACString(
"additionalMinidumps"
);
if (additionalMinidumps.length != 0) {
let dumpNames = additionalMinidumps.split(",");
for (let name of dumpNames) {
message.dumpIDs.push({
id: pluginID + "-" + name,
extension: "dmp",
});
}
}
} else {
// ipc:content-shutdown
if (!aSubject.hasKey("abnormal")) {
return; // This is a normal shutdown, ignore it
}
addDumpIDToMessage("dumpID");
}
this.sendAsyncMessage("SPProcessCrashService", message);
break;
}
}
_getCrashDumpDir() {
if (!this._crashDumpDir) {
this._crashDumpDir = Services.dirsvc.get("ProfD", Ci.nsIFile);
this._crashDumpDir.append("minidumps");
}
return this._crashDumpDir;
}
_getPendingCrashDumpDir() {
if (!this._pendingCrashDumpDir) {
this._pendingCrashDumpDir = Services.dirsvc.get("UAppData", Ci.nsIFile);
this._pendingCrashDumpDir.append("Crash Reports");
this._pendingCrashDumpDir.append("pending");
}
return this._pendingCrashDumpDir;
}
_deleteCrashDumpFiles(aFilenames) {
var crashDumpDir = this._getCrashDumpDir();
if (!crashDumpDir.exists()) {
return false;
}
var success = aFilenames.length != 0;
aFilenames.forEach(function(crashFilename) {
var file = crashDumpDir.clone();
file.append(crashFilename);
if (file.exists()) {
file.remove(false);
} else {
success = false;
}
});
return success;
}
_findCrashDumpFiles(aToIgnore) {
var crashDumpDir = this._getCrashDumpDir();
var entries = crashDumpDir.exists() && crashDumpDir.directoryEntries;
if (!entries) {
return [];
}
var crashDumpFiles = [];
while (entries.hasMoreElements()) {
var file = entries.nextFile;
var path = String(file.path);
if (path.match(/\.(dmp|extra)$/) && !aToIgnore[path]) {
crashDumpFiles.push(path);
}
}
return crashDumpFiles.concat();
}
_deletePendingCrashDumpFiles() {
var crashDumpDir = this._getPendingCrashDumpDir();
var removed = false;
if (crashDumpDir.exists()) {
let entries = crashDumpDir.directoryEntries;
while (entries.hasMoreElements()) {
let file = entries.nextFile;
if (file.isFile()) {
file.remove(false);
removed = true;
}
}
}
return removed;
}
_addProcessCrashObservers() {
if (this._processCrashObserversRegistered) {
return;
}
Services.obs.addObserver(this._observer, "plugin-crashed");
Services.obs.addObserver(this._observer, "ipc:content-shutdown");
this._processCrashObserversRegistered = true;
}
_removeProcessCrashObservers() {
if (!this._processCrashObserversRegistered) {
return;
}
Services.obs.removeObserver(this._observer, "plugin-crashed");
Services.obs.removeObserver(this._observer, "ipc:content-shutdown");
this._processCrashObserversRegistered = false;
}
onRegister() {
this.sendAsyncMessage("SPServiceWorkerRegistered", { registered: true });
}
_getURI(url) {
return Services.io.newURI(url);
}
_notifyCategoryAndObservers(subject, topic, data) {
const serviceMarker = "service,";
// First create observers from the category manager.
let observers = [];
for (let { value: contractID } of Services.catMan.enumerateCategory(
topic
)) {
let factoryFunction;
if (contractID.substring(0, serviceMarker.length) == serviceMarker) {
contractID = contractID.substring(serviceMarker.length);
factoryFunction = "getService";
} else {
factoryFunction = "createInstance";
}
try {
let handler = Cc[contractID][factoryFunction]();
if (handler) {
let observer = handler.QueryInterface(Ci.nsIObserver);
observers.push(observer);
}
} catch (e) {}
}
// Next enumerate the registered observers.
for (let observer of Services.obs.enumerateObservers(topic)) {
if (observer instanceof Ci.nsIObserver && !observers.includes(observer)) {
observers.push(observer);
}
}
observers.forEach(function(observer) {
try {
observer.observe(subject, topic, data);
} catch (e) {}
});
}
/*
Iterate through one atomic set of pref actions and perform sets/clears as appropriate.
All actions performed must modify the relevant pref.
*/
_applyPrefs(actions) {
for (let pref of actions) {
if (pref.action == "set") {
this._setPref(pref.name, pref.type, pref.value, pref.iid);
} else if (pref.action == "clear") {
Services.prefs.clearUserPref(pref.name);
}
}
}
/**
* Take in a list of pref changes to make, pushes their current values
* onto the restore stack, and makes the changes. When the test
* finishes, these changes are reverted.
*
* |inPrefs| must be an object with up to two properties: "set" and "clear".
* pushPrefEnv will set prefs as indicated in |inPrefs.set| and will unset
* the prefs indicated in |inPrefs.clear|.
*
* For example, you might pass |inPrefs| as:
*
* inPrefs = {'set': [['foo.bar', 2], ['magic.pref', 'baz']],
* 'clear': [['clear.this'], ['also.this']] };
*
* Notice that |set| and |clear| are both an array of arrays. In |set|, each
* of the inner arrays must have the form [pref_name, value] or [pref_name,
* value, iid]. (The latter form is used for prefs with "complex" values.)
*
* In |clear|, each inner array should have the form [pref_name].
*
* If you set the same pref more than once (or both set and clear a pref),
* the behavior of this method is undefined.
*/
pushPrefEnv(inPrefs) {
return doPrefEnvOp(() => {
let pendingActions = [];
let cleanupActions = [];
for (let [action, prefs] of Object.entries(inPrefs)) {
for (let pref of prefs) {
let name = pref[0];
let value = null;
let iid = null;
let type = PREF_TYPES[Services.prefs.getPrefType(name)];
let originalValue = null;
if (pref.length == 3) {
value = pref[1];
iid = pref[2];
} else if (pref.length == 2) {
value = pref[1];
}
/* If pref is not found or invalid it doesn't exist. */
if (type !== "INVALID") {
if (
(Services.prefs.prefHasUserValue(name) && action == "clear") ||
action == "set"
) {
originalValue = this._getPref(name, type);
}
} else if (action == "set") {
/* name doesn't exist, so 'clear' is pointless */
if (iid) {
type = "COMPLEX";
}
}
if (type === "INVALID") {
type = PREF_TYPES[typeof value];
}
if (type === "INVALID") {
throw new Error("Unexpected preference type");
}
pendingActions.push({ action, type, name, value, iid });
/* Push original preference value or clear into cleanup array */
var cleanupTodo = { type, name, value: originalValue, iid };
if (originalValue == null) {
cleanupTodo.action = "clear";
} else {
cleanupTodo.action = "set";
}
cleanupActions.push(cleanupTodo);
}
}
prefUndoStack.push(cleanupActions);
this._applyPrefs(pendingActions);
});
}
async popPrefEnv() {
return doPrefEnvOp(() => {
let env = prefUndoStack.pop();
if (env) {
this._applyPrefs(env);
return true;
}
return false;
});
}
flushPrefEnv() {
while (prefUndoStack.length) {
this.popPrefEnv();
}
}
_setPref(name, type, value, iid) {
switch (type) {
case "BOOL":
return Services.prefs.setBoolPref(name, value);
case "INT":
return Services.prefs.setIntPref(name, value);
case "CHAR":
return Services.prefs.setCharPref(name, value);
case "COMPLEX":
return Services.prefs.setComplexValue(name, iid, value);
}
throw new Error(`Unexpected preference type: ${type}`);
}
_getPref(name, type, defaultValue, iid) {
switch (type) {
case "BOOL":
if (defaultValue !== undefined) {
return Services.prefs.getBoolPref(name, defaultValue);
}
return Services.prefs.getBoolPref(name);
case "INT":
if (defaultValue !== undefined) {
return Services.prefs.getIntPref(name, defaultValue);
}
return Services.prefs.getIntPref(name);
case "CHAR":
if (defaultValue !== undefined) {
return Services.prefs.getCharPref(name, defaultValue);
}
return Services.prefs.getCharPref(name);
case "COMPLEX":
return Services.prefs.getComplexValue(name, iid);
}
throw new Error(`Unexpected preference type: ${type}`);
}
_toggleMuteAudio(aMuted) {
let browser = this.browsingContext.top.embedderElement;
if (aMuted) {
browser.mute();
} else {
browser.unmute();
}
}
_permOp(perm) {
switch (perm.op) {
case "add":
Services.perms.addFromPrincipal(
perm.principal,
perm.type,
perm.permission,
perm.expireType,
perm.expireTime
);
break;
case "remove":
Services.perms.removeFromPrincipal(perm.principal, perm.type);
break;
default:
throw new Error(`Unexpected permission op: ${perm.op}`);
}
}
pushPermissions(inPermissions) {
let pendingPermissions = [];
let cleanupPermissions = [];
for (let permission of inPermissions) {
let { principal } = permission;
if (principal.isSystemPrincipal) {
continue;
}
let originalValue = Services.perms.testPermissionFromPrincipal(
principal,
permission.type
);
let perm = permission.allow;
if (typeof perm === "boolean") {
perm = Ci.nsIPermissionManager[perm ? "ALLOW_ACTION" : "DENY_ACTION"];
}
if (permission.remove) {
perm = Ci.nsIPermissionManager.UNKNOWN_ACTION;
}
if (originalValue == perm) {
continue;
}
let todo = {
op: "add",
type: permission.type,
permission: perm,
value: perm,
principal,
expireType:
typeof permission.expireType === "number" ? permission.expireType : 0, // default: EXPIRE_NEVER
expireTime:
typeof permission.expireTime === "number" ? permission.expireTime : 0,
};
var cleanupTodo = Object.assign({}, todo);
if (permission.remove) {
todo.op = "remove";
}
pendingPermissions.push(todo);
if (originalValue == Ci.nsIPermissionManager.UNKNOWN_ACTION) {
cleanupTodo.op = "remove";
} else {
cleanupTodo.value = originalValue;
cleanupTodo.permission = originalValue;
}
cleanupPermissions.push(cleanupTodo);
}
permissionUndoStack.push(cleanupPermissions);
for (let perm of pendingPermissions) {
this._permOp(perm);
}
}
popPermissions() {
if (permissionUndoStack.length) {
for (let perm of permissionUndoStack.pop()) {
this._permOp(perm);
}
}
}
flushPermissions() {
while (permissionUndoStack.length) {
this.popPermissions();
}
}
_spawnChrome(task, args, caller, imports) {
let sb = new SpecialPowersSandbox(
null,
data => {
this.sendAsyncMessage("Assert", data);
},
{ imports }
);
for (let [global, prop] of Object.entries({
windowGlobalParent: "manager",
browsingContext: "browsingContext",
})) {
Object.defineProperty(sb.sandbox, global, {
get: () => {
return this[prop];
},
enumerable: true,
});
}
return sb.execute(task, args, caller);
}
/**
* messageManager callback function
* This will get requests from our API in the window and process them in chrome for it
**/
// eslint-disable-next-line complexity
receiveMessage(aMessage) {
ChromeUtils.addProfilerMarker("SpecialPowers", undefined, aMessage.name);
// We explicitly return values in the below code so that this function
// doesn't trigger a flurry of warnings about "does not always return
// a value".
switch (aMessage.name) {
case "SPToggleMuteAudio":
return this._toggleMuteAudio(aMessage.data.mute);
case "Ping":
return undefined;
case "SpecialPowers.Quit":
if (
!AppConstants.RELEASE_OR_BETA &&
!AppConstants.DEBUG &&
!AppConstants.MOZ_CODE_COVERAGE &&
!AppConstants.ASAN &&
!AppConstants.TSAN
) {
Cu.exitIfInAutomation();
} else {
Services.startup.quit(Ci.nsIAppStartup.eForceQuit);
}
return undefined;
case "SpecialPowers.Focus":
if (this.manager.rootFrameLoader) {
this.manager.rootFrameLoader.ownerElement.focus();
}
return undefined;
case "SpecialPowers.CreateFiles":
return (async () => {
let filePaths = [];
if (!this._createdFiles) {
this._createdFiles = [];
}
let createdFiles = this._createdFiles;
let promises = [];
aMessage.data.forEach(function(request) {
const filePerms = 0o666;
let testFile = Services.dirsvc.get("ProfD", Ci.nsIFile);
if (request.name) {
testFile.appendRelativePath(request.name);
} else {
testFile.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, filePerms);
}
let outStream = Cc[
"@mozilla.org/network/file-output-stream;1"
].createInstance(Ci.nsIFileOutputStream);
outStream.init(
testFile,
0x02 | 0x08 | 0x20, // PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE
filePerms,
0
);
if (request.data) {
outStream.write(request.data, request.data.length);
}
outStream.close();
promises.push(
File.createFromFileName(testFile.path, request.options).then(
function(file) {
filePaths.push(file);
}
)
);
createdFiles.push(testFile);
});
await Promise.all(promises);
return filePaths;
})().catch(e => {
Cu.reportError(e);
return Promise.reject(String(e));
});
case "SpecialPowers.RemoveFiles":
if (this._createdFiles) {
this._createdFiles.forEach(function(testFile) {
try {
testFile.remove(false);
} catch (e) {}
});
this._createdFiles = null;
}
return undefined;
case "Wakeup":
return undefined;
case "PushPrefEnv":
return this.pushPrefEnv(aMessage.data);
case "PopPrefEnv":
return this.popPrefEnv();
case "FlushPrefEnv":
return this.flushPrefEnv();
case "PushPermissions":
return this.pushPermissions(aMessage.data);
case "PopPermissions":
return this.popPermissions();
case "FlushPermissions":
return this.flushPermissions();
case "SPPrefService": {
let prefs = Services.prefs;
let prefType = aMessage.json.prefType.toUpperCase();
let { prefName, prefValue, iid, defaultValue } = aMessage.json;
if (aMessage.json.op == "get") {
if (!prefName || !prefType) {
throw new SpecialPowersError(
"Invalid parameters for get in SPPrefService"
);
}
// return null if the pref doesn't exist
if (
defaultValue === undefined &&
prefs.getPrefType(prefName) == prefs.PREF_INVALID
) {
return null;
}
return this._getPref(prefName, prefType, defaultValue, iid);
} else if (aMessage.json.op == "set") {
if (!prefName || !prefType || prefValue === undefined) {
throw new SpecialPowersError(
"Invalid parameters for set in SPPrefService"
);
}
return this._setPref(prefName, prefType, prefValue, iid);
} else if (aMessage.json.op == "clear") {
if (!prefName) {
throw new SpecialPowersError(
"Invalid parameters for clear in SPPrefService"
);
}
prefs.clearUserPref(prefName);
} else {
throw new SpecialPowersError("Invalid operation for SPPrefService");
}
return undefined; // See comment at the beginning of this function.
}
case "SPProcessCrashService": {
switch (aMessage.json.op) {
case "register-observer":
this._addProcessCrashObservers();
break;
case "unregister-observer":
this._removeProcessCrashObservers();
break;
case "delete-crash-dump-files":
return this._deleteCrashDumpFiles(aMessage.json.filenames);
case "find-crash-dump-files":
return this._findCrashDumpFiles(
aMessage.json.crashDumpFilesToIgnore
);
case "delete-pending-crash-dump-files":
return this._deletePendingCrashDumpFiles();
default:
throw new SpecialPowersError(
"Invalid operation for SPProcessCrashService"
);
}
return undefined; // See comment at the beginning of this function.
}
case "SPProcessCrashManagerWait": {
let promises = aMessage.json.crashIds.map(crashId => {
return Services.crashmanager.ensureCrashIsPresent(crashId);
});
return Promise.all(promises);
}
case "SPPermissionManager": {
let msg = aMessage.data;
switch (msg.op) {
case "add":
case "remove":
this._permOp(msg);
break;
case "has":
let hasPerm = Services.perms.testPermissionFromPrincipal(
msg.principal,
msg.type
);
return hasPerm == Ci.nsIPermissionManager.ALLOW_ACTION;
case "test":
let testPerm = Services.perms.testPermissionFromPrincipal(
msg.principal,
msg.type
);
return testPerm == msg.value;
default:
throw new SpecialPowersError(
"Invalid operation for SPPermissionManager"
);
}
return undefined; // See comment at the beginning of this function.
}
case "SPSetTestPluginEnabledState": {
var plugin = getTestPlugin(aMessage.data.pluginName);
if (!plugin) {
return undefined;
}
var oldEnabledState = plugin.enabledState;
plugin.enabledState = aMessage.data.newEnabledState;
return oldEnabledState;
}
case "SPObserverService": {
let topic = aMessage.json.observerTopic;
switch (aMessage.json.op) {
case "notify":
let data = aMessage.json.observerData;
Services.obs.notifyObservers(null, topic, data);
break;
case "add":
this._registerObservers._add(topic);
break;
default:
throw new SpecialPowersError(
"Invalid operation for SPObserverervice"
);
}
return undefined; // See comment at the beginning of this function.
}
case "SPLoadChromeScript": {
let id = aMessage.json.id;
let scriptName;
let jsScript = aMessage.json.function.body;
if (aMessage.json.url) {
scriptName = aMessage.json.url;
} else if (aMessage.json.function) {
scriptName =
aMessage.json.function.name ||
"<loadChromeScript anonymous function>";
} else {
throw new SpecialPowersError("SPLoadChromeScript: Invalid script");
}
// Setup a chrome sandbox that has access to sendAsyncMessage
// and {add,remove}MessageListener in order to communicate with
// the mochitest.
let sb = new SpecialPowersSandbox(
scriptName,
data => {
this.sendAsyncMessage("Assert", data);
},
aMessage.data
);
Object.assign(sb.sandbox, {
createWindowlessBrowser,
sendAsyncMessage: (name, message) => {
this.sendAsyncMessage("SPChromeScriptMessage", {
id,
name,
message,
});
},
addMessageListener: (name, listener) => {
this._chromeScriptListeners.push({ id, name, listener });
},
removeMessageListener: (name, listener) => {
let index = this._chromeScriptListeners.findIndex(function(obj) {
return (
obj.id == id && obj.name == name && obj.listener == listener
);
});
if (index >= 0) {
this._chromeScriptListeners.splice(index, 1);
}
},
actorParent: this.manager,
});
// Evaluate the chrome script
try {
Cu.evalInSandbox(jsScript, sb.sandbox, "1.8", scriptName, 1);
} catch (e) {
throw new SpecialPowersError(
"Error while executing chrome script '" +
scriptName +
"':\n" +
e +
"\n" +
e.fileName +
":" +
e.lineNumber
);
}
return undefined; // See comment at the beginning of this function.
}
case "SPChromeScriptMessage": {
let id = aMessage.json.id;
let name = aMessage.json.name;
let message = aMessage.json.message;
let result;
for (let listener of this._chromeScriptListeners) {
if (listener.name == name && listener.id == id) {
result = listener.listener(message);
}
}
return result;
}
case "SPImportInMainProcess": {
var message = { hadError: false, errorMessage: null };
try {
ChromeUtils.import(aMessage.data);
} catch (e) {
message.hadError = true;
message.errorMessage = e.toString();
}
return message;
}
case "SPCleanUpSTSData": {
let origin = aMessage.data.origin;
let flags = aMessage.data.flags;
let uri = Services.io.newURI(origin);
let sss = Cc["@mozilla.org/ssservice;1"].getService(
Ci.nsISiteSecurityService
);
sss.resetState(Ci.nsISiteSecurityService.HEADER_HSTS, uri, flags);
return undefined;
}
case "SPRequestDumpCoverageCounters": {
return PerTestCoverageUtils.afterTest();
}
case "SPRequestResetCoverageCounters": {
return PerTestCoverageUtils.beforeTest();
}
case "SPCheckServiceWorkers": {
let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService(
Ci.nsIServiceWorkerManager
);
let regs = swm.getAllRegistrations();
// XXX This code is shared with specialpowers.js.
let workers = new Array(regs.length);
for (let i = 0; i < regs.length; ++i) {
let { scope, scriptSpec } = regs.queryElementAt(
i,
Ci.nsIServiceWorkerRegistrationInfo
);
workers[i] = { scope, scriptSpec };
}
return { workers };
}
case "SPLoadExtension": {
let id = aMessage.data.id;
let ext = aMessage.data.ext;
let extension = ExtensionTestCommon.generate(ext);
let resultListener = (...args) => {
this.sendAsyncMessage("SPExtensionMessage", {
id,
type: "testResult",
args,
});
};
let messageListener = (...args) => {
args.shift();
this.sendAsyncMessage("SPExtensionMessage", {
id,
type: "testMessage",
args,
});
};
// Register pass/fail handlers.
extension.on("test-result", resultListener);
extension.on("test-eq", resultListener);
extension.on("test-log", resultListener);
extension.on("test-done", resultListener);
extension.on("test-message", messageListener);
this._extensions.set(id, extension);
return undefined;
}
case "SPStartupExtension": {
let id = aMessage.data.id;
// This is either an Extension, or (if useAddonManager is set) a MockExtension.
let extension = this._extensions.get(id);
extension.on("startup", (eventName, ext) => {
if (AppConstants.platform === "android") {
// We need a way to notify the embedding layer that a new extension
// has been installed, so that the java layer can be updated too.
Services.obs.notifyObservers(null, "testing-installed-addon", id);
}
// ext is always the "real" Extension object, even when "extension"
// is a MockExtension.
this.sendAsyncMessage("SPExtensionMessage", {
id,
type: "extensionSetId",
args: [ext.id, ext.uuid],
});
});
// Make sure the extension passes the packaging checks when
// they're run on a bare archive rather than a running instance,
// as the add-on manager runs them.
let extensionData = new ExtensionData(extension.rootURI);
return extensionData
.loadManifest()
.then(
() => {
return extensionData.initAllLocales().then(() => {
if (extensionData.errors.length) {
return Promise.reject("Extension contains packaging errors");
}
return undefined;
});
},
() => {
// loadManifest() will throw if we're loading an embedded
// extension, so don't worry about locale errors in that
// case.
}
)
.then(async () => {
// browser tests do not call startup in ExtensionXPCShellUtils or MockExtension,
// in that case we have an ID here and we need to set the override.
if (extension.id) {
await ExtensionTestCommon.setIncognitoOverride(extension);
}
return extension.startup().then(
() => {},
e => {
dump(`Extension startup failed: ${e}\n${e.stack}`);
throw e;
}
);
});
}
case "SPExtensionMessage": {
let id = aMessage.data.id;
let extension = this._extensions.get(id);
extension.testMessage(...aMessage.data.args);
return undefined;
}
case "SPExtensionGrantActiveTab": {
let { id, tabId } = aMessage.data;
let { tabManager } = this._extensions.get(id);
tabManager.addActiveTabPermission(tabManager.get(tabId).nativeTab);
return undefined;
}
case "SPUnloadExtension": {
let id = aMessage.data.id;
let extension = this._extensions.get(id);
this._extensions.delete(id);
return extension.shutdown().then(() => {
return extension._uninstallPromise;
});
}
case "SetAsDefaultAssertHandler": {
defaultAssertHandler = this;
return undefined;
}
case "Spawn": {
let {
browsingContext,
task,
args,
caller,
hasHarness,
imports,
} = aMessage.data;
let spParent = browsingContext.currentWindowGlobal.getActor(
"SpecialPowers"
);
let taskId = nextTaskID++;
if (hasHarness) {
spParent._taskActors.set(taskId, this);
}
return spParent
.sendQuery("Spawn", { task, args, caller, taskId, imports })
.finally(() => spParent._taskActors.delete(taskId));
}
case "SpawnChrome": {
let { task, args, caller, imports } = aMessage.data;
return this._spawnChrome(task, args, caller, imports);
}
case "Snapshot": {
let { browsingContext, rect, background } = aMessage.data;
return browsingContext.currentWindowGlobal
.drawSnapshot(rect, 1.0, background)
.then(async image => {
let hiddenFrame = new HiddenFrame();
let win = await hiddenFrame.get();
let canvas = win.document.createElement("canvas");
canvas.width = image.width;
canvas.height = image.height;
const ctx = canvas.getContext("2d");
ctx.drawImage(image, 0, 0);
let data = ctx.getImageData(0, 0, image.width, image.height);
hiddenFrame.destroy();
return data;
});
}
case "SecurityState": {
let { browsingContext } = aMessage.data;
return browsingContext.secureBrowserUI.state;
}
case "ProxiedAssert": {
let { taskId, data } = aMessage.data;
let actor = this._taskActors.get(taskId) || defaultAssertHandler;
actor.sendAsyncMessage("Assert", data);
return undefined;
}
case "SPRemoveAllServiceWorkers": {
return ServiceWorkerCleanUp.removeAll();
}
case "SPRemoveServiceWorkerDataForExampleDomain": {
return ServiceWorkerCleanUp.removeFromHost("example.com");
}
case "SPGenerateMediaControlKeyTestEvent": {
// eslint-disable-next-line no-undef
MediaControlService.generateMediaControlKey(aMessage.data.event);
return undefined;
}
default:
throw new SpecialPowersError(
`Unrecognized Special Powers API: ${aMessage.name}`
);
}
// This should be unreachable. If it ever becomes reachable, ESLint
// will produce an error about inconsistent return values.
}
}