diff options
Diffstat (limited to '')
| -rw-r--r-- | testing/specialpowers/content/MockColorPicker.jsm | 132 | ||||
| -rw-r--r-- | testing/specialpowers/content/MockFilePicker.jsm | 332 | ||||
| -rw-r--r-- | testing/specialpowers/content/MockPermissionPrompt.jsm | 87 | ||||
| -rw-r--r-- | testing/specialpowers/content/SpecialPowersChild.jsm | 2232 | ||||
| -rw-r--r-- | testing/specialpowers/content/SpecialPowersEventUtils.jsm | 42 | ||||
| -rw-r--r-- | testing/specialpowers/content/SpecialPowersParent.jsm | 1304 | ||||
| -rw-r--r-- | testing/specialpowers/content/SpecialPowersSandbox.jsm | 143 | ||||
| -rw-r--r-- | testing/specialpowers/content/WrapPrivileged.jsm | 415 |
8 files changed, 4687 insertions, 0 deletions
diff --git a/testing/specialpowers/content/MockColorPicker.jsm b/testing/specialpowers/content/MockColorPicker.jsm new file mode 100644 index 0000000000..b091cf6eb2 --- /dev/null +++ b/testing/specialpowers/content/MockColorPicker.jsm @@ -0,0 +1,132 @@ +/* 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/. */ + +var EXPORTED_SYMBOLS = ["MockColorPicker"]; + +ChromeUtils.defineModuleGetter( + this, + "WrapPrivileged", + "resource://specialpowers/WrapPrivileged.jsm" +); + +const Cm = Components.manager; + +const CONTRACT_ID = "@mozilla.org/colorpicker;1"; + +Cu.crashIfNotInAutomation(); + +var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); +var oldClassID = ""; +var newClassID = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator) + .generateUUID(); +var newFactory = function(window) { + return { + createInstance(aOuter, aIID) { + if (aOuter) { + throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION); + } + return new MockColorPickerInstance(window).QueryInterface(aIID); + }, + lockFactory(aLock) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + QueryInterface: ChromeUtils.generateQI(["nsIFactory"]), + }; +}; + +var MockColorPicker = { + init(window) { + this.reset(); + this.factory = newFactory(window); + if (!registrar.isCIDRegistered(newClassID)) { + try { + oldClassID = registrar.contractIDToCID(CONTRACT_ID); + } catch (ex) { + oldClassID = ""; + dump( + "TEST-INFO | can't get colorpicker registered component, " + + "assuming there is none" + ); + } + registrar.registerFactory(newClassID, "", CONTRACT_ID, this.factory); + } + }, + + reset() { + this.returnColor = ""; + this.showCallback = null; + this.shown = false; + this.showing = false; + }, + + cleanup() { + var previousFactory = this.factory; + this.reset(); + this.factory = null; + + registrar.unregisterFactory(newClassID, previousFactory); + if (oldClassID != "") { + registrar.registerFactory(oldClassID, "", CONTRACT_ID, null); + } + }, +}; + +function MockColorPickerInstance(window) { + this.window = window; + this.showCallback = null; + this.showCallbackWrapped = null; +} +MockColorPickerInstance.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIColorPicker"]), + init(aParent, aTitle, aInitialColor) { + this.parent = aParent; + this.initialColor = aInitialColor; + }, + initialColor: "", + parent: null, + open(aColorPickerShownCallback) { + MockColorPicker.showing = true; + MockColorPicker.shown = true; + + this.window.setTimeout(() => { + let result = ""; + try { + if (typeof MockColorPicker.showCallback == "function") { + if (MockColorPicker.showCallback != this.showCallback) { + this.showCallback = MockColorPicker.showCallback; + if (Cu.isXrayWrapper(this.window)) { + this.showCallbackWrapped = WrapPrivileged.wrapCallback( + MockColorPicker.showCallback, + this.window + ); + } else { + this.showCallbackWrapped = this.showCallback; + } + } + var updateCb = function(color) { + result = color; + aColorPickerShownCallback.update(color); + }; + let returnColor = this.showCallbackWrapped(this, updateCb); + if (typeof returnColor === "string") { + result = returnColor; + } + } else if (typeof MockColorPicker.returnColor === "string") { + result = MockColorPicker.returnColor; + } + } catch (ex) { + dump( + "TEST-UNEXPECTED-FAIL | Exception in MockColorPicker.jsm open() " + + "method: " + + ex + + "\n" + ); + } + if (aColorPickerShownCallback) { + aColorPickerShownCallback.done(result); + } + }, 0); + }, +}; diff --git a/testing/specialpowers/content/MockFilePicker.jsm b/testing/specialpowers/content/MockFilePicker.jsm new file mode 100644 index 0000000000..2b331cf6c5 --- /dev/null +++ b/testing/specialpowers/content/MockFilePicker.jsm @@ -0,0 +1,332 @@ +/* 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/. */ + +var EXPORTED_SYMBOLS = ["MockFilePicker"]; + +ChromeUtils.defineModuleGetter( + this, + "WrapPrivileged", + "resource://specialpowers/WrapPrivileged.jsm" +); + +const Cm = Components.manager; + +const CONTRACT_ID = "@mozilla.org/filepicker;1"; + +ChromeUtils.defineModuleGetter( + this, + "FileUtils", + "resource://gre/modules/FileUtils.jsm" +); +const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); + +/* globals __URI__ */ +if (__URI__.includes("specialpowers")) { + Cu.crashIfNotInAutomation(); +} + +var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); +var oldClassID; +var newClassID = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator) + .generateUUID(); +var newFactory = function(window) { + return { + createInstance(aOuter, aIID) { + if (aOuter) { + throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION); + } + return new MockFilePickerInstance(window).QueryInterface(aIID); + }, + lockFactory(aLock) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + QueryInterface: ChromeUtils.generateQI(["nsIFactory"]), + }; +}; + +var MockFilePicker = { + returnOK: Ci.nsIFilePicker.returnOK, + returnCancel: Ci.nsIFilePicker.returnCancel, + returnReplace: Ci.nsIFilePicker.returnReplace, + + filterAll: Ci.nsIFilePicker.filterAll, + filterHTML: Ci.nsIFilePicker.filterHTML, + filterText: Ci.nsIFilePicker.filterText, + filterImages: Ci.nsIFilePicker.filterImages, + filterXML: Ci.nsIFilePicker.filterXML, + filterXUL: Ci.nsIFilePicker.filterXUL, + filterApps: Ci.nsIFilePicker.filterApps, + filterAllowURLs: Ci.nsIFilePicker.filterAllowURLs, + filterAudio: Ci.nsIFilePicker.filterAudio, + filterVideo: Ci.nsIFilePicker.filterVideo, + + window: null, + pendingPromises: [], + + init(window) { + this.window = window; + + this.reset(); + this.factory = newFactory(window); + if (!registrar.isCIDRegistered(newClassID)) { + oldClassID = registrar.contractIDToCID(CONTRACT_ID); + registrar.registerFactory(newClassID, "", CONTRACT_ID, this.factory); + } + }, + + reset() { + this.appendFilterCallback = null; + this.appendFiltersCallback = null; + this.displayDirectory = null; + this.displaySpecialDirectory = ""; + this.filterIndex = 0; + this.mode = null; + this.returnData = []; + this.returnValue = null; + this.showCallback = null; + this.afterOpenCallback = null; + this.shown = false; + this.showing = false; + }, + + cleanup() { + var previousFactory = this.factory; + this.reset(); + this.factory = null; + if (oldClassID) { + registrar.unregisterFactory(newClassID, previousFactory); + registrar.registerFactory(oldClassID, "", CONTRACT_ID, null); + } + }, + + internalFileData(obj) { + return { + nsIFile: "nsIFile" in obj ? obj.nsIFile : null, + domFile: "domFile" in obj ? obj.domFile : null, + domDirectory: "domDirectory" in obj ? obj.domDirectory : null, + }; + }, + + useAnyFile() { + var file = FileUtils.getDir("TmpD", [], false); + file.append("testfile"); + file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644); + let promise = this.window.File.createFromNsIFile(file) + .then( + domFile => domFile, + () => null + ) + // domFile can be null. + .then(domFile => { + this.returnData = [this.internalFileData({ nsIFile: file, domFile })]; + }) + .then(() => file); + + this.pendingPromises = [promise]; + + // We return a promise in order to support some existing mochitests. + return promise; + }, + + useBlobFile() { + var blob = new this.window.Blob([]); + var file = new this.window.File([blob], "helloworld.txt", { + type: "plain/text", + }); + this.returnData = [this.internalFileData({ domFile: file })]; + this.pendingPromises = []; + }, + + useDirectory(aPath) { + var directory = new this.window.Directory(aPath); + this.returnData = [this.internalFileData({ domDirectory: directory })]; + this.pendingPromises = []; + }, + + setFiles(files) { + this.returnData = []; + this.pendingPromises = []; + + for (let file of files) { + if (file instanceof this.window.File) { + this.returnData.push(this.internalFileData({ domFile: file })); + } else { + let promise = this.window.File.createFromNsIFile(file, { + existenceCheck: false, + }); + + promise.then(domFile => { + this.returnData.push( + this.internalFileData({ nsIFile: file, domFile }) + ); + }); + this.pendingPromises.push(promise); + } + } + }, + + getNsIFile() { + if (this.returnData.length >= 1) { + return this.returnData[0].nsIFile; + } + return null; + }, +}; + +function MockFilePickerInstance(window) { + this.window = window; + this.showCallback = null; + this.showCallbackWrapped = null; +} +MockFilePickerInstance.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIFilePicker"]), + init(aParent, aTitle, aMode) { + this.mode = aMode; + this.filterIndex = MockFilePicker.filterIndex; + this.parent = aParent; + }, + appendFilter(aTitle, aFilter) { + if (typeof MockFilePicker.appendFilterCallback == "function") { + MockFilePicker.appendFilterCallback(this, aTitle, aFilter); + } + }, + appendFilters(aFilterMask) { + if (typeof MockFilePicker.appendFiltersCallback == "function") { + MockFilePicker.appendFiltersCallback(this, aFilterMask); + } + }, + defaultString: "", + defaultExtension: "", + parent: null, + filterIndex: 0, + displayDirectory: null, + displaySpecialDirectory: "", + get file() { + if (MockFilePicker.returnData.length >= 1) { + return MockFilePicker.returnData[0].nsIFile; + } + + return null; + }, + + // We don't support directories here. + get domFileOrDirectory() { + if (MockFilePicker.returnData.length < 1) { + return null; + } + + if (MockFilePicker.returnData[0].domFile) { + return MockFilePicker.returnData[0].domFile; + } + + if (MockFilePicker.returnData[0].domDirectory) { + return MockFilePicker.returnData[0].domDirectory; + } + + return null; + }, + get fileURL() { + if ( + MockFilePicker.returnData.length >= 1 && + MockFilePicker.returnData[0].nsIFile + ) { + return Services.io.newFileURI(MockFilePicker.returnData[0].nsIFile); + } + + return null; + }, + *getFiles(asDOM) { + for (let d of MockFilePicker.returnData) { + if (asDOM) { + yield d.domFile || d.domDirectory; + } else if (d.nsIFile) { + yield d.nsIFile; + } else { + throw Components.Exception("", Cr.NS_ERROR_FAILURE); + } + } + }, + get files() { + return this.getFiles(false); + }, + get domFileOrDirectoryEnumerator() { + return this.getFiles(true); + }, + open(aFilePickerShownCallback) { + MockFilePicker.showing = true; + Services.tm.dispatchToMainThread(() => { + // Maybe all the pending promises are already resolved, but we want to be sure. + Promise.all(MockFilePicker.pendingPromises) + .then( + () => { + return Ci.nsIFilePicker.returnOK; + }, + () => { + return Ci.nsIFilePicker.returnCancel; + } + ) + .then(result => { + // Nothing else has to be done. + MockFilePicker.pendingPromises = []; + + if (result == Ci.nsIFilePicker.returnCancel) { + return result; + } + + MockFilePicker.displayDirectory = this.displayDirectory; + MockFilePicker.displaySpecialDirectory = this.displaySpecialDirectory; + MockFilePicker.shown = true; + if (typeof MockFilePicker.showCallback == "function") { + if (MockFilePicker.showCallback != this.showCallback) { + this.showCallback = MockFilePicker.showCallback; + if (Cu.isXrayWrapper(this.window)) { + this.showCallbackWrapped = WrapPrivileged.wrapCallback( + MockFilePicker.showCallback, + this.window + ); + } else { + this.showCallbackWrapped = this.showCallback; + } + } + try { + var returnValue = this.showCallbackWrapped(this); + if (typeof returnValue != "undefined") { + return returnValue; + } + } catch (ex) { + return Ci.nsIFilePicker.returnCancel; + } + } + + return MockFilePicker.returnValue; + }) + .then(result => { + // Some additional result file can be set by the callback. Let's + // resolve the pending promises again. + return Promise.all(MockFilePicker.pendingPromises).then( + () => { + return result; + }, + () => { + return Ci.nsIFilePicker.returnCancel; + } + ); + }) + .then(result => { + MockFilePicker.pendingPromises = []; + + if (aFilePickerShownCallback) { + aFilePickerShownCallback.done(result); + } + + if (typeof MockFilePicker.afterOpenCallback == "function") { + Services.tm.dispatchToMainThread(() => { + MockFilePicker.afterOpenCallback(this); + }); + } + }); + }); + }, +}; diff --git a/testing/specialpowers/content/MockPermissionPrompt.jsm b/testing/specialpowers/content/MockPermissionPrompt.jsm new file mode 100644 index 0000000000..099c4c37c5 --- /dev/null +++ b/testing/specialpowers/content/MockPermissionPrompt.jsm @@ -0,0 +1,87 @@ +/* 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/. */ + +var EXPORTED_SYMBOLS = ["MockPermissionPrompt"]; + +const Cm = Components.manager; + +const CONTRACT_ID = "@mozilla.org/content-permission/prompt;1"; + +const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); + +var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); +var oldClassID, oldFactory; +var newClassID = Cc["@mozilla.org/uuid-generator;1"] + .getService(Ci.nsIUUIDGenerator) + .generateUUID(); +var newFactory = { + createInstance(aOuter, aIID) { + if (aOuter) { + throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION); + } + return new MockPermissionPromptInstance().QueryInterface(aIID); + }, + lockFactory(aLock) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, + QueryInterface: ChromeUtils.generateQI(["nsIFactory"]), +}; + +var MockPermissionPrompt = { + init() { + this.reset(); + if (!registrar.isCIDRegistered(newClassID)) { + try { + oldClassID = registrar.contractIDToCID(CONTRACT_ID); + oldFactory = Cm.getClassObject(Cc[CONTRACT_ID], Ci.nsIFactory); + } catch (ex) { + oldClassID = ""; + oldFactory = null; + dump( + "TEST-INFO | can't get permission prompt registered component, " + + "assuming there is none" + ); + } + if (oldFactory) { + registrar.unregisterFactory(oldClassID, oldFactory); + } + registrar.registerFactory(newClassID, "", CONTRACT_ID, newFactory); + } + }, + + reset() {}, + + cleanup() { + this.reset(); + if (oldFactory) { + registrar.unregisterFactory(newClassID, newFactory); + registrar.registerFactory(oldClassID, "", CONTRACT_ID, oldFactory); + } + }, +}; + +function MockPermissionPromptInstance() {} +MockPermissionPromptInstance.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIContentPermissionPrompt"]), + + promptResult: Ci.nsIPermissionManager.UNKNOWN_ACTION, + + prompt(request) { + let perms = request.types.QueryInterface(Ci.nsIArray); + for (let idx = 0; idx < perms.length; idx++) { + let perm = perms.queryElementAt(idx, Ci.nsIContentPermissionType); + if ( + Services.perms.testExactPermissionFromPrincipal( + request.principal, + perm.type + ) != Ci.nsIPermissionManager.ALLOW_ACTION + ) { + request.cancel(); + return; + } + } + + request.allow(); + }, +}; diff --git a/testing/specialpowers/content/SpecialPowersChild.jsm b/testing/specialpowers/content/SpecialPowersChild.jsm new file mode 100644 index 0000000000..203495dc71 --- /dev/null +++ b/testing/specialpowers/content/SpecialPowersChild.jsm @@ -0,0 +1,2232 @@ +/* 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/. */ +/* This code is loaded in every child process that is started by mochitest. + */ + +"use strict"; + +var EXPORTED_SYMBOLS = ["SpecialPowersChild"]; + +var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); + +const { ExtensionUtils } = ChromeUtils.import( + "resource://gre/modules/ExtensionUtils.jsm" +); + +ChromeUtils.defineModuleGetter( + this, + "MockFilePicker", + "resource://specialpowers/MockFilePicker.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "MockColorPicker", + "resource://specialpowers/MockColorPicker.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "MockPermissionPrompt", + "resource://specialpowers/MockPermissionPrompt.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "SpecialPowersSandbox", + "resource://specialpowers/SpecialPowersSandbox.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "WrapPrivileged", + "resource://specialpowers/WrapPrivileged.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "PrivateBrowsingUtils", + "resource://gre/modules/PrivateBrowsingUtils.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "NetUtil", + "resource://gre/modules/NetUtil.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "AppConstants", + "resource://gre/modules/AppConstants.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "PerTestCoverageUtils", + "resource://testing-common/PerTestCoverageUtils.jsm" +); +ChromeUtils.defineModuleGetter( + this, + "ContentTaskUtils", + "resource://testing-common/ContentTaskUtils.jsm" +); + +Cu.crashIfNotInAutomation(); + +function bindDOMWindowUtils(aWindow) { + return aWindow && WrapPrivileged.wrap(aWindow.windowUtils, aWindow); +} + +function defineSpecialPowers(sp) { + let window = sp.contentWindow; + window.SpecialPowers = sp; + if (window === window.wrappedJSObject) { + return; + } + // We can't use a generic |defineLazyGetter| because it does not + // allow customizing the re-definition behavior. + Object.defineProperty(window.wrappedJSObject, "SpecialPowers", { + get() { + let value = WrapPrivileged.wrap(sp, window); + // If we bind |window.wrappedJSObject| when defining the getter + // and use it here, it might become a dead wrapper. + // We have to retrieve |wrappedJSObject| again. + Object.defineProperty(window.wrappedJSObject, "SpecialPowers", { + configurable: true, + enumerable: true, + value, + writable: true, + }); + return value; + }, + configurable: true, + enumerable: true, + }); +} + +// SPConsoleListener reflects nsIConsoleMessage objects into JS in a +// tidy, XPCOM-hiding way. Messages that are nsIScriptError objects +// have their properties exposed in detail. It also auto-unregisters +// itself when it receives a "sentinel" message. +function SPConsoleListener(callback, contentWindow) { + this.callback = callback; + this.contentWindow = contentWindow; +} + +SPConsoleListener.prototype = { + // Overload the observe method for both nsIConsoleListener and nsIObserver. + // The topic will be null for nsIConsoleListener. + observe(msg, topic) { + let m = { + message: msg.message, + errorMessage: null, + cssSelectors: null, + sourceName: null, + sourceLine: null, + lineNumber: null, + columnNumber: null, + category: null, + windowID: null, + isScriptError: false, + isConsoleEvent: false, + isWarning: false, + }; + if (msg instanceof Ci.nsIScriptError) { + m.errorMessage = msg.errorMessage; + m.cssSelectors = msg.cssSelectors; + m.sourceName = msg.sourceName; + m.sourceLine = msg.sourceLine; + m.lineNumber = msg.lineNumber; + m.columnNumber = msg.columnNumber; + m.category = msg.category; + m.windowID = msg.outerWindowID; + m.innerWindowID = msg.innerWindowID; + m.isScriptError = true; + m.isWarning = (msg.flags & Ci.nsIScriptError.warningFlag) === 1; + } else if (topic === "console-api-log-event") { + // This is a dom/console event. + let unwrapped = msg.wrappedJSObject; + m.errorMessage = unwrapped.arguments[0]; + m.sourceName = unwrapped.filename; + m.lineNumber = unwrapped.lineNumber; + m.columnNumber = unwrapped.columnNumber; + m.windowID = unwrapped.ID; + m.innerWindowID = unwrapped.innerID; + m.isConsoleEvent = true; + m.isWarning = unwrapped.level === "warning"; + } + + Object.freeze(m); + + // Run in a separate runnable since console listeners aren't + // supposed to touch content and this one might. + Services.tm.dispatchToMainThread(() => { + this.callback.call(undefined, Cu.cloneInto(m, this.contentWindow)); + }); + + if (!m.isScriptError && !m.isConsoleEvent && m.message === "SENTINEL") { + Services.obs.removeObserver(this, "console-api-log-event"); + Services.console.unregisterListener(this); + } + }, + + QueryInterface: ChromeUtils.generateQI(["nsIConsoleListener", "nsIObserver"]), +}; + +class SpecialPowersChild extends JSWindowActorChild { + constructor() { + super(); + + this._windowID = null; + + this._encounteredCrashDumpFiles = []; + this._unexpectedCrashDumpFiles = {}; + this._crashDumpDir = null; + this._serviceWorkerRegistered = false; + this._serviceWorkerCleanUpRequests = new Map(); + Object.defineProperty(this, "Components", { + configurable: true, + enumerable: true, + value: Components, + }); + this._createFilesOnError = null; + this._createFilesOnSuccess = null; + + this._messageListeners = new ExtensionUtils.DefaultMap(() => new Set()); + + this._consoleListeners = []; + this._spawnTaskImports = {}; + this._encounteredCrashDumpFiles = []; + this._unexpectedCrashDumpFiles = {}; + this._crashDumpDir = null; + this._mfl = null; + this._asyncObservers = new WeakMap(); + this._xpcomabi = null; + this._os = null; + this._pu = null; + + this._nextExtensionID = 0; + this._extensionListeners = null; + + WrapPrivileged.disableAutoWrap( + this.unwrap, + this.isWrapper, + this.wrapCallback, + this.wrapCallbackObject, + this.setWrapped, + this.nondeterministicGetWeakMapKeys, + this.snapshotWindowWithOptions, + this.snapshotWindow, + this.snapshotRect, + this.getDOMRequestService + ); + } + + observe(aSubject, aTopic, aData) { + // Ignore the "{chrome/content}-document-global-created" event. It + // is only observed to force creation of the actor. + } + + actorCreated() { + this.attachToWindow(); + } + + attachToWindow() { + let window = this.contentWindow; + // We should not invoke the getter. + if (!("SpecialPowers" in window.wrappedJSObject)) { + this._windowID = window.windowGlobalChild.innerWindowId; + + defineSpecialPowers(this); + } + } + + get window() { + return this.contentWindow; + } + + // Hack around devtools sometimes trying to JSON stringify us. + toJSON() { + return {}; + } + + toString() { + return "[SpecialPowers]"; + } + sanityCheck() { + return "foo"; + } + + _addMessageListener(msgname, listener) { + this._messageListeners.get(msgname).add(listener); + } + + _removeMessageListener(msgname, listener) { + this._messageListeners.get(msgname).delete(listener); + } + + receiveMessage(message) { + if (this._messageListeners.has(message.name)) { + for (let listener of this._messageListeners.get(message.name)) { + try { + if (typeof listener === "function") { + listener(message); + } else { + listener.receiveMessage(message); + } + } catch (e) { + Cu.reportError(e); + } + } + } + + switch (message.name) { + case "SPProcessCrashService": + if (message.json.type == "crash-observed") { + for (let e of message.json.dumpIDs) { + this._encounteredCrashDumpFiles.push(e.id + "." + e.extension); + } + } + break; + + case "SPServiceWorkerRegistered": + this._serviceWorkerRegistered = message.data.registered; + break; + + case "SpecialPowers.FilesCreated": + var createdHandler = this._createFilesOnSuccess; + this._createFilesOnSuccess = null; + this._createFilesOnError = null; + if (createdHandler) { + createdHandler(Cu.cloneInto(message.data, this.contentWindow)); + } + break; + + case "SpecialPowers.FilesError": + var errorHandler = this._createFilesOnError; + this._createFilesOnSuccess = null; + this._createFilesOnError = null; + if (errorHandler) { + errorHandler(message.data); + } + break; + + case "Spawn": + let { task, args, caller, taskId, imports } = message.data; + return this._spawnTask(task, args, caller, taskId, imports); + + case "Assert": + { + if ("info" in message.data) { + this.SimpleTest.info(message.data.info); + break; + } + + // An assertion has been done in a mochitest chrome script + let { name, passed, stack, diag, expectFail } = message.data; + + let { SimpleTest } = this; + if (SimpleTest) { + let expected = expectFail ? "fail" : "pass"; + SimpleTest.record(passed, name, diag, stack, expected); + } else { + // Well, this is unexpected. + dump(name + "\n"); + } + } + break; + } + return undefined; + } + + registerProcessCrashObservers() { + this.sendAsyncMessage("SPProcessCrashService", { op: "register-observer" }); + } + + unregisterProcessCrashObservers() { + this.sendAsyncMessage("SPProcessCrashService", { + op: "unregister-observer", + }); + } + + /* + * Privileged object wrapping API + * + * Usage: + * var wrapper = SpecialPowers.wrap(obj); + * wrapper.privilegedMethod(); wrapper.privilegedProperty; + * obj === SpecialPowers.unwrap(wrapper); + * + * These functions provide transparent access to privileged objects using + * various pieces of deep SpiderMagic. Conceptually, a wrapper is just an + * object containing a reference to the underlying object, where all method + * calls and property accesses are transparently performed with the System + * Principal. Moreover, objects obtained from the wrapper (including properties + * and method return values) are wrapped automatically. Thus, after a single + * call to SpecialPowers.wrap(), the wrapper layer is transitively maintained. + * + * Known Issues: + * + * - The wrapping function does not preserve identity, so + * SpecialPowers.wrap(foo) !== SpecialPowers.wrap(foo). See bug 718543. + * + * - The wrapper cannot see expando properties on unprivileged DOM objects. + * That is to say, the wrapper uses Xray delegation. + * + * - The wrapper sometimes guesses certain ES5 attributes for returned + * properties. This is explained in a comment in the wrapper code above, + * and shouldn't be a problem. + */ + wrap(obj) { + return obj; + } + unwrap(obj) { + return WrapPrivileged.unwrap(obj); + } + isWrapper(val) { + return WrapPrivileged.isWrapper(val); + } + + /* + * Wrap objects on a specified global. + */ + wrapFor(obj, win) { + return WrapPrivileged.wrap(obj, win); + } + + /* + * When content needs to pass a callback or a callback object to an API + * accessed over SpecialPowers, that API may sometimes receive arguments for + * whom it is forbidden to create a wrapper in content scopes. As such, we + * need a layer to wrap the values in SpecialPowers wrappers before they ever + * reach content. + */ + wrapCallback(func) { + return WrapPrivileged.wrapCallback(func, this.contentWindow); + } + wrapCallbackObject(obj) { + return WrapPrivileged.wrapCallbackObject(obj, this.contentWindow); + } + + /* + * Used for assigning a property to a SpecialPowers wrapper, without unwrapping + * the value that is assigned. + */ + setWrapped(obj, prop, val) { + if (!WrapPrivileged.isWrapper(obj)) { + throw new Error( + "You only need to use this for SpecialPowers wrapped objects" + ); + } + + obj = WrapPrivileged.unwrap(obj); + return Reflect.set(obj, prop, val); + } + + /* + * Create blank privileged objects to use as out-params for privileged functions. + */ + createBlankObject() { + return {}; + } + + /* + * Because SpecialPowers wrappers don't preserve identity, comparing with == + * can be hazardous. Sometimes we can just unwrap to compare, but sometimes + * wrapping the underlying object into a content scope is forbidden. This + * function strips any wrappers if they exist and compare the underlying + * values. + */ + compare(a, b) { + return WrapPrivileged.unwrap(a) === WrapPrivileged.unwrap(b); + } + + get MockFilePicker() { + return MockFilePicker; + } + + get MockColorPicker() { + return MockColorPicker; + } + + get MockPermissionPrompt() { + return MockPermissionPrompt; + } + + quit() { + this.sendAsyncMessage("SpecialPowers.Quit", {}); + } + + // fileRequests is an array of file requests. Each file request is an object. + // A request must have a field |name|, which gives the base of the name of the + // file to be created in the profile directory. If the request has a |data| field + // then that data will be written to the file. + createFiles(fileRequests, onCreation, onError) { + return this.sendQuery("SpecialPowers.CreateFiles", fileRequests).then( + files => onCreation(Cu.cloneInto(files, this.contentWindow)), + onError + ); + } + + // Remove the files that were created using |SpecialPowers.createFiles()|. + // This will be automatically called by |SimpleTest.finish()|. + removeFiles() { + this.sendAsyncMessage("SpecialPowers.RemoveFiles", {}); + } + + executeAfterFlushingMessageQueue(aCallback) { + return this.sendQuery("Ping").then(aCallback); + } + + async registeredServiceWorkers() { + // For the time being, if parent_intercept is false, we can assume that + // ServiceWorkers registered by the current test are all known to the SWM in + // this process. + if ( + !Services.prefs.getBoolPref("dom.serviceWorkers.parent_intercept", false) + ) { + let swm = Cc["@mozilla.org/serviceworkers/manager;1"].getService( + Ci.nsIServiceWorkerManager + ); + let regs = swm.getAllRegistrations(); + + // XXX This is shared with SpecialPowersAPIParent.jsm + let workers = new Array(regs.length); + for (let i = 0; i < workers.length; ++i) { + let { scope, scriptSpec } = regs.queryElementAt( + i, + Ci.nsIServiceWorkerRegistrationInfo + ); + workers[i] = { scope, scriptSpec }; + } + + return workers; + } + + // Please see the comment in SpecialPowersObserver.jsm above + // this._serviceWorkerListener's assignment for what this returns. + if (this._serviceWorkerRegistered) { + // This test registered at least one service worker. Send a synchronous + // call to the parent to make sure that it called unregister on all of its + // service workers. + let { workers } = await this.sendQuery("SPCheckServiceWorkers"); + return workers; + } + + return []; + } + + /* + * Load a privileged script that runs same-process. This is different from + * |loadChromeScript|, which will run in the parent process in e10s mode. + */ + loadPrivilegedScript(aFunction) { + var str = "(" + aFunction.toString() + ")();"; + let gGlobalObject = Cu.getGlobalForObject(this); + let sb = Cu.Sandbox(gGlobalObject); + var window = this.contentWindow; + var mc = new window.MessageChannel(); + sb.port = mc.port1; + let blob = new Blob([str], { type: "application/javascript" }); + let blobUrl = URL.createObjectURL(blob); + Services.scriptloader.loadSubScript(blobUrl, sb); + + return mc.port2; + } + + _readUrlAsString(aUrl) { + // Fetch script content as we can't use scriptloader's loadSubScript + // to evaluate http:// urls... + var scriptableStream = Cc[ + "@mozilla.org/scriptableinputstream;1" + ].getService(Ci.nsIScriptableInputStream); + + var channel = NetUtil.newChannel({ + uri: aUrl, + loadUsingSystemPrincipal: true, + }); + var input = channel.open(); + scriptableStream.init(input); + + var str; + var buffer = []; + + while ((str = scriptableStream.read(4096))) { + buffer.push(str); + } + + var output = buffer.join(""); + + scriptableStream.close(); + input.close(); + + var status; + if (channel instanceof Ci.nsIHttpChannel) { + status = channel.responseStatus; + } + + if (status == 404) { + throw new Error( + `Error while executing chrome script '${aUrl}':\n` + + "The script doesn't exist. Ensure you have registered it in " + + "'support-files' in your mochitest.ini." + ); + } + + return output; + } + + loadChromeScript(urlOrFunction, sandboxOptions) { + // Create a unique id for this chrome script + let uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].getService( + Ci.nsIUUIDGenerator + ); + let id = uuidGenerator.generateUUID().toString(); + + // Tells chrome code to evaluate this chrome script + let scriptArgs = { id, sandboxOptions }; + if (typeof urlOrFunction == "function") { + scriptArgs.function = { + body: "(" + urlOrFunction.toString() + ")();", + name: urlOrFunction.name, + }; + } else { + // Note: We need to do this in the child since, even though + // `_readUrlAsString` pretends to be synchronous, its channel + // winds up spinning the event loop when loading HTTP URLs. That + // leads to unexpected out-of-order operations if the child sends + // a message immediately after loading the script. + scriptArgs.function = { + body: this._readUrlAsString(urlOrFunction), + }; + scriptArgs.url = urlOrFunction; + } + this.sendAsyncMessage("SPLoadChromeScript", scriptArgs); + + // Returns a MessageManager like API in order to be + // able to communicate with this chrome script + let listeners = []; + let chromeScript = { + addMessageListener: (name, listener) => { + listeners.push({ name, listener }); + }, + + promiseOneMessage: name => + new Promise(resolve => { + chromeScript.addMessageListener(name, function listener(message) { + chromeScript.removeMessageListener(name, listener); + resolve(message); + }); + }), + + removeMessageListener: (name, listener) => { + listeners = listeners.filter( + o => o.name != name || o.listener != listener + ); + }, + + sendAsyncMessage: (name, message) => { + this.sendAsyncMessage("SPChromeScriptMessage", { id, name, message }); + }, + + sendQuery: (name, message) => { + return this.sendQuery("SPChromeScriptMessage", { id, name, message }); + }, + + destroy: () => { + listeners = []; + this._removeMessageListener("SPChromeScriptMessage", chromeScript); + }, + + receiveMessage: aMessage => { + let messageId = aMessage.json.id; + let name = aMessage.json.name; + let message = aMessage.json.message; + if (this.contentWindow) { + message = new StructuredCloneHolder(message).deserialize( + this.contentWindow + ); + } + // Ignore message from other chrome script + if (messageId != id) { + return null; + } + + let result; + if (aMessage.name == "SPChromeScriptMessage") { + for (let listener of listeners.filter(o => o.name == name)) { + result = listener.listener(message); + } + } + return result; + }, + }; + this._addMessageListener("SPChromeScriptMessage", chromeScript); + + return chromeScript; + } + + async importInMainProcess(importString) { + var message = await this.sendQuery("SPImportInMainProcess", importString); + if (message.hadError) { + throw new Error( + "SpecialPowers.importInMainProcess failed with error " + + message.errorMessage + ); + } + } + + get Services() { + return Services; + } + + /* + * Convenient shortcuts to the standard Components abbreviations. + */ + get Cc() { + return Cc; + } + get Ci() { + return Ci; + } + get Cu() { + return Cu; + } + get Cr() { + return Cr; + } + + get addProfilerMarker() { + return ChromeUtils.addProfilerMarker; + } + + get DOMWindowUtils() { + return this.contentWindow.windowUtils; + } + + getDOMWindowUtils(aWindow) { + if (aWindow == this.contentWindow) { + return aWindow.windowUtils; + } + + return bindDOMWindowUtils(Cu.unwaiveXrays(aWindow)); + } + + async toggleMuteState(aMuted, aWindow) { + let actor = aWindow + ? aWindow.windowGlobalChild.getActor("SpecialPowers") + : this; + return actor.sendQuery("SPToggleMuteAudio", { mute: aMuted }); + } + + /* + * A method to get a DOMParser that can't parse XUL. + */ + getNoXULDOMParser() { + // If we create it with a system subject principal (so it gets a + // nullprincipal), it won't be able to parse XUL by default. + return new DOMParser(); + } + + get InspectorUtils() { + return InspectorUtils; + } + + get PromiseDebugging() { + return PromiseDebugging; + } + + async waitForCrashes(aExpectingProcessCrash) { + if (!aExpectingProcessCrash) { + return; + } + + var crashIds = this._encounteredCrashDumpFiles + .filter(filename => { + return filename.length === 40 && filename.endsWith(".dmp"); + }) + .map(id => { + return id.slice(0, -4); // Strip the .dmp extension to get the ID + }); + + await this.sendQuery("SPProcessCrashManagerWait", { + crashIds, + }); + } + + async removeExpectedCrashDumpFiles(aExpectingProcessCrash) { + var success = true; + if (aExpectingProcessCrash) { + var message = { + op: "delete-crash-dump-files", + filenames: this._encounteredCrashDumpFiles, + }; + if (!(await this.sendQuery("SPProcessCrashService", message))) { + success = false; + } + } + this._encounteredCrashDumpFiles.length = 0; + return success; + } + + async findUnexpectedCrashDumpFiles() { + var self = this; + var message = { + op: "find-crash-dump-files", + crashDumpFilesToIgnore: this._unexpectedCrashDumpFiles, + }; + var crashDumpFiles = await this.sendQuery("SPProcessCrashService", message); + crashDumpFiles.forEach(function(aFilename) { + self._unexpectedCrashDumpFiles[aFilename] = true; + }); + return crashDumpFiles; + } + + removePendingCrashDumpFiles() { + var message = { + op: "delete-pending-crash-dump-files", + }; + return this.sendQuery("SPProcessCrashService", message); + } + + _setTimeout(callback, delay = 0) { + // for mochitest-browser + if (typeof this.chromeWindow != "undefined") { + this.chromeWindow.setTimeout(callback, delay); + } + // for mochitest-plain + else { + this.contentWindow.setTimeout(callback, delay); + } + } + + promiseTimeout(delay) { + return new Promise(resolve => { + this._setTimeout(resolve, delay); + }); + } + + _delayCallbackTwice(callback) { + let delayedCallback = () => { + let delayAgain = aCallback => { + // Using this._setTimeout doesn't work here + // It causes failures in mochtests that use + // multiple pushPrefEnv calls + // For chrome/browser-chrome mochitests + this._setTimeout(aCallback); + }; + delayAgain(delayAgain.bind(this, callback)); + }; + return delayedCallback; + } + + /* apply permissions to the system and when the test case is finished (SimpleTest.finish()) + we will revert the permission back to the original. + + inPermissions is an array of objects where each object has a type, action, context, ex: + [{'type': 'SystemXHR', 'allow': 1, 'context': document}, + {'type': 'SystemXHR', 'allow': Ci.nsIPermissionManager.PROMPT_ACTION, 'context': document}] + + Allow can be a boolean value of true/false or ALLOW_ACTION/DENY_ACTION/PROMPT_ACTION/UNKNOWN_ACTION + */ + async pushPermissions(inPermissions, callback) { + let permissions = []; + for (let perm of inPermissions) { + let principal = this._getPrincipalFromArg(perm.context); + permissions.push({ + ...perm, + context: null, + principal, + }); + } + + await this.sendQuery("PushPermissions", permissions).then(callback); + await this.promiseTimeout(0); + } + + async popPermissions(callback = null) { + await this.sendQuery("PopPermissions").then(callback); + await this.promiseTimeout(0); + } + + async flushPermissions(callback = null) { + await this.sendQuery("FlushPermissions").then(callback); + await this.promiseTimeout(0); + } + + /* + * This function should be used when specialpowers is in content process but + * it want to get the notification from chrome space. + * + * This function will call Services.obs.addObserver in SpecialPowersObserver + * (that is in chrome process) and forward the data received to SpecialPowers + * via messageManager. + * You can use this._addMessageListener("specialpowers-YOUR_TOPIC") to fire + * the callback. + * + * To get the expected data, you should modify + * SpecialPowersObserver.prototype._registerObservers.observe. Or the message + * you received from messageManager will only contain 'aData' from Service.obs. + */ + registerObservers(topic) { + var msg = { + op: "add", + observerTopic: topic, + }; + return this.sendQuery("SPObserverService", msg); + } + + setTestPluginEnabledState(newEnabledState, pluginName) { + return this.sendQuery("SPSetTestPluginEnabledState", { + newEnabledState, + pluginName, + }); + } + + async pushPrefEnv(inPrefs, callback = null) { + await this.sendQuery("PushPrefEnv", inPrefs).then(callback); + await this.promiseTimeout(0); + } + + async popPrefEnv(callback = null) { + await this.sendQuery("PopPrefEnv").then(callback); + await this.promiseTimeout(0); + } + + async flushPrefEnv(callback = null) { + await this.sendQuery("FlushPrefEnv").then(callback); + await this.promiseTimeout(0); + } + + _addObserverProxy(notification) { + if (notification in this._proxiedObservers) { + this._addMessageListener( + notification, + this._proxiedObservers[notification] + ); + } + } + _removeObserverProxy(notification) { + if (notification in this._proxiedObservers) { + this._removeMessageListener( + notification, + this._proxiedObservers[notification] + ); + } + } + + addObserver(obs, notification, weak) { + // Make sure the parent side exists, or we won't get any notifications. + this.sendAsyncMessage("Wakeup"); + + this._addObserverProxy(notification); + obs = Cu.waiveXrays(obs); + if ( + typeof obs == "object" && + obs.observe.name != "SpecialPowersCallbackWrapper" + ) { + obs.observe = WrapPrivileged.wrapCallback( + Cu.unwaiveXrays(obs.observe), + this.contentWindow + ); + } + Services.obs.addObserver(obs, notification, weak); + } + removeObserver(obs, notification) { + this._removeObserverProxy(notification); + Services.obs.removeObserver(Cu.waiveXrays(obs), notification); + } + notifyObservers(subject, topic, data) { + Services.obs.notifyObservers(subject, topic, data); + } + + /** + * An async observer is useful if you're listening for a + * notification that normally is only used by C++ code or chrome + * code (so it runs in the SystemGroup), but we need to know about + * it for a test (which runs as web content). If we used + * addObserver, we would assert when trying to enter web content + * from a runnabled labeled by the SystemGroup. An async observer + * avoids this problem. + */ + addAsyncObserver(obs, notification, weak) { + obs = Cu.waiveXrays(obs); + if ( + typeof obs == "object" && + obs.observe.name != "SpecialPowersCallbackWrapper" + ) { + obs.observe = WrapPrivileged.wrapCallback( + Cu.unwaiveXrays(obs.observe), + this.contentWindow + ); + } + let asyncObs = (...args) => { + Services.tm.dispatchToMainThread(() => { + if (typeof obs == "function") { + obs(...args); + } else { + obs.observe.call(undefined, ...args); + } + }); + }; + this._asyncObservers.set(obs, asyncObs); + Services.obs.addObserver(asyncObs, notification, weak); + } + removeAsyncObserver(obs, notification) { + let asyncObs = this._asyncObservers.get(Cu.waiveXrays(obs)); + Services.obs.removeObserver(asyncObs, notification); + } + + can_QI(obj) { + return obj.QueryInterface !== undefined; + } + do_QueryInterface(obj, iface) { + return obj.QueryInterface(Ci[iface]); + } + + call_Instanceof(obj1, obj2) { + obj1 = WrapPrivileged.unwrap(obj1); + obj2 = WrapPrivileged.unwrap(obj2); + return obj1 instanceof obj2; + } + + // Returns a privileged getter from an object. GetOwnPropertyDescriptor does + // not work here because xray wrappers don't properly implement it. + // + // This terribleness is used by dom/base/test/test_object.html because + // <object> and <embed> tags will spawn plugins if their prototype is touched, + // so we need to get and cache the getter of |hasRunningPlugin| if we want to + // call it without paradoxically spawning the plugin. + do_lookupGetter(obj, name) { + return Object.prototype.__lookupGetter__.call(obj, name); + } + + // Mimic the get*Pref API + getBoolPref(...args) { + return Services.prefs.getBoolPref(...args); + } + getIntPref(...args) { + return Services.prefs.getIntPref(...args); + } + getCharPref(...args) { + return Services.prefs.getCharPref(...args); + } + getComplexValue(prefName, iid) { + return Services.prefs.getComplexValue(prefName, iid); + } + + getParentBoolPref(prefName, defaultValue) { + return this._getParentPref(prefName, "BOOL", { defaultValue }); + } + getParentIntPref(prefName, defaultValue) { + return this._getParentPref(prefName, "INT", { defaultValue }); + } + getParentCharPref(prefName, defaultValue) { + return this._getParentPref(prefName, "CHAR", { defaultValue }); + } + + // Mimic the set*Pref API + setBoolPref(prefName, value) { + return this._setPref(prefName, "BOOL", value); + } + setIntPref(prefName, value) { + return this._setPref(prefName, "INT", value); + } + setCharPref(prefName, value) { + return this._setPref(prefName, "CHAR", value); + } + setComplexValue(prefName, iid, value) { + return this._setPref(prefName, "COMPLEX", value, iid); + } + + // Mimic the clearUserPref API + clearUserPref(prefName) { + let msg = { + op: "clear", + prefName, + prefType: "", + }; + return this.sendQuery("SPPrefService", msg); + } + + // Private pref functions to communicate to chrome + async _getParentPref(prefName, prefType, { defaultValue, iid }) { + let msg = { + op: "get", + prefName, + prefType, + iid, // Only used with complex prefs + defaultValue, // Optional default value + }; + let val = await this.sendQuery("SPPrefService", msg); + if (val == null) { + throw new Error(`Error getting pref '${prefName}'`); + } + return val; + } + _getPref(prefName, prefType, { defaultValue }) { + switch (prefType) { + case "BOOL": + return Services.prefs.getBoolPref(prefName); + case "INT": + return Services.prefs.getIntPref(prefName); + case "CHAR": + return Services.prefs.getCharPref(prefName); + } + return undefined; + } + _setPref(prefName, prefType, prefValue, iid) { + let msg = { + op: "set", + prefName, + prefType, + iid, // Only used with complex prefs + prefValue, + }; + return this.sendQuery("SPPrefService", msg); + } + + _getMUDV(window) { + return window.docShell.contentViewer; + } + // XXX: these APIs really ought to be removed, they're not e10s-safe. + // (also they're pretty Firefox-specific) + _getTopChromeWindow(window) { + return window.browsingContext.topChromeWindow; + } + _getAutoCompletePopup(window) { + return this._getTopChromeWindow(window).document.getElementById( + "PopupAutoComplete" + ); + } + addAutoCompletePopupEventListener(window, eventname, listener) { + this._getAutoCompletePopup(window).addEventListener(eventname, listener); + } + removeAutoCompletePopupEventListener(window, eventname, listener) { + this._getAutoCompletePopup(window).removeEventListener(eventname, listener); + } + get formHistory() { + let tmp = {}; + ChromeUtils.import("resource://gre/modules/FormHistory.jsm", tmp); + return tmp.FormHistory; + } + getFormFillController(window) { + return Cc["@mozilla.org/satchel/form-fill-controller;1"].getService( + Ci.nsIFormFillController + ); + } + attachFormFillControllerTo(window) { + this.getFormFillController().attachPopupElementToDocument( + window.document, + this._getAutoCompletePopup(window) + ); + } + detachFormFillControllerFrom(window) { + this.getFormFillController().detachFromDocument(window.document); + } + isBackButtonEnabled(window) { + return !this._getTopChromeWindow(window) + .document.getElementById("Browser:Back") + .hasAttribute("disabled"); + } + // XXX end of problematic APIs + + addChromeEventListener(type, listener, capture, allowUntrusted) { + this.docShell.chromeEventHandler.addEventListener( + type, + listener, + capture, + allowUntrusted + ); + } + removeChromeEventListener(type, listener, capture) { + this.docShell.chromeEventHandler.removeEventListener( + type, + listener, + capture + ); + } + + async generateMediaControlKeyTestEvent(event) { + await this.sendQuery("SPGenerateMediaControlKeyTestEvent", { event }); + } + + // Note: each call to registerConsoleListener MUST be paired with a + // call to postConsoleSentinel; when the callback receives the + // sentinel it will unregister itself (_after_ calling the + // callback). SimpleTest.expectConsoleMessages does this for you. + // If you register more than one console listener, a call to + // postConsoleSentinel will zap all of them. + registerConsoleListener(callback) { + let listener = new SPConsoleListener(callback, this.contentWindow); + Services.console.registerListener(listener); + + // listen for dom/console events as well + Services.obs.addObserver(listener, "console-api-log-event"); + } + postConsoleSentinel() { + Services.console.logStringMessage("SENTINEL"); + } + resetConsole() { + Services.console.reset(); + } + + getFullZoom(window) { + return BrowsingContext.getFromWindow(window).fullZoom; + } + + getDeviceFullZoom(window) { + return this._getMUDV(window).deviceFullZoomForTest; + } + setFullZoom(window, zoom) { + BrowsingContext.getFromWindow(window).fullZoom = zoom; + } + getTextZoom(window) { + return BrowsingContext.getFromWindow(window).textZoom; + } + setTextZoom(window, zoom) { + BrowsingContext.getFromWindow(window).textZoom = zoom; + } + + getOverrideDPPX(window) { + return this._getMUDV(window).overrideDPPX; + } + setOverrideDPPX(window, dppx) { + this._getMUDV(window).overrideDPPX = dppx; + } + + emulateMedium(window, mediaType) { + this._getMUDV(window).emulateMedium(mediaType); + } + stopEmulatingMedium(window) { + this._getMUDV(window).stopEmulatingMedium(); + } + + // Takes a snapshot of the given window and returns a <canvas> + // containing the image. When the window is same-process, the canvas + // is returned synchronously. When it is out-of-process (or when a + // BrowsingContext or FrameLoaderOwner is passed instead of a Window), + // a promise which resolves to such a canvas is returned instead. + snapshotWindowWithOptions(content, rect, bgcolor, options) { + function getImageData(rect, bgcolor, options) { + let el = content.document.createElementNS( + "http://www.w3.org/1999/xhtml", + "canvas" + ); + if (rect === undefined) { + rect = { + top: content.scrollY, + left: content.scrollX, + width: content.innerWidth, + height: content.innerHeight, + }; + } + if (bgcolor === undefined) { + bgcolor = "rgb(255,255,255)"; + } + if (options === undefined) { + options = {}; + } + + el.width = rect.width; + el.height = rect.height; + let ctx = el.getContext("2d"); + + let flags = 0; + for (let option in options) { + flags |= options[option] && ctx[option]; + } + + ctx.drawWindow( + content, + rect.left, + rect.top, + rect.width, + rect.height, + bgcolor, + flags + ); + + return ctx.getImageData(0, 0, el.width, el.height); + } + + let toCanvas = imageData => { + let el = this.document.createElementNS( + "http://www.w3.org/1999/xhtml", + "canvas" + ); + el.width = imageData.width; + el.height = imageData.height; + + if (ImageData.isInstance(imageData)) { + let ctx = el.getContext("2d"); + ctx.putImageData(imageData, 0, 0); + } + + return el; + }; + + if (Window.isInstance(content)) { + // Hack around tests that try to snapshot 0 width or height + // elements. + if (rect && !(rect.width && rect.height)) { + return toCanvas(rect); + } + + // This is an in-process window. Snapshot it synchronously. + return toCanvas(getImageData(rect, bgcolor, options)); + } + + // This is a remote window or frame. Snapshot it asynchronously and + // return a promise for the result. Alas, consumers expect us to + // return a <canvas> element rather than an ImageData object, so we + // need to convert the result from the remote snapshot to a local + // canvas. + let promise = this.spawn( + content, + [rect, bgcolor, options], + getImageData + ).then(toCanvas); + if (Cu.isXrayWrapper(this.contentWindow)) { + return new this.contentWindow.Promise((resolve, reject) => { + promise.then(resolve, reject); + }); + } + return promise; + } + + snapshotWindow(win, withCaret, rect, bgcolor) { + return this.snapshotWindowWithOptions(win, rect, bgcolor, { + DRAWWINDOW_DRAW_CARET: withCaret, + }); + } + + snapshotRect(win, rect, bgcolor) { + return this.snapshotWindowWithOptions(win, rect, bgcolor); + } + + gc() { + this.contentWindow.windowUtils.garbageCollect(); + } + + forceGC() { + Cu.forceGC(); + } + + forceShrinkingGC() { + Cu.forceShrinkingGC(); + } + + forceCC() { + Cu.forceCC(); + } + + finishCC() { + Cu.finishCC(); + } + + ccSlice(budget) { + Cu.ccSlice(budget); + } + + // Due to various dependencies between JS objects and C++ objects, an ordinary + // forceGC doesn't necessarily clear all unused objects, thus the GC and CC + // needs to run several times and when no other JS is running. + // The current number of iterations has been determined according to massive + // cross platform testing. + exactGC(callback) { + let count = 0; + + function genGCCallback(cb) { + return function() { + Cu.forceCC(); + if (++count < 3) { + Cu.schedulePreciseGC(genGCCallback(cb)); + } else if (cb) { + cb(); + } + }; + } + + Cu.schedulePreciseGC(genGCCallback(callback)); + } + + nondeterministicGetWeakMapKeys(m) { + let keys = ChromeUtils.nondeterministicGetWeakMapKeys(m); + if (!keys) { + return undefined; + } + return this.contentWindow.Array.from(keys); + } + + getMemoryReports() { + try { + Cc["@mozilla.org/memory-reporter-manager;1"] + .getService(Ci.nsIMemoryReporterManager) + .getReports( + () => {}, + null, + () => {}, + null, + false + ); + } catch (e) {} + } + + setGCZeal(zeal) { + Cu.setGCZeal(zeal); + } + + isMainProcess() { + try { + return ( + Services.appinfo.processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT + ); + } catch (e) {} + return true; + } + + get XPCOMABI() { + if (this._xpcomabi != null) { + return this._xpcomabi; + } + + var xulRuntime = Services.appinfo.QueryInterface(Ci.nsIXULRuntime); + + this._xpcomabi = xulRuntime.XPCOMABI; + return this._xpcomabi; + } + + // The optional aWin parameter allows the caller to specify a given window in + // whose scope the runnable should be dispatched. If aFun throws, the + // exception will be reported to aWin. + executeSoon(aFun, aWin) { + // Create the runnable in the scope of aWin to avoid running into COWs. + var runnable = {}; + if (aWin) { + runnable = Cu.createObjectIn(aWin); + } + runnable.run = aFun; + Cu.dispatch(runnable, aWin); + } + + get OS() { + if (this._os != null) { + return this._os; + } + + this._os = Services.appinfo.OS; + return this._os; + } + + get useRemoteSubframes() { + return this.docShell.nsILoadContext.useRemoteSubframes; + } + + addSystemEventListener(target, type, listener, useCapture) { + Services.els.addSystemEventListener(target, type, listener, useCapture); + } + removeSystemEventListener(target, type, listener, useCapture) { + Services.els.removeSystemEventListener(target, type, listener, useCapture); + } + + // helper method to check if the event is consumed by either default group's + // event listener or system group's event listener. + defaultPreventedInAnyGroup(event) { + // FYI: Event.defaultPrevented returns false in content context if the + // event is consumed only by system group's event listeners. + return event.defaultPrevented; + } + + getDOMRequestService() { + var serv = Services.DOMRequest; + var res = {}; + var props = [ + "createRequest", + "createCursor", + "fireError", + "fireSuccess", + "fireDone", + "fireDetailedError", + ]; + for (var i in props) { + let prop = props[i]; + res[prop] = function() { + return serv[prop].apply(serv, arguments); + }; + } + return Cu.cloneInto(res, this.contentWindow, { cloneFunctions: true }); + } + + addCategoryEntry(category, entry, value, persists, replace) { + Services.catMan.addCategoryEntry(category, entry, value, persists, replace); + } + + deleteCategoryEntry(category, entry, persists) { + Services.catMan.deleteCategoryEntry(category, entry, persists); + } + openDialog(win, args) { + return win.openDialog.apply(win, args); + } + // This is a blocking call which creates and spins a native event loop + spinEventLoop(win) { + // simply do a sync XHR back to our windows location. + var syncXHR = new win.XMLHttpRequest(); + syncXHR.open("GET", win.location, false); + syncXHR.send(); + } + + // :jdm gets credit for this. ex: getPrivilegedProps(window, 'location.href'); + getPrivilegedProps(obj, props) { + var parts = props.split("."); + for (var i = 0; i < parts.length; i++) { + var p = parts[i]; + if (obj[p] != undefined) { + obj = obj[p]; + } else { + return null; + } + } + return obj; + } + + _browsingContextForTarget(target) { + if (BrowsingContext.isInstance(target)) { + return target; + } + if (Element.isInstance(target)) { + return target.browsingContext; + } + + return BrowsingContext.getFromWindow(target); + } + + getBrowsingContextID(target) { + return this._browsingContextForTarget(target).id; + } + + *getGroupTopLevelWindows(target) { + let { group } = this._browsingContextForTarget(target); + for (let bc of group.getToplevels()) { + yield bc.window; + } + } + + /** + * Runs a task in the context of the given frame, and returns a + * promise which resolves to the return value of that task. + * + * The given frame may be in-process or out-of-process. Either way, + * the task will run asynchronously, in a sandbox with access to the + * frame's content window via its `content` global. Any arguments + * passed will be copied via structured clone, as will its return + * value. + * + * The sandbox also has access to an Assert object, as provided by + * Assert.jsm. Any assertion methods called before the task resolves + * will be relayed back to the test environment of the caller. + * + * @param {BrowsingContext or FrameLoaderOwner or WindowProxy} target + * The target in which to run the task. This may be any element + * which implements the FrameLoaderOwner interface (including + * HTML <iframe> elements and XUL <browser> elements) or a + * WindowProxy (either in-process or remote). + * @param {Array<any>} args + * An array of arguments to pass to the task. All arguments + * must be structured clone compatible, and will be cloned + * before being passed to the task. + * @param {function} task + * The function to run in the context of the target. The + * function will be stringified and re-evaluated in the context + * of the target's content window. It may return any structured + * clone compatible value, or a Promise which resolves to the + * same, which will be returned to the caller. + * + * @returns {Promise<any>} + * A promise which resolves to the return value of the task, or + * which rejects if the task raises an exception. As this is + * being written, the rejection value will always be undefined + * in the cases where the task throws an error, though that may + * change in the future. + */ + spawn(target, args, task) { + let browsingContext = this._browsingContextForTarget(target); + + return this.sendQuery("Spawn", { + browsingContext, + args, + task: String(task), + caller: Cu.getFunctionSourceLocation(task), + hasHarness: typeof this.SimpleTest === "object", + imports: this._spawnTaskImports, + }); + } + + /** + * Like `spawn`, but spawns a chrome task in the parent process, + * instead. The task additionally has access to `windowGlobalParent` + * and `browsingContext` globals corresponding to the window from + * which the task was spawned. + */ + spawnChrome(args, task) { + return this.sendQuery("SpawnChrome", { + args, + task: String(task), + caller: Cu.getFunctionSourceLocation(task), + imports: this._spawnTaskImports, + }); + } + + snapshotContext(target, rect, background) { + let browsingContext = this._browsingContextForTarget(target); + + return this.sendQuery("Snapshot", { + browsingContext, + rect, + background, + }).then(imageData => { + return this.contentWindow.createImageBitmap(imageData); + }); + } + + getSecurityState(target) { + let browsingContext = this._browsingContextForTarget(target); + + return this.sendQuery("SecurityState", { + browsingContext, + }); + } + + _spawnTask(task, args, caller, taskId, imports) { + let sb = new SpecialPowersSandbox( + null, + data => { + this.sendAsyncMessage("ProxiedAssert", { taskId, data }); + }, + { imports } + ); + + sb.sandbox.SpecialPowers = this; + sb.sandbox.ContentTaskUtils = ContentTaskUtils; + for (let [global, prop] of Object.entries({ + content: "contentWindow", + docShell: "docShell", + })) { + Object.defineProperty(sb.sandbox, global, { + get: () => { + return this[prop]; + }, + enumerable: true, + }); + } + + return sb.execute(task, args, caller); + } + + /** + * Automatically imports the given symbol from the given JSM for any + * task spawned by this SpecialPowers instance. + */ + addTaskImport(symbol, url) { + this._spawnTaskImports[symbol] = url; + } + + get SimpleTest() { + return this._SimpleTest || this.contentWindow.wrappedJSObject.SimpleTest; + } + set SimpleTest(val) { + this._SimpleTest = val; + } + + /** + * Sets this actor as the default assertion result handler for tasks + * which originate in a window without a test harness. + */ + setAsDefaultAssertHandler() { + this.sendAsyncMessage("SetAsDefaultAssertHandler"); + } + + getFocusedElementForWindow(targetWindow, aDeep) { + var outParam = {}; + Services.focus.getFocusedElementForWindow(targetWindow, aDeep, outParam); + return outParam.value; + } + + get focusManager() { + return Services.focus; + } + + activeWindow() { + return Services.focus.activeWindow; + } + + focusedWindow() { + return Services.focus.focusedWindow; + } + + focus(aWindow) { + // This is called inside TestRunner._makeIframe without aWindow, because of assertions in oop mochitests + // With aWindow, it is called in SimpleTest.waitForFocus to allow popup window opener focus switching + if (aWindow) { + aWindow.focus(); + } + + try { + let actor = aWindow + ? aWindow.windowGlobalChild.getActor("SpecialPowers") + : this; + actor.sendAsyncMessage("SpecialPowers.Focus", {}); + } catch (e) { + Cu.reportError(e); + } + } + + getClipboardData(flavor, whichClipboard) { + if (whichClipboard === undefined) { + whichClipboard = Services.clipboard.kGlobalClipboard; + } + + var xferable = Cc["@mozilla.org/widget/transferable;1"].createInstance( + Ci.nsITransferable + ); + xferable.init(this.docShell); + xferable.addDataFlavor(flavor); + Services.clipboard.getData(xferable, whichClipboard); + var data = {}; + try { + xferable.getTransferData(flavor, data); + } catch (e) {} + data = data.value || null; + if (data == null) { + return ""; + } + + return data.QueryInterface(Ci.nsISupportsString).data; + } + + clipboardCopyString(str) { + Cc["@mozilla.org/widget/clipboardhelper;1"] + .getService(Ci.nsIClipboardHelper) + .copyString(str); + } + + supportsSelectionClipboard() { + return Services.clipboard.supportsSelectionClipboard(); + } + + swapFactoryRegistration(cid, contractID, newFactory) { + newFactory = Cu.waiveXrays(newFactory); + + var componentRegistrar = Components.manager.QueryInterface( + Ci.nsIComponentRegistrar + ); + + var currentCID = componentRegistrar.contractIDToCID(contractID); + var currentFactory = Components.manager.getClassObject( + Cc[contractID], + Ci.nsIFactory + ); + if (cid) { + componentRegistrar.unregisterFactory(currentCID, currentFactory); + } else { + let uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].getService( + Ci.nsIUUIDGenerator + ); + cid = uuidGenerator.generateUUID(); + } + + // Restore the original factory. + componentRegistrar.registerFactory(cid, "", contractID, newFactory); + return { originalCID: currentCID }; + } + + _getElement(aWindow, id) { + return typeof id == "string" ? aWindow.document.getElementById(id) : id; + } + + dispatchEvent(aWindow, target, event) { + var el = this._getElement(aWindow, target); + return el.dispatchEvent(event); + } + + get isDebugBuild() { + return Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2) + .isDebugBuild; + } + assertionCount() { + var debugsvc = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2); + return debugsvc.assertionCount; + } + + /** + * @param arg one of the following: + * - A URI string. + * - A document node. + * - A dictionary including a URL (`url`) and origin attributes (`attr`). + */ + _getPrincipalFromArg(arg) { + arg = WrapPrivileged.unwrap(Cu.unwaiveXrays(arg)); + + if (arg.nodePrincipal) { + // It's a document. + return arg.nodePrincipal; + } + + let secMan = Services.scriptSecurityManager; + if (typeof arg == "string") { + // It's a URL. + let uri = Services.io.newURI(arg); + return secMan.createContentPrincipal(uri, {}); + } + + let uri = Services.io.newURI(arg.url); + let attrs = arg.originAttributes || {}; + return secMan.createContentPrincipal(uri, attrs); + } + + async addPermission(type, allow, arg, expireType, expireTime) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return; // nothing to do + } + + let permission = allow; + if (typeof permission === "boolean") { + permission = + Ci.nsIPermissionManager[allow ? "ALLOW_ACTION" : "DENY_ACTION"]; + } + + var msg = { + op: "add", + type, + permission, + principal, + expireType: typeof expireType === "number" ? expireType : 0, + expireTime: typeof expireTime === "number" ? expireTime : 0, + }; + + await this.sendQuery("SPPermissionManager", msg); + } + + /** + * @param type see nsIPermissionsManager::testPermissionFromPrincipal. + * @param arg one of the following: + * - A URI string. + * - A document node. + * - A dictionary including a URL (`url`) and origin attributes (`attr`). + */ + async removePermission(type, arg) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return; // nothing to do + } + + var msg = { + op: "remove", + type, + principal, + }; + + await this.sendQuery("SPPermissionManager", msg); + } + + async hasPermission(type, arg) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return true; // system principals have all permissions + } + + var msg = { + op: "has", + type, + principal, + }; + + return this.sendQuery("SPPermissionManager", msg); + } + + async testPermission(type, value, arg) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return true; // system principals have all permissions + } + + var msg = { + op: "test", + type, + value, + principal, + }; + return this.sendQuery("SPPermissionManager", msg); + } + + isContentWindowPrivate(win) { + return PrivateBrowsingUtils.isContentWindowPrivate(win); + } + + async notifyObserversInParentProcess(subject, topic, data) { + if (subject) { + throw new Error("Can't send subject to another process!"); + } + if (this.isMainProcess()) { + this.notifyObservers(subject, topic, data); + return; + } + var msg = { + op: "notify", + observerTopic: topic, + observerData: data, + }; + await this.sendQuery("SPObserverService", msg); + } + + removeAllServiceWorkerData() { + return this.sendQuery("SPRemoveAllServiceWorkers", {}); + } + + removeServiceWorkerDataForExampleDomain() { + return this.sendQuery("SPRemoveServiceWorkerDataForExampleDomain", {}); + } + + cleanUpSTSData(origin, flags) { + return this.sendQuery("SPCleanUpSTSData", { origin, flags: flags || 0 }); + } + + async requestDumpCoverageCounters(cb) { + // We want to avoid a roundtrip between child and parent. + if (!PerTestCoverageUtils.enabled) { + return; + } + + await this.sendQuery("SPRequestDumpCoverageCounters", {}); + } + + async requestResetCoverageCounters(cb) { + // We want to avoid a roundtrip between child and parent. + if (!PerTestCoverageUtils.enabled) { + return; + } + await this.sendQuery("SPRequestResetCoverageCounters", {}); + } + + loadExtension(ext, handler) { + if (this._extensionListeners == null) { + this._extensionListeners = new Set(); + + this._addMessageListener("SPExtensionMessage", msg => { + for (let listener of this._extensionListeners) { + try { + listener(msg); + } catch (e) { + Cu.reportError(e); + } + } + }); + } + + // Note, this is not the addon is as used by the AddonManager etc, + // this is just an identifier used for specialpowers messaging + // between this content process and the chrome process. + let id = this._nextExtensionID++; + + handler = Cu.waiveXrays(handler); + ext = Cu.waiveXrays(ext); + + let sp = this; + let state = "uninitialized"; + let extension = { + get state() { + return state; + }, + + startup() { + state = "pending"; + return sp.sendQuery("SPStartupExtension", { id }).then( + () => { + state = "running"; + }, + () => { + state = "failed"; + sp._extensionListeners.delete(listener); + return Promise.reject("startup failed"); + } + ); + }, + + unload() { + state = "unloading"; + return sp.sendQuery("SPUnloadExtension", { id }).finally(() => { + sp._extensionListeners.delete(listener); + state = "unloaded"; + }); + }, + + sendMessage(...args) { + sp.sendAsyncMessage("SPExtensionMessage", { id, args }); + }, + + grantActiveTab(tabId) { + sp.sendAsyncMessage("SPExtensionGrantActiveTab", { id, tabId }); + }, + }; + + this.sendAsyncMessage("SPLoadExtension", { ext, id }); + + let listener = msg => { + if (msg.data.id == id) { + if (msg.data.type == "extensionSetId") { + extension.id = msg.data.args[0]; + extension.uuid = msg.data.args[1]; + } else if (msg.data.type in handler) { + handler[msg.data.type]( + ...Cu.cloneInto(msg.data.args, this.contentWindow) + ); + } else { + dump(`Unexpected: ${msg.data.type}\n`); + } + } + }; + + this._extensionListeners.add(listener); + return extension; + } + + invalidateExtensionStorageCache() { + this.notifyObserversInParentProcess( + null, + "extension-invalidate-storage-cache", + "" + ); + } + + allowMedia(window, enable) { + window.docShell.allowMedia = enable; + } + + createChromeCache(name, url) { + let principal = this._getPrincipalFromArg(url); + return new this.contentWindow.CacheStorage(name, principal); + } + + loadChannelAndReturnStatus(url, loadUsingSystemPrincipal) { + const BinaryInputStream = Components.Constructor( + "@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream" + ); + + return new Promise(function(resolve) { + let listener = { + httpStatus: 0, + + onStartRequest(request) { + request.QueryInterface(Ci.nsIHttpChannel); + this.httpStatus = request.responseStatus; + }, + + onDataAvailable(request, stream, offset, count) { + new BinaryInputStream(stream).readByteArray(count); + }, + + onStopRequest(request, status) { + /* testing here that the redirect was not followed. If it was followed + we would see a http status of 200 and status of NS_OK */ + + let httpStatus = this.httpStatus; + resolve({ status, httpStatus }); + }, + }; + let uri = NetUtil.newURI(url); + let channel = NetUtil.newChannel({ uri, loadUsingSystemPrincipal }); + + channel.loadFlags |= Ci.nsIChannel.LOAD_DOCUMENT_URI; + channel.QueryInterface(Ci.nsIHttpChannelInternal); + channel.documentURI = uri; + channel.asyncOpen(listener); + }); + } + + get ParserUtils() { + if (this._pu != null) { + return this._pu; + } + + let pu = Cc["@mozilla.org/parserutils;1"].getService(Ci.nsIParserUtils); + // We need to create and return our own wrapper. + this._pu = { + sanitize(src, flags) { + return pu.sanitize(src, flags); + }, + convertToPlainText(src, flags, wrapCol) { + return pu.convertToPlainText(src, flags, wrapCol); + }, + parseFragment(fragment, flags, isXML, baseURL, element) { + let baseURI = baseURL ? NetUtil.newURI(baseURL) : null; + return pu.parseFragment( + WrapPrivileged.unwrap(fragment), + flags, + isXML, + baseURI, + WrapPrivileged.unwrap(element) + ); + }, + }; + return this._pu; + } + + createDOMWalker(node, showAnonymousContent) { + node = WrapPrivileged.unwrap(node); + let walker = Cc["@mozilla.org/inspector/deep-tree-walker;1"].createInstance( + Ci.inIDeepTreeWalker + ); + walker.showAnonymousContent = showAnonymousContent; + walker.init(node.ownerDocument, NodeFilter.SHOW_ALL); + walker.currentNode = node; + let contentWindow = this.contentWindow; + return { + get firstChild() { + return WrapPrivileged.wrap(walker.firstChild(), contentWindow); + }, + get lastChild() { + return WrapPrivileged.wrap(walker.lastChild(), contentWindow); + }, + }; + } + + observeMutationEvents(mo, node, nativeAnonymousChildList, subtree) { + WrapPrivileged.unwrap(mo).observe(WrapPrivileged.unwrap(node), { + nativeAnonymousChildList, + subtree, + }); + } + + doCommand(window, cmd, param) { + switch (cmd) { + case "cmd_align": + case "cmd_backgroundColor": + case "cmd_fontColor": + case "cmd_fontFace": + case "cmd_fontSize": + case "cmd_highlight": + case "cmd_insertImageNoUI": + case "cmd_insertLinkNoUI": + case "cmd_paragraphState": + let params = Cu.createCommandParams(); + params.setStringValue("state_attribute", param); + return window.docShell.doCommandWithParams(cmd, params); + default: + return window.docShell.doCommand(cmd); + } + } + + isCommandEnabled(window, cmd) { + return window.docShell.isCommandEnabled(cmd); + } + + setCommandNode(window, node) { + return window.docShell.contentViewer + .QueryInterface(Ci.nsIContentViewerEdit) + .setCommandNode(node); + } + + /* Bug 1339006 Runnables of nsIURIClassifier.classify may be labeled by + * SystemGroup, but some test cases may run as web content. That would assert + * when trying to enter web content from a runnable labeled by the + * SystemGroup. To avoid that, we run classify from SpecialPowers which is + * chrome-privileged and allowed to run inside SystemGroup + */ + + doUrlClassify(principal, eventTarget, callback) { + let classifierService = Cc[ + "@mozilla.org/url-classifier/dbservice;1" + ].getService(Ci.nsIURIClassifier); + + let wrapCallback = (...args) => { + Services.tm.dispatchToMainThread(() => { + if (typeof callback == "function") { + callback(...args); + } else { + callback.onClassifyComplete.call(undefined, ...args); + } + }); + }; + + return classifierService.classify( + WrapPrivileged.unwrap(principal), + eventTarget, + wrapCallback + ); + } + + // TODO: Bug 1353701 - Supports custom event target for labelling. + doUrlClassifyLocal(uri, tables, callback) { + let classifierService = Cc[ + "@mozilla.org/url-classifier/dbservice;1" + ].getService(Ci.nsIURIClassifier); + + let wrapCallback = results => { + Services.tm.dispatchToMainThread(() => { + if (typeof callback == "function") { + callback(WrapPrivileged.wrap(results, this.contentWindow)); + } else { + callback.onClassifyComplete.call( + undefined, + WrapPrivileged.wrap(results, this.contentWindow) + ); + } + }); + }; + + let feature = classifierService.createFeatureWithTables( + "test", + tables.split(","), + [] + ); + return classifierService.asyncClassifyLocalWithFeatures( + WrapPrivileged.unwrap(uri), + [feature], + Ci.nsIUrlClassifierFeature.blocklist, + wrapCallback + ); + } +} + +SpecialPowersChild.prototype._proxiedObservers = { + "specialpowers-http-notify-request": function(aMessage) { + let uri = aMessage.json.uri; + Services.obs.notifyObservers( + null, + "specialpowers-http-notify-request", + uri + ); + }, + + "specialpowers-service-worker-shutdown": function(aMessage) { + Services.obs.notifyObservers(null, "specialpowers-service-worker-shutdown"); + }, + + "specialpowers-csp-on-violate-policy": function(aMessage) { + let subject = null; + + try { + subject = Services.io.newURI(aMessage.data.subject); + } catch (ex) { + // if it's not a valid URI it must be an nsISupportsCString + subject = Cc["@mozilla.org/supports-cstring;1"].createInstance( + Ci.nsISupportsCString + ); + subject.data = aMessage.data.subject; + } + Services.obs.notifyObservers( + subject, + "specialpowers-csp-on-violate-policy", + aMessage.data.data + ); + }, + + "specialpowers-xfo-on-violate-policy": function(aMessage) { + let subject = Services.io.newURI(aMessage.data.subject); + Services.obs.notifyObservers( + subject, + "specialpowers-xfo-on-violate-policy", + aMessage.data.data + ); + }, +}; + +SpecialPowersChild.prototype.EARLY_BETA_OR_EARLIER = + AppConstants.EARLY_BETA_OR_EARLIER; diff --git a/testing/specialpowers/content/SpecialPowersEventUtils.jsm b/testing/specialpowers/content/SpecialPowersEventUtils.jsm new file mode 100644 index 0000000000..e1557d509d --- /dev/null +++ b/testing/specialpowers/content/SpecialPowersEventUtils.jsm @@ -0,0 +1,42 @@ +/* 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 = ["EventUtils"]; + +/** + * Loads a stub copy of EventUtils.js which can be used by things like + * content tasks without holding any direct references to windows. + */ + +const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); + +let EventUtils = {}; + +EventUtils.window = {}; +EventUtils.parent = EventUtils.window; +EventUtils._EU_Ci = Ci; +EventUtils._EU_Cc = Cc; + +EventUtils.synthesizeClick = element => + new Promise(resolve => { + element.addEventListener("click", () => resolve(), { once: true }); + + EventUtils.synthesizeMouseAtCenter( + element, + { type: "mousedown", isSynthesized: false }, + element.ownerGlobal + ); + EventUtils.synthesizeMouseAtCenter( + element, + { type: "mouseup", isSynthesized: false }, + element.ownerGlobal + ); + }); + +Services.scriptloader.loadSubScript( + "chrome://mochikit/content/tests/SimpleTest/EventUtils.js", + EventUtils +); diff --git a/testing/specialpowers/content/SpecialPowersParent.jsm b/testing/specialpowers/content/SpecialPowersParent.jsm new file mode 100644 index 0000000000..2aad29b6a5 --- /dev/null +++ b/testing/specialpowers/content/SpecialPowersParent.jsm @@ -0,0 +1,1304 @@ +/* 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( + "resource://gre/modules/AppConstants.jsm" +); +var { XPCOMUtils } = ChromeUtils.import( + "resource://gre/modules/XPCOMUtils.jsm" +); +var { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm"); + +XPCOMUtils.defineLazyModuleGetters(this, { + ExtensionData: "resource://gre/modules/Extension.jsm", + ExtensionTestCommon: "resource://testing-common/ExtensionTestCommon.jsm", + PerTestCoverageUtils: "resource://testing-common/PerTestCoverageUtils.jsm", + ServiceWorkerCleanUp: "resource://gre/modules/ServiceWorkerCleanUp.jsm", + SpecialPowersSandbox: "resource://specialpowers/SpecialPowersSandbox.jsm", + HiddenFrame: "resource://gre/modules/HiddenFrame.jsm", +}); + +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( + "resource://gre/modules/ExtensionUtils.jsm" + ).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", + { category: "Test" }, + 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. + } +} diff --git a/testing/specialpowers/content/SpecialPowersSandbox.jsm b/testing/specialpowers/content/SpecialPowersSandbox.jsm new file mode 100644 index 0000000000..b5a2fe46ab --- /dev/null +++ b/testing/specialpowers/content/SpecialPowersSandbox.jsm @@ -0,0 +1,143 @@ +/* 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/. */ + +/** + * This modules handles creating and provisioning Sandboxes for + * executing cross-process code from SpecialPowers. This allows all such + * sandboxes to have a similar environment, and in particular allows + * them to run test assertions in the target process and propagate + * results back to the caller. + */ + +var EXPORTED_SYMBOLS = ["SpecialPowersSandbox"]; + +ChromeUtils.defineModuleGetter( + this, + "Assert", + "resource://testing-common/Assert.jsm" +); + +// Note: When updating the set of globals exposed to sandboxes by +// default, please also update the ESLint plugin rule defined in +// import-content-task-globals.js. +const SANDBOX_GLOBALS = [ + "Blob", + "ChromeUtils", + "FileReader", + "TextDecoder", + "TextEncoder", + "URL", +]; +const EXTRA_IMPORTS = { + EventUtils: "resource://specialpowers/SpecialPowersEventUtils.jsm", + Services: "resource://gre/modules/Services.jsm", +}; + +let expectFail = false; +function expectingFail(fn) { + try { + expectFail = true; + fn(); + } finally { + expectFail = false; + } +} + +class SpecialPowersSandbox { + constructor(name, reportCallback, opts = {}) { + this.name = name; + this.reportCallback = reportCallback; + + this._Assert = null; + + this.sandbox = Cu.Sandbox( + Cu.getGlobalForObject({}), + Object.assign( + { wantGlobalProperties: SANDBOX_GLOBALS }, + opts.sandboxOptions + ) + ); + + for (let prop of ["assert", "Assert"]) { + Object.defineProperty(this.sandbox, prop, { + get: () => { + return this.Assert; + }, + enumerable: true, + configurable: true, + }); + } + + let imports = { + ...EXTRA_IMPORTS, + ...opts.imports, + }; + for (let [symbol, url] of Object.entries(imports)) { + ChromeUtils.defineModuleGetter(this.sandbox, symbol, url); + } + + // Note: When updating the set of globals exposed to sandboxes by + // default, please also update the ESLint plugin rule defined in + // import-content-task-globals.js. + Object.assign(this.sandbox, { + BrowsingContext, + InspectorUtils, + ok: (...args) => { + this.Assert.ok(...args); + }, + is: (...args) => { + this.Assert.equal(...args); + }, + isnot: (...args) => { + this.Assert.notEqual(...args); + }, + todo: (...args) => { + expectingFail(() => this.Assert.ok(...args)); + }, + todo_is: (...args) => { + expectingFail(() => this.Assert.equal(...args)); + }, + info: info => { + this.reportCallback({ info }); + }, + }); + } + + get Assert() { + if (!this._Assert) { + this._Assert = new Assert((err, message, stack) => { + this.report(err, message, stack); + }); + } + return this._Assert; + } + + report(err, name, stack) { + let diag; + if (err) { + diag = + `got ${uneval(err.actual)}, expected ${uneval(err.expected)} ` + + `(operator ${err.operator})`; + } + + this.reportCallback({ + name, + diag, + passed: !err, + stack: stack && stack.formattedStack, + expectFail, + }); + } + + execute(task, args, caller) { + let func = Cu.evalInSandbox( + `(${task})`, + this.sandbox, + undefined, + caller.filename, + caller.lineNumber + ); + return func(...args); + } +} diff --git a/testing/specialpowers/content/WrapPrivileged.jsm b/testing/specialpowers/content/WrapPrivileged.jsm new file mode 100644 index 0000000000..5c6fd4df7d --- /dev/null +++ b/testing/specialpowers/content/WrapPrivileged.jsm @@ -0,0 +1,415 @@ +/* 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"; + +/** + * This module handles wrapping privileged objects so that they can be exposed + * to unprivileged contexts. It is only to be used in automated tests. + * + * Its exact semantics are also liable to change at any time, so any callers + * relying on undocumented behavior or subtle platform features should expect + * breakage. Those callers should, wherever possible, migrate to fully + * chrome-privileged scripts when they need to interact with privileged APIs. + */ + +/* globals XPCNativeWrapper */ + +Cu.crashIfNotInAutomation(); + +var EXPORTED_SYMBOLS = ["WrapPrivileged"]; + +let wrappedObjects = new WeakMap(); +let perWindowInfo = new WeakMap(); +let noAutoWrap = new WeakSet(); + +function isWrappable(x) { + if (typeof x === "object") { + return x !== null; + } + return typeof x === "function"; +} + +function isWrapper(x) { + try { + return isWrappable(x) && wrappedObjects.has(x); + } catch (e) { + // If `x` is a remote object proxy, trying to access an unexpected property + // on it will throw a security error, even though we're chrome privileged. + // However, remote proxies are not SpecialPowers wrappers, so: + return false; + } +} + +function unwrapIfWrapped(x) { + return isWrapper(x) ? unwrapPrivileged(x) : x; +} + +function wrapIfUnwrapped(x, w) { + return isWrapper(x) ? x : wrapPrivileged(x, w); +} + +function isObjectOrArray(obj) { + if (Object(obj) !== obj) { + return false; + } + let arrayClasses = [ + "Object", + "Array", + "Int8Array", + "Uint8Array", + "Int16Array", + "Uint16Array", + "Int32Array", + "Uint32Array", + "Float32Array", + "Float64Array", + "Uint8ClampedArray", + ]; + let className = Cu.getClassName(obj, true); + return arrayClasses.includes(className); +} + +// In general, we want Xray wrappers for content DOM objects, because waiving +// Xray gives us Xray waiver wrappers that clamp the principal when we cross +// compartment boundaries. However, there are some exceptions where we want +// to use a waiver: +// +// * Xray adds some gunk to toString(), which has the potential to confuse +// consumers that aren't expecting Xray wrappers. Since toString() is a +// non-privileged method that returns only strings, we can just waive Xray +// for that case. +// +// * We implement Xrays to pure JS [[Object]] and [[Array]] instances that +// filter out tricky things like callables. This is the right thing for +// security in general, but tends to break tests that try to pass object +// literals into SpecialPowers. So we waive [[Object]] and [[Array]] +// instances before inspecting properties. +// +// * When we don't have meaningful Xray semantics, we create an Opaque +// XrayWrapper for security reasons. For test code, we generally want to see +// through that sort of thing. +function waiveXraysIfAppropriate(obj, propName) { + if ( + propName == "toString" || + isObjectOrArray(obj) || + /Opaque/.test(Object.prototype.toString.call(obj)) + ) { + return XPCNativeWrapper.unwrap(obj); + } + return obj; +} + +// We can't call apply() directy on Xray-wrapped functions, so we have to be +// clever. +function doApply(fun, invocant, args) { + // We implement Xrays to pure JS [[Object]] instances that filter out tricky + // things like callables. This is the right thing for security in general, + // but tends to break tests that try to pass object literals into + // SpecialPowers. So we waive [[Object]] instances when they're passed to a + // SpecialPowers-wrapped callable. + // + // Note that the transitive nature of Xray waivers means that any property + // pulled off such an object will also be waived, and so we'll get principal + // clamping for Xrayed DOM objects reached from literals, so passing things + // like {l : xoWin.location} won't work. Hopefully the rabbit hole doesn't + // go that deep. + args = args.map(x => (isObjectOrArray(x) ? Cu.waiveXrays(x) : x)); + return Reflect.apply(fun, invocant, args); +} + +function wrapPrivileged(obj, win) { + // Primitives pass straight through. + if (!isWrappable(obj)) { + return obj; + } + + // No double wrapping. + if (isWrapper(obj)) { + throw new Error("Trying to double-wrap object!"); + } + + let { windowID, proxies, handler } = perWindowInfo.get(win) || {}; + // |windowUtils| is undefined if |win| is a non-window object + // such as a sandbox. + let currentID = win.windowGlobalChild + ? win.windowGlobalChild.innerWindowId + : 0; + // Values are dead objects if the inner window is changed. + if (windowID !== currentID) { + windowID = currentID; + proxies = new WeakMap(); + handler = Cu.cloneInto(SpecialPowersHandler, win, { + cloneFunctions: true, + }); + handler.wrapped = new win.WeakMap(); + perWindowInfo.set(win, { windowID, proxies, handler }); + } + + if (proxies.has(obj)) { + return proxies.get(obj).proxy; + } + + let className = Cu.getClassName(obj, true); + if (className === "ArrayBuffer") { + // Since |new Uint8Array(<proxy>)| doesn't work as expected, we have to + // return a real ArrayBuffer. + return obj instanceof win.ArrayBuffer ? obj : Cu.cloneInto(obj, win); + } + + let dummy; + if (typeof obj === "function") { + dummy = Cu.exportFunction(function() {}, win); + } else { + dummy = new win.Object(); + } + handler.wrapped.set(dummy, { obj }); + + let proxy = new win.Proxy(dummy, handler); + wrappedObjects.set(proxy, obj); + switch (className) { + case "AnonymousContent": + // Caching anonymous content will cause crashes (bug 1636015). + break; + case "CSS2Properties": + case "CSSStyleRule": + case "CSSStyleSheet": + // Caching these classes will cause memory leaks. + break; + default: + proxies.set(obj, { proxy }); + break; + } + return proxy; +} + +function unwrapPrivileged(x) { + // We don't wrap primitives, so sometimes we have a primitive where we'd + // expect to have a wrapper. The proxy pretends to be the type that it's + // emulating, so we can just as easily check isWrappable() on a proxy as + // we can on an unwrapped object. + if (!isWrappable(x)) { + return x; + } + + // If we have a wrappable type, make sure it's wrapped. + if (!isWrapper(x)) { + throw new Error("Trying to unwrap a non-wrapped object!"); + } + + // unwrapped. + return wrappedObjects.get(x); +} + +function wrapExceptions(global, fn) { + try { + return fn(); + } catch (e) { + throw wrapIfUnwrapped(e, global); + } +} + +function specialPowersHasInstance(value) { + // Because we return wrapped versions of this function, when it's called its + // wrapper will unwrap the "this" as well as the function itself. So our + // "this" is the unwrapped thing we started out with. + return value instanceof this; +} + +let SpecialPowersHandler = { + construct(target, args) { + // The arguments may or may not be wrappers. Unwrap them if necessary. + var unwrappedArgs = Array.from(Cu.waiveXrays(args), x => + unwrapIfWrapped(Cu.unwaiveXrays(x)) + ); + + // We want to invoke "obj" as a constructor, but using unwrappedArgs as + // the arguments. + let global = Cu.getGlobalForObject(this); + return wrapExceptions(global, () => + wrapIfUnwrapped( + Reflect.construct(this.wrapped.get(target).obj, unwrappedArgs), + global + ) + ); + }, + + apply(target, thisValue, args) { + let wrappedObject = this.wrapped.get(target).obj; + let global = Cu.getGlobalForObject(this); + // The invocant and arguments may or may not be wrappers. Unwrap + // them if necessary. + var invocant = unwrapIfWrapped(thisValue); + + return wrapExceptions(global, () => { + if (noAutoWrap.has(wrappedObject)) { + args = Array.from(Cu.waiveXrays(args), x => Cu.unwaiveXrays(x)); + return doApply(wrappedObject, invocant, args); + } + + if (wrappedObject.name == "then") { + args = Array.from(Cu.waiveXrays(args), x => + wrapCallback(Cu.unwaiveXrays(x), global) + ); + } else { + args = Array.from(Cu.waiveXrays(args), x => + unwrapIfWrapped(Cu.unwaiveXrays(x)) + ); + } + + return wrapIfUnwrapped(doApply(wrappedObject, invocant, args), global); + }); + }, + + has(target, prop) { + return Reflect.has(this.wrapped.get(target).obj, prop); + }, + + get(target, prop, receiver) { + let global = Cu.getGlobalForObject(this); + return wrapExceptions(global, () => { + let obj = waiveXraysIfAppropriate(this.wrapped.get(target).obj, prop); + let val = Reflect.get(obj, prop); + if (val === undefined && prop == Symbol.hasInstance) { + // Special-case Symbol.hasInstance to pass the hasInstance check on to our + // target. We only do this when the target doesn't have its own + // Symbol.hasInstance already. Once we get rid of JS engine class + // instance hooks (bug 1448218) and always use Symbol.hasInstance, we can + // remove this bit (bug 1448400). + return wrapPrivileged(specialPowersHasInstance, global); + } + return wrapIfUnwrapped(val, global); + }); + }, + + set(target, prop, val, receiver) { + return wrapExceptions(Cu.getGlobalForObject(this), () => { + let obj = waiveXraysIfAppropriate(this.wrapped.get(target).obj, prop); + return Reflect.set(obj, prop, unwrapIfWrapped(val)); + }); + }, + + delete(target, prop) { + return wrapExceptions(Cu.getGlobalForObject(this), () => { + return Reflect.deleteProperty(this.wrapped.get(target).obj, prop); + }); + }, + + defineProperty(target, prop, descriptor) { + throw new Error( + "Can't call defineProperty on SpecialPowers wrapped object" + ); + }, + + getOwnPropertyDescriptor(target, prop) { + let global = Cu.getGlobalForObject(this); + return wrapExceptions(global, () => { + let obj = waiveXraysIfAppropriate(this.wrapped.get(target).obj, prop); + let desc = Reflect.getOwnPropertyDescriptor(obj, prop); + + if (desc === undefined) { + if (prop == Symbol.hasInstance) { + // Special-case Symbol.hasInstance to pass the hasInstance check on to + // our target. We only do this when the target doesn't have its own + // Symbol.hasInstance already. Once we get rid of JS engine class + // instance hooks (bug 1448218) and always use Symbol.hasInstance, we + // can remove this bit (bug 1448400). + return { + value: wrapPrivileged(specialPowersHasInstance, global), + writeable: true, + configurable: true, + enumerable: false, + }; + } + + return undefined; + } + + // Transitively maintain the wrapper membrane. + let wrapIfExists = key => { + if (key in desc) { + desc[key] = wrapIfUnwrapped(desc[key], global); + } + }; + + wrapIfExists("value"); + wrapIfExists("get"); + wrapIfExists("set"); + + // A trapping proxy's properties must always be configurable, but sometimes + // we come across non-configurable properties. Tell a white lie. + desc.configurable = true; + + return wrapIfUnwrapped(desc, global); + }); + }, + + ownKeys(target) { + let props = []; + + // Do the normal thing. + let wrappedObject = this.wrapped.get(target).obj; + let flt = a => !props.includes(a); + props = props.concat(Reflect.ownKeys(wrappedObject).filter(flt)); + + // If we've got an Xray wrapper, include the expandos as well. + if ("wrappedJSObject" in wrappedObject) { + props = props.concat( + Reflect.ownKeys(wrappedObject.wrappedJSObject).filter(flt) + ); + } + + return Cu.cloneInto(props, Cu.getGlobalForObject(this)); + }, + + preventExtensions(target) { + throw new Error( + "Can't call preventExtensions on SpecialPowers wrapped object" + ); + }, +}; + +function wrapCallback(cb, win) { + // Do not wrap if it is already privileged. + if (!isWrappable(cb) || Cu.getObjectPrincipal(cb).isSystemPrincipal) { + return cb; + } + return function SpecialPowersCallbackWrapper() { + var args = Array.from(arguments, obj => wrapIfUnwrapped(obj, win)); + let invocant = wrapIfUnwrapped(this, win); + return unwrapIfWrapped(cb.apply(invocant, args)); + }; +} + +function wrapCallbackObject(obj, win) { + // Do not wrap if it is already privileged. + if (!isWrappable(obj) || Cu.getObjectPrincipal(obj).isSystemPrincipal) { + return obj; + } + obj = Cu.waiveXrays(obj); + var wrapper = {}; + for (var i in obj) { + if (typeof obj[i] == "function") { + wrapper[i] = wrapCallback(Cu.unwaiveXrays(obj[i]), win); + } else { + wrapper[i] = obj[i]; + } + } + return wrapper; +} + +function disableAutoWrap(...objs) { + objs.forEach(x => noAutoWrap.add(x)); +} + +var WrapPrivileged = { + wrap: wrapIfUnwrapped, + unwrap: unwrapIfWrapped, + + isWrapper, + + wrapCallback, + wrapCallbackObject, + + disableAutoWrap, +}; |