diff options
Diffstat (limited to 'testing/specialpowers/content')
| -rw-r--r-- | testing/specialpowers/content/MockColorPicker.jsm | 117 | ||||
| -rw-r--r-- | testing/specialpowers/content/MockFilePicker.jsm | 235 | ||||
| -rw-r--r-- | testing/specialpowers/content/MockPermissionPrompt.jsm | 97 | ||||
| -rw-r--r-- | testing/specialpowers/content/MozillaLogger.js | 134 | ||||
| -rw-r--r-- | testing/specialpowers/content/SpecialPowersObserver.jsm | 313 | ||||
| -rw-r--r-- | testing/specialpowers/content/SpecialPowersObserverAPI.js | 635 | ||||
| -rw-r--r-- | testing/specialpowers/content/specialpowers.js | 278 | ||||
| -rw-r--r-- | testing/specialpowers/content/specialpowersAPI.js | 2100 |
8 files changed, 3909 insertions, 0 deletions
diff --git a/testing/specialpowers/content/MockColorPicker.jsm b/testing/specialpowers/content/MockColorPicker.jsm new file mode 100644 index 000000000..3cce150c8 --- /dev/null +++ b/testing/specialpowers/content/MockColorPicker.jsm @@ -0,0 +1,117 @@ +/* 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.EXPORTED_SYMBOLS = ["MockColorPicker"]; + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cm = Components.manager; +const Cu = Components.utils; + +const CONTRACT_ID = "@mozilla.org/colorpicker;1"; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +// Allow stuff from this scope to be accessed from non-privileged scopes. This +// would crash if used outside of automation. +Cu.forcePermissiveCOWs(); + +var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); +var oldClassID = "", oldFactory = null; +var newClassID = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator).generateUUID(); +var newFactory = function (window) { + return { + createInstance: function(aOuter, aIID) { + if (aOuter) + throw Components.results.NS_ERROR_NO_AGGREGATION; + return new MockColorPickerInstance(window).QueryInterface(aIID); + }, + lockFactory: function(aLock) { + throw Components.results.NS_ERROR_NOT_IMPLEMENTED; + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIFactory]) + }; +} + +this.MockColorPicker = { + init: function(window) { + this.reset(); + this.factory = newFactory(window); + 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 colorpicker registered component, " + + "assuming there is none"); + } + if (oldClassID != "" && oldFactory != null) { + registrar.unregisterFactory(oldClassID, oldFactory); + } + registrar.registerFactory(newClassID, "", CONTRACT_ID, this.factory); + } + }, + + reset: function() { + this.returnColor = ""; + this.showCallback = null; + this.shown = false; + this.showing = false; + }, + + cleanup: function() { + var previousFactory = this.factory; + this.reset(); + this.factory = null; + + registrar.unregisterFactory(newClassID, previousFactory); + if (oldClassID != "" && oldFactory != null) { + registrar.registerFactory(oldClassID, "", CONTRACT_ID, oldFactory); + } + } +}; + +function MockColorPickerInstance(window) { + this.window = window; +}; +MockColorPickerInstance.prototype = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsIColorPicker]), + init: function(aParent, aTitle, aInitialColor) { + this.parent = aParent; + this.initialColor = aInitialColor; + }, + initialColor: "", + parent: null, + open: function(aColorPickerShownCallback) { + MockColorPicker.showing = true; + MockColorPicker.shown = true; + + this.window.setTimeout(function() { + let result = ""; + try { + if (typeof MockColorPicker.showCallback == "function") { + var updateCb = function(color) { + result = color; + aColorPickerShownCallback.update(color); + }; + let returnColor = MockColorPicker.showCallback(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); + } + }.bind(this), 0); + } +}; diff --git a/testing/specialpowers/content/MockFilePicker.jsm b/testing/specialpowers/content/MockFilePicker.jsm new file mode 100644 index 000000000..4c93cd0e2 --- /dev/null +++ b/testing/specialpowers/content/MockFilePicker.jsm @@ -0,0 +1,235 @@ +/* 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.EXPORTED_SYMBOLS = ["MockFilePicker"]; + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cm = Components.manager; +const Cu = Components.utils; + +const CONTRACT_ID = "@mozilla.org/filepicker;1"; + +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); + +// Allow stuff from this scope to be accessed from non-privileged scopes. This +// would crash if used outside of automation. +Cu.forcePermissiveCOWs(); + +var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); +var oldClassID, oldFactory; +var newClassID = Cc["@mozilla.org/uuid-generator;1"].getService(Ci.nsIUUIDGenerator).generateUUID(); +var newFactory = function (window) { + return { + createInstance: function(aOuter, aIID) { + if (aOuter) + throw Components.results.NS_ERROR_NO_AGGREGATION; + return new MockFilePickerInstance(window).QueryInterface(aIID); + }, + lockFactory: function(aLock) { + throw Components.results.NS_ERROR_NOT_IMPLEMENTED; + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIFactory]) + }; +} + +this.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, + + init: function(window) { + this.window = window; + + this.reset(); + this.factory = newFactory(window); + if (!registrar.isCIDRegistered(newClassID)) { + oldClassID = registrar.contractIDToCID(CONTRACT_ID); + oldFactory = Cm.getClassObject(Cc[CONTRACT_ID], Ci.nsIFactory); + registrar.unregisterFactory(oldClassID, oldFactory); + registrar.registerFactory(newClassID, "", CONTRACT_ID, this.factory); + } + }, + + reset: function() { + this.appendFilterCallback = null; + this.appendFiltersCallback = null; + this.displayDirectory = null; + this.filterIndex = 0; + this.mode = null; + this.returnFiles = []; + this.returnValue = null; + this.showCallback = null; + this.shown = false; + this.showing = false; + }, + + cleanup: function() { + var previousFactory = this.factory; + this.reset(); + this.factory = null; + if (oldFactory) { + registrar.unregisterFactory(newClassID, previousFactory); + registrar.registerFactory(oldClassID, "", CONTRACT_ID, oldFactory); + } + }, + + useAnyFile: function() { + var file = FileUtils.getDir("TmpD", [], false); + file.append("testfile"); + file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644); + this.returnFiles = [file]; + }, + + useBlobFile: function() { + var blob = new this.window.Blob([]); + var file = new this.window.File([blob], 'helloworld.txt', { type: 'plain/text' }); + this.returnFiles = [file]; + }, + + useDirectory: function(aPath) { + var directory = new this.window.Directory(aPath); + this.returnFiles = [directory]; + }, + + isNsIFile: function(aFile) { + let ret = false; + try { + if (aFile.QueryInterface(Ci.nsIFile)) + ret = true; + } catch(e) {} + + return ret; + } +}; + +function MockFilePickerInstance(window) { + this.window = window; +}; +MockFilePickerInstance.prototype = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsIFilePicker]), + init: function(aParent, aTitle, aMode) { + MockFilePicker.mode = aMode; + this.filterIndex = MockFilePicker.filterIndex; + this.parent = aParent; + }, + appendFilter: function(aTitle, aFilter) { + if (typeof MockFilePicker.appendFilterCallback == "function") + MockFilePicker.appendFilterCallback(this, aTitle, aFilter); + }, + appendFilters: function(aFilterMask) { + if (typeof MockFilePicker.appendFiltersCallback == "function") + MockFilePicker.appendFiltersCallback(this, aFilterMask); + }, + defaultString: "", + defaultExtension: "", + parent: null, + filterIndex: 0, + displayDirectory: null, + get file() { + if (MockFilePicker.returnFiles.length >= 1 && + // window.File does not implement nsIFile + MockFilePicker.isNsIFile(MockFilePicker.returnFiles[0])) { + return MockFilePicker.returnFiles[0]; + } + + return null; + }, + + // We don't support directories here. + get domFileOrDirectory() { + if (MockFilePicker.returnFiles.length >= 1) { + // window.File does not implement nsIFile + if (!MockFilePicker.isNsIFile(MockFilePicker.returnFiles[0])) { + return MockFilePicker.returnFiles[0]; + } + + let utils = this.parent.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindowUtils); + return utils.wrapDOMFile(MockFilePicker.returnFiles[0]); + } + return null; + }, + get fileURL() { + if (MockFilePicker.returnFiles.length >= 1 && + // window.File does not implement nsIFile + MockFilePicker.isNsIFile(MockFilePicker.returnFiles[0])) { + return Services.io.newFileURI(MockFilePicker.returnFiles[0]); + } + + return null; + }, + get files() { + return { + index: 0, + QueryInterface: XPCOMUtils.generateQI([Ci.nsISimpleEnumerator]), + hasMoreElements: function() { + return this.index < MockFilePicker.returnFiles.length; + }, + getNext: function() { + // window.File does not implement nsIFile + if (!MockFilePicker.isNsIFile(MockFilePicker.returnFiles[this.index])) { + return null; + } + return MockFilePicker.returnFiles[this.index++]; + } + }; + }, + get domFileOrDirectoryEnumerator() { + let utils = this.parent.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindowUtils); + return { + index: 0, + QueryInterface: XPCOMUtils.generateQI([Ci.nsISimpleEnumerator]), + hasMoreElements: function() { + return this.index < MockFilePicker.returnFiles.length; + }, + getNext: function() { + // window.File does not implement nsIFile + if (!MockFilePicker.isNsIFile(MockFilePicker.returnFiles[this.index])) { + return MockFilePicker.returnFiles[this.index++]; + } + return utils.wrapDOMFile(MockFilePicker.returnFiles[this.index++]); + } + }; + }, + show: function() { + MockFilePicker.displayDirectory = this.displayDirectory; + MockFilePicker.shown = true; + if (typeof MockFilePicker.showCallback == "function") { + var returnValue = MockFilePicker.showCallback(this); + if (typeof returnValue != "undefined") + return returnValue; + } + return MockFilePicker.returnValue; + }, + open: function(aFilePickerShownCallback) { + MockFilePicker.showing = true; + this.window.setTimeout(function() { + let result = Components.interfaces.nsIFilePicker.returnCancel; + try { + result = this.show(); + } catch(ex) { + } + if (aFilePickerShownCallback) { + aFilePickerShownCallback.done(result); + } + }.bind(this), 0); + } +}; diff --git a/testing/specialpowers/content/MockPermissionPrompt.jsm b/testing/specialpowers/content/MockPermissionPrompt.jsm new file mode 100644 index 000000000..e07f8e002 --- /dev/null +++ b/testing/specialpowers/content/MockPermissionPrompt.jsm @@ -0,0 +1,97 @@ +/* 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.EXPORTED_SYMBOLS = ["MockPermissionPrompt"]; + +const Cc = Components.classes; +const Ci = Components.interfaces; +const Cm = Components.manager; +const Cu = Components.utils; + +const CONTRACT_ID = "@mozilla.org/content-permission/prompt;1"; + +Cu.import("resource://gre/modules/FileUtils.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.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: function(aOuter, aIID) { + if (aOuter) + throw Components.results.NS_ERROR_NO_AGGREGATION; + return new MockPermissionPromptInstance().QueryInterface(aIID); + }, + lockFactory: function(aLock) { + throw Components.results.NS_ERROR_NOT_IMPLEMENTED; + }, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIFactory]) +}; + +this.MockPermissionPrompt = { + init: function() { + 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: function() { + }, + + cleanup: function() { + this.reset(); + if (oldFactory) { + registrar.unregisterFactory(newClassID, newFactory); + registrar.registerFactory(oldClassID, "", CONTRACT_ID, oldFactory); + } + }, +}; + +function MockPermissionPromptInstance() { }; +MockPermissionPromptInstance.prototype = { + QueryInterface: XPCOMUtils.generateQI([Ci.nsIContentPermissionPrompt]), + + promptResult: Ci.nsIPermissionManager.UNKNOWN_ACTION, + + prompt: function(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(); + } +}; + +// Expose everything to content. We call reset() here so that all of the relevant +// lazy expandos get added. +MockPermissionPrompt.reset(); +function exposeAll(obj) { + var props = {}; + for (var prop in obj) + props[prop] = 'rw'; + obj.__exposedProps__ = props; +} +exposeAll(MockPermissionPrompt); +exposeAll(MockPermissionPromptInstance.prototype); diff --git a/testing/specialpowers/content/MozillaLogger.js b/testing/specialpowers/content/MozillaLogger.js new file mode 100644 index 000000000..52e16cabc --- /dev/null +++ b/testing/specialpowers/content/MozillaLogger.js @@ -0,0 +1,134 @@ +/** + * MozillaLogger, a base class logger that just logs to stdout. + */ + +"use strict"; + +function MozillaLogger(aPath) { +} + +function formatLogMessage(msg) { + return msg.info.join(' ') + "\n"; +} + +MozillaLogger.prototype = { + init : function(path) {}, + + getLogCallback : function() { + return function (msg) { + var data = formatLogMessage(msg); + dump(data); + }; + }, + + log : function(msg) { + dump(msg); + }, + + close : function() {} +}; + + +/** + * SpecialPowersLogger, inherits from MozillaLogger and utilizes SpecialPowers. + * intented to be used in content scripts to write to a file + */ +function SpecialPowersLogger(aPath) { + // Call the base constructor + MozillaLogger.call(this); + this.prototype = new MozillaLogger(aPath); + this.init(aPath); +} + +SpecialPowersLogger.prototype = { + init : function (path) { + SpecialPowers.setLogFile(path); + }, + + getLogCallback : function () { + return function (msg) { + var data = formatLogMessage(msg); + SpecialPowers.log(data); + + if (data.indexOf("SimpleTest FINISH") >= 0) { + SpecialPowers.closeLogFile(); + } + }; + }, + + log : function (msg) { + SpecialPowers.log(msg); + }, + + close : function () { + SpecialPowers.closeLogFile(); + } +}; + + +/** + * MozillaFileLogger, a log listener that can write to a local file. + * intended to be run from chrome space + */ + +/** Init the file logger with the absolute path to the file. + It will create and append if the file already exists **/ +function MozillaFileLogger(aPath) { + // Call the base constructor + MozillaLogger.call(this); + this.prototype = new MozillaLogger(aPath); + this.init(aPath); +} + +MozillaFileLogger.prototype = { + + init : function (path) { + var PR_WRITE_ONLY = 0x02; // Open for writing only. + var PR_CREATE_FILE = 0x08; + var PR_APPEND = 0x10; + this._file = Components.classes["@mozilla.org/file/local;1"]. + createInstance(Components.interfaces.nsILocalFile); + this._file.initWithPath(path); + this._foStream = Components.classes["@mozilla.org/network/file-output-stream;1"]. + createInstance(Components.interfaces.nsIFileOutputStream); + this._foStream.init(this._file, PR_WRITE_ONLY | PR_CREATE_FILE | PR_APPEND, + 436 /* 0664 */, 0); + + this._converter = Components.classes["@mozilla.org/intl/converter-output-stream;1"]. + createInstance(Components.interfaces.nsIConverterOutputStream); + this._converter.init(this._foStream, "UTF-8", 0, 0); + }, + + getLogCallback : function() { + return function (msg) { + var data = formatLogMessage(msg); + if (MozillaFileLogger._converter) { + this._converter.writeString(data); + } + + if (data.indexOf("SimpleTest FINISH") >= 0) { + MozillaFileLogger.close(); + } + }; + }, + + log : function(msg) { + if (this._converter) { + this._converter.writeString(msg); + } + }, + close : function() { + if (this._converter) { + this._converter.flush(); + this._converter.close(); + } + + this._foStream = null; + this._converter = null; + this._file = null; + } +}; + +this.MozillaLogger = MozillaLogger; +this.SpecialPowersLogger = SpecialPowersLogger; +this.MozillaFileLogger = MozillaFileLogger; diff --git a/testing/specialpowers/content/SpecialPowersObserver.jsm b/testing/specialpowers/content/SpecialPowersObserver.jsm new file mode 100644 index 000000000..fc7584505 --- /dev/null +++ b/testing/specialpowers/content/SpecialPowersObserver.jsm @@ -0,0 +1,313 @@ +/* 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/. */ + +// Based on: +// https://bugzilla.mozilla.org/show_bug.cgi?id=549539 +// https://bug549539.bugzilla.mozilla.org/attachment.cgi?id=429661 +// https://developer.mozilla.org/en/XPCOM/XPCOM_changes_in_Gecko_1.9.3 +// https://developer.mozilla.org/en/how_to_build_an_xpcom_component_in_javascript + +var EXPORTED_SYMBOLS = ["SpecialPowersObserver", "SpecialPowersObserverFactory"]; + +Components.utils.import("resource://gre/modules/XPCOMUtils.jsm"); +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.importGlobalProperties(['File']); + +if (typeof(Cc) == "undefined") { + const Cc = Components.classes; + const Ci = Components.interfaces; +} + +const CHILD_SCRIPT = "chrome://specialpowers/content/specialpowers.js" +const CHILD_SCRIPT_API = "chrome://specialpowers/content/specialpowersAPI.js" +const CHILD_LOGGER_SCRIPT = "chrome://specialpowers/content/MozillaLogger.js" + + +// Glue to add in the observer API to this object. This allows us to share code with chrome tests +var loader = Components.classes["@mozilla.org/moz/jssubscript-loader;1"] + .getService(Components.interfaces.mozIJSSubScriptLoader); +loader.loadSubScript("chrome://specialpowers/content/SpecialPowersObserverAPI.js"); + +/* XPCOM gunk */ +this.SpecialPowersObserver = function SpecialPowersObserver() { + this._isFrameScriptLoaded = false; + this._messageManager = Cc["@mozilla.org/globalmessagemanager;1"]. + getService(Ci.nsIMessageBroadcaster); +} + + +SpecialPowersObserver.prototype = new SpecialPowersObserverAPI(); + +SpecialPowersObserver.prototype.classDescription = "Special powers Observer for use in testing."; +SpecialPowersObserver.prototype.classID = Components.ID("{59a52458-13e0-4d93-9d85-a637344f29a1}"); +SpecialPowersObserver.prototype.contractID = "@mozilla.org/special-powers-observer;1"; +SpecialPowersObserver.prototype.QueryInterface = XPCOMUtils.generateQI([Components.interfaces.nsIObserver]); + +SpecialPowersObserver.prototype.observe = function(aSubject, aTopic, aData) +{ + switch (aTopic) { + case "chrome-document-global-created": + this._loadFrameScript(); + break; + + case "http-on-modify-request": + if (aSubject instanceof Ci.nsIChannel) { + let uri = aSubject.URI.spec; + this._sendAsyncMessage("specialpowers-http-notify-request", { uri: uri }); + } + break; + + default: + this._observe(aSubject, aTopic, aData); + break; + } +}; + +SpecialPowersObserver.prototype._loadFrameScript = function() +{ + if (!this._isFrameScriptLoaded) { + // Register for any messages our API needs us to handle + this._messageManager.addMessageListener("SPPrefService", this); + this._messageManager.addMessageListener("SPProcessCrashService", this); + this._messageManager.addMessageListener("SPPingService", this); + this._messageManager.addMessageListener("SpecialPowers.Quit", this); + this._messageManager.addMessageListener("SpecialPowers.Focus", this); + this._messageManager.addMessageListener("SpecialPowers.CreateFiles", this); + this._messageManager.addMessageListener("SpecialPowers.RemoveFiles", this); + this._messageManager.addMessageListener("SPPermissionManager", this); + this._messageManager.addMessageListener("SPObserverService", this); + this._messageManager.addMessageListener("SPLoadChromeScript", this); + this._messageManager.addMessageListener("SPImportInMainProcess", this); + this._messageManager.addMessageListener("SPChromeScriptMessage", this); + this._messageManager.addMessageListener("SPQuotaManager", this); + this._messageManager.addMessageListener("SPSetTestPluginEnabledState", this); + this._messageManager.addMessageListener("SPLoadExtension", this); + this._messageManager.addMessageListener("SPStartupExtension", this); + this._messageManager.addMessageListener("SPUnloadExtension", this); + this._messageManager.addMessageListener("SPExtensionMessage", this); + this._messageManager.addMessageListener("SPCleanUpSTSData", this); + this._messageManager.addMessageListener("SPClearAppPrivateData", this); + + this._messageManager.loadFrameScript(CHILD_LOGGER_SCRIPT, true); + this._messageManager.loadFrameScript(CHILD_SCRIPT_API, true); + this._messageManager.loadFrameScript(CHILD_SCRIPT, true); + this._isFrameScriptLoaded = true; + this._createdFiles = null; + } +}; + +SpecialPowersObserver.prototype._sendAsyncMessage = function(msgname, msg) +{ + this._messageManager.broadcastAsyncMessage(msgname, msg); +}; + +SpecialPowersObserver.prototype._receiveMessage = function(aMessage) { + return this._receiveMessageAPI(aMessage); +}; + +SpecialPowersObserver.prototype.init = function() +{ + var obs = Services.obs; + obs.addObserver(this, "chrome-document-global-created", false); + + // Register special testing modules. + var testsURI = Cc["@mozilla.org/file/directory_service;1"]. + getService(Ci.nsIProperties). + get("ProfD", Ci.nsILocalFile); + testsURI.append("tests.manifest"); + var ioSvc = Cc["@mozilla.org/network/io-service;1"]. + getService(Ci.nsIIOService); + var manifestFile = ioSvc.newFileURI(testsURI). + QueryInterface(Ci.nsIFileURL).file; + + Components.manager.QueryInterface(Ci.nsIComponentRegistrar). + autoRegister(manifestFile); + + obs.addObserver(this, "http-on-modify-request", false); + + this._loadFrameScript(); +}; + +SpecialPowersObserver.prototype.uninit = function() +{ + var obs = Services.obs; + obs.removeObserver(this, "chrome-document-global-created"); + obs.removeObserver(this, "http-on-modify-request"); + this._registerObservers._topics.forEach(function(element) { + obs.removeObserver(this._registerObservers, element); + }); + this._removeProcessCrashObservers(); + + if (this._isFrameScriptLoaded) { + this._messageManager.removeMessageListener("SPPrefService", this); + this._messageManager.removeMessageListener("SPProcessCrashService", this); + this._messageManager.removeMessageListener("SPPingService", this); + this._messageManager.removeMessageListener("SpecialPowers.Quit", this); + this._messageManager.removeMessageListener("SpecialPowers.Focus", this); + this._messageManager.removeMessageListener("SpecialPowers.CreateFiles", this); + this._messageManager.removeMessageListener("SpecialPowers.RemoveFiles", this); + this._messageManager.removeMessageListener("SPPermissionManager", this); + this._messageManager.removeMessageListener("SPObserverService", this); + this._messageManager.removeMessageListener("SPLoadChromeScript", this); + this._messageManager.removeMessageListener("SPImportInMainProcess", this); + this._messageManager.removeMessageListener("SPChromeScriptMessage", this); + this._messageManager.removeMessageListener("SPQuotaManager", this); + this._messageManager.removeMessageListener("SPSetTestPluginEnabledState", this); + this._messageManager.removeMessageListener("SPLoadExtension", this); + this._messageManager.removeMessageListener("SPStartupExtension", this); + this._messageManager.removeMessageListener("SPUnloadExtension", this); + this._messageManager.removeMessageListener("SPExtensionMessage", this); + this._messageManager.removeMessageListener("SPCleanUpSTSData", this); + this._messageManager.removeMessageListener("SPClearAppPrivateData", this); + + this._messageManager.removeDelayedFrameScript(CHILD_LOGGER_SCRIPT); + this._messageManager.removeDelayedFrameScript(CHILD_SCRIPT_API); + this._messageManager.removeDelayedFrameScript(CHILD_SCRIPT); + this._isFrameScriptLoaded = false; + } +}; + +SpecialPowersObserver.prototype._addProcessCrashObservers = function() { + if (this._processCrashObserversRegistered) { + return; + } + + var obs = Components.classes["@mozilla.org/observer-service;1"] + .getService(Components.interfaces.nsIObserverService); + + obs.addObserver(this, "plugin-crashed", false); + obs.addObserver(this, "ipc:content-shutdown", false); + this._processCrashObserversRegistered = true; +}; + +SpecialPowersObserver.prototype._removeProcessCrashObservers = function() { + if (!this._processCrashObserversRegistered) { + return; + } + + var obs = Components.classes["@mozilla.org/observer-service;1"] + .getService(Components.interfaces.nsIObserverService); + + obs.removeObserver(this, "plugin-crashed"); + obs.removeObserver(this, "ipc:content-shutdown"); + this._processCrashObserversRegistered = false; +}; + +SpecialPowersObserver.prototype._registerObservers = { + _self: null, + _topics: [], + _add: function(topic) { + if (this._topics.indexOf(topic) < 0) { + this._topics.push(topic); + Services.obs.addObserver(this, topic, false); + } + }, + observe: function (aSubject, aTopic, aData) { + var msg = { aData: aData }; + switch (aTopic) { + case "perm-changed": + var permission = aSubject.QueryInterface(Ci.nsIPermission); + + // specialPowersAPI will consume this value, and it is used as a + // fake permission, but only type and principal.appId will be used. + // + // We need to ensure that it looks the same as a real permission, + // so we fake these properties. + msg.permission = { + principal: { + originAttributes: {appId: permission.principal.appId} + }, + type: permission.type + }; + default: + this._self._sendAsyncMessage("specialpowers-" + aTopic, msg); + } + } +}; + +/** + * messageManager callback function + * This will get requests from our API in the window and process them in chrome for it + **/ +SpecialPowersObserver.prototype.receiveMessage = function(aMessage) { + switch(aMessage.name) { + case "SPPingService": + if (aMessage.json.op == "ping") { + aMessage.target + .QueryInterface(Ci.nsIFrameLoaderOwner) + .frameLoader + .messageManager + .sendAsyncMessage("SPPingService", { op: "pong" }); + } + break; + case "SpecialPowers.Quit": + let appStartup = Cc["@mozilla.org/toolkit/app-startup;1"].getService(Ci.nsIAppStartup); + appStartup.quit(Ci.nsIAppStartup.eForceQuit); + break; + case "SpecialPowers.Focus": + aMessage.target.focus(); + break; + case "SpecialPowers.CreateFiles": + let filePaths = new Array; + if (!this._createdFiles) { + this._createdFiles = new Array; + } + let createdFiles = this._createdFiles; + try { + aMessage.data.forEach(function(request) { + const filePerms = 0666; + 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(); + filePaths.push(File.createFromFileName(testFile.path, request.options)); + createdFiles.push(testFile); + }); + aMessage.target + .QueryInterface(Ci.nsIFrameLoaderOwner) + .frameLoader + .messageManager + .sendAsyncMessage("SpecialPowers.FilesCreated", filePaths); + } catch (e) { + aMessage.target + .QueryInterface(Ci.nsIFrameLoaderOwner) + .frameLoader + .messageManager + .sendAsyncMessage("SpecialPowers.FilesError", e.toString()); + } + + break; + case "SpecialPowers.RemoveFiles": + if (this._createdFiles) { + this._createdFiles.forEach(function (testFile) { + try { + testFile.remove(false); + } catch (e) {} + }); + this._createdFiles = null; + } + break; + default: + return this._receiveMessage(aMessage); + } +}; + +this.NSGetFactory = XPCOMUtils.generateNSGetFactory([SpecialPowersObserver]); +this.SpecialPowersObserverFactory = Object.freeze({ + createInstance: function(outer, id) { + if (outer) { throw Components.results.NS_ERROR_NO_AGGREGATION }; + return new SpecialPowersObserver(); + }, + loadFactory: function(lock){}, + QueryInterface: XPCOMUtils.generateQI([Ci.nsIFactory]) +}); diff --git a/testing/specialpowers/content/SpecialPowersObserverAPI.js b/testing/specialpowers/content/SpecialPowersObserverAPI.js new file mode 100644 index 000000000..f37f7bf0e --- /dev/null +++ b/testing/specialpowers/content/SpecialPowersObserverAPI.js @@ -0,0 +1,635 @@ +/* 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"; + +Components.utils.import("resource://gre/modules/Services.jsm"); +Components.utils.import("resource://gre/modules/NetUtil.jsm"); + +if (typeof(Ci) == 'undefined') { + var Ci = Components.interfaces; +} + +if (typeof(Cc) == 'undefined') { + var Cc = Components.classes; +} + +this.SpecialPowersError = function(aMsg) { + Error.call(this); + let {stack} = new Error(); + this.message = aMsg; + this.name = "SpecialPowersError"; +} +SpecialPowersError.prototype = Object.create(Error.prototype); + +SpecialPowersError.prototype.toString = function() { + return `${this.name}: ${this.message}`; +}; + +this.SpecialPowersObserverAPI = function SpecialPowersObserverAPI() { + this._crashDumpDir = null; + this._processCrashObserversRegistered = false; + this._chromeScriptListeners = []; + this._extensions = new Map(); +} + +function parseKeyValuePairs(text) { + var lines = text.split('\n'); + var data = {}; + for (let i = 0; i < lines.length; i++) { + if (lines[i] == '') + continue; + + // can't just .split() because the value might contain = characters + let eq = lines[i].indexOf('='); + if (eq != -1) { + let [key, value] = [lines[i].substring(0, eq), + lines[i].substring(eq + 1)]; + if (key && value) + data[key] = value.replace(/\\n/g, "\n").replace(/\\\\/g, "\\"); + } + } + return data; +} + +function parseKeyValuePairsFromFile(file) { + var fstream = Cc["@mozilla.org/network/file-input-stream;1"]. + createInstance(Ci.nsIFileInputStream); + fstream.init(file, -1, 0, 0); + var is = Cc["@mozilla.org/intl/converter-input-stream;1"]. + createInstance(Ci.nsIConverterInputStream); + is.init(fstream, "UTF-8", 1024, Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER); + var str = {}; + var contents = ''; + while (is.readString(4096, str) != 0) { + contents += str.value; + } + is.close(); + fstream.close(); + return parseKeyValuePairs(contents); +} + +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; +} + +SpecialPowersObserverAPI.prototype = { + + _observe: function(aSubject, aTopic, aData) { + function addDumpIDToMessage(propertyName) { + try { + var id = aSubject.getPropertyAsAString(propertyName); + } catch(ex) { + var id = null; + } + if (id) { + message.dumpIDs.push({id: id, extension: "dmp"}); + message.dumpIDs.push({id: id, extension: "extra"}); + } + } + + switch(aTopic) { + case "plugin-crashed": + case "ipc:content-shutdown": + var message = { type: "crash-observed", dumpIDs: [] }; + aSubject = aSubject.QueryInterface(Ci.nsIPropertyBag2); + if (aTopic == "plugin-crashed") { + addDumpIDToMessage("pluginDumpID"); + addDumpIDToMessage("browserDumpID"); + + let pluginID = aSubject.getPropertyAsAString("pluginDumpID"); + let extra = this._getExtraData(pluginID); + if (extra && ("additional_minidumps" in extra)) { + let dumpNames = extra.additional_minidumps.split(','); + for (let name of dumpNames) { + message.dumpIDs.push({id: pluginID + "-" + name, extension: "dmp"}); + } + } + } else { // ipc:content-shutdown + addDumpIDToMessage("dumpID"); + } + this._sendAsyncMessage("SPProcessCrashService", message); + break; + } + }, + + _getCrashDumpDir: function() { + if (!this._crashDumpDir) { + this._crashDumpDir = Services.dirsvc.get("ProfD", Ci.nsIFile); + this._crashDumpDir.append("minidumps"); + } + return this._crashDumpDir; + }, + + _getExtraData: function(dumpId) { + let extraFile = this._getCrashDumpDir().clone(); + extraFile.append(dumpId + ".extra"); + if (!extraFile.exists()) { + return null; + } + return parseKeyValuePairsFromFile(extraFile); + }, + + _deleteCrashDumpFiles: function(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: function(aToIgnore) { + var crashDumpDir = this._getCrashDumpDir(); + var entries = crashDumpDir.exists() && crashDumpDir.directoryEntries; + if (!entries) { + return []; + } + + var crashDumpFiles = []; + while (entries.hasMoreElements()) { + var file = entries.getNext().QueryInterface(Ci.nsIFile); + var path = String(file.path); + if (path.match(/\.(dmp|extra)$/) && !aToIgnore[path]) { + crashDumpFiles.push(path); + } + } + return crashDumpFiles.concat(); + }, + + _getURI: function (url) { + return Services.io.newURI(url, null, null); + }, + + _readUrlAsString: function(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.open2(); + 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; + try { + channel.QueryInterface(Ci.nsIHttpChannel); + status = channel.responseStatus; + } catch(e) { + /* The channel is not a nsIHttpCHannel, but that's fine */ + dump("-*- _readUrlAsString: Got an error while fetching " + + "chrome script '" + aUrl + "': (" + e.name + ") " + e.message + ". " + + "Ignoring.\n"); + } + + if (status == 404) { + throw new SpecialPowersError( + "Error while executing chrome script '" + aUrl + "':\n" + + "The script doesn't exists. Ensure you have registered it in " + + "'support-files' in your mochitest.ini."); + } + + return output; + }, + + _sendReply: function(aMessage, aReplyName, aReplyMsg) { + let mm = aMessage.target + .QueryInterface(Ci.nsIFrameLoaderOwner) + .frameLoader + .messageManager; + mm.sendAsyncMessage(aReplyName, aReplyMsg); + }, + + _notifyCategoryAndObservers: function(subject, topic, data) { + const serviceMarker = "service,"; + + // First create observers from the category manager. + let cm = + Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager); + let enumerator = cm.enumerateCategory(topic); + + let observers = []; + + while (enumerator.hasMoreElements()) { + let entry = + enumerator.getNext().QueryInterface(Ci.nsISupportsCString).data; + let contractID = cm.getCategoryEntry(topic, entry); + + 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. + enumerator = Services.obs.enumerateObservers(topic); + while (enumerator.hasMoreElements()) { + try { + let observer = enumerator.getNext().QueryInterface(Ci.nsIObserver); + if (observers.indexOf(observer) == -1) { + observers.push(observer); + } + } catch (e) { } + } + + observers.forEach(function (observer) { + try { + observer.observe(subject, topic, data); + } catch(e) { } + }); + }, + + /** + * messageManager callback function + * This will get requests from our API in the window and process them in chrome for it + **/ + _receiveMessageAPI: function(aMessage) { + // 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 "SPPrefService": { + let prefs = Services.prefs; + let prefType = aMessage.json.prefType.toUpperCase(); + let prefName = aMessage.json.prefName; + let prefValue = "prefValue" in aMessage.json ? aMessage.json.prefValue : null; + + 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 (prefs.getPrefType(prefName) == prefs.PREF_INVALID) + return null; + } else if (aMessage.json.op == "set") { + if (!prefName || !prefType || prefValue === null) + throw new SpecialPowersError("Invalid parameters for set in SPPrefService"); + } else if (aMessage.json.op == "clear") { + if (!prefName) + throw new SpecialPowersError("Invalid parameters for clear in SPPrefService"); + } else { + throw new SpecialPowersError("Invalid operation for SPPrefService"); + } + + // Now we make the call + switch(prefType) { + case "BOOL": + if (aMessage.json.op == "get") + return(prefs.getBoolPref(prefName)); + else + return(prefs.setBoolPref(prefName, prefValue)); + case "INT": + if (aMessage.json.op == "get") + return(prefs.getIntPref(prefName)); + else + return(prefs.setIntPref(prefName, prefValue)); + case "CHAR": + if (aMessage.json.op == "get") + return(prefs.getCharPref(prefName)); + else + return(prefs.setCharPref(prefName, prefValue)); + case "COMPLEX": + if (aMessage.json.op == "get") + return(prefs.getComplexValue(prefName, prefValue[0])); + else + return(prefs.setComplexValue(prefName, prefValue[0], prefValue[1])); + case "": + if (aMessage.json.op == "clear") { + prefs.clearUserPref(prefName); + return undefined; + } + } + 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); + default: + throw new SpecialPowersError("Invalid operation for SPProcessCrashService"); + } + return undefined; // See comment at the beginning of this function. + } + + case "SPPermissionManager": { + let msg = aMessage.json; + let principal = msg.principal; + + switch (msg.op) { + case "add": + Services.perms.addFromPrincipal(principal, msg.type, msg.permission, msg.expireType, msg.expireTime); + break; + case "remove": + Services.perms.removeFromPrincipal(principal, msg.type); + break; + case "has": + let hasPerm = Services.perms.testPermissionFromPrincipal(principal, msg.type); + return hasPerm == Ci.nsIPermissionManager.ALLOW_ACTION; + case "test": + let testPerm = Services.perms.testPermissionFromPrincipal(principal, msg.type, msg.value); + 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._self = this; + 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 jsScript; + let scriptName; + + if (aMessage.json.url) { + jsScript = this._readUrlAsString(aMessage.json.url); + scriptName = aMessage.json.url; + } else if (aMessage.json.function) { + jsScript = aMessage.json.function.body; + 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 addMessageListener in order to communicate with + // the mochitest. + let systemPrincipal = Services.scriptSecurityManager.getSystemPrincipal(); + let sb = Components.utils.Sandbox(systemPrincipal); + let mm = aMessage.target + .QueryInterface(Ci.nsIFrameLoaderOwner) + .frameLoader + .messageManager; + sb.sendAsyncMessage = (name, message) => { + mm.sendAsyncMessage("SPChromeScriptMessage", + { id: id, name: name, message: message }); + }; + sb.addMessageListener = (name, listener) => { + this._chromeScriptListeners.push({ id: id, name: name, listener: listener }); + }; + sb.browserElement = aMessage.target; + + // Also expose assertion functions + let reporter = function (err, message, stack) { + // Pipe assertions back to parent process + mm.sendAsyncMessage("SPChromeScriptAssert", + { id, name: scriptName, err, message, + stack }); + }; + Object.defineProperty(sb, "assert", { + get: function () { + let scope = Components.utils.createObjectIn(sb); + Services.scriptloader.loadSubScript("chrome://specialpowers/content/Assert.jsm", + scope); + + let assert = new scope.Assert(reporter); + delete sb.assert; + return sb.assert = assert; + }, + configurable: true + }); + + // Evaluate the chrome script + try { + Components.utils.evalInSandbox(jsScript, sb, "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; + return this._chromeScriptListeners + .filter(o => (o.name == name && o.id == id)) + .map(o => o.listener(message)); + } + + case "SPImportInMainProcess": { + var message = { hadError: false, errorMessage: null }; + try { + Components.utils.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, null, null); + let sss = Cc["@mozilla.org/ssservice;1"]. + getService(Ci.nsISiteSecurityService); + sss.removeState(Ci.nsISiteSecurityService.HEADER_HSTS, uri, flags); + return undefined; + } + + case "SPLoadExtension": { + let {Extension} = Components.utils.import("resource://gre/modules/Extension.jsm", {}); + + let id = aMessage.data.id; + let ext = aMessage.data.ext; + let extension = Extension.generate(ext); + + let resultListener = (...args) => { + this._sendReply(aMessage, "SPExtensionMessage", {id, type: "testResult", args}); + }; + + let messageListener = (...args) => { + args.shift(); + this._sendReply(aMessage, "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 {ExtensionData, Management} = Components.utils.import("resource://gre/modules/Extension.jsm", {}); + + let id = aMessage.data.id; + let extension = this._extensions.get(id); + let startupListener = (msg, ext) => { + if (ext == extension) { + this._sendReply(aMessage, "SPExtensionMessage", {id, type: "extensionSetId", args: [extension.id]}); + Management.off("startup", startupListener); + } + }; + Management.on("startup", startupListener); + + // 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); + extensionData.readManifest().then( + () => { + return extensionData.initAllLocales().then(() => { + if (extensionData.errors.length) { + return Promise.reject("Extension contains packaging errors"); + } + }); + }, + () => { + // readManifest() will throw if we're loading an embedded + // extension, so don't worry about locale errors in that + // case. + } + ).then(() => { + return extension.startup(); + }).then(() => { + this._sendReply(aMessage, "SPExtensionMessage", {id, type: "extensionStarted", args: []}); + }).catch(e => { + dump(`Extension startup failed: ${e}\n${e.stack}`); + Management.off("startup", startupListener); + this._sendReply(aMessage, "SPExtensionMessage", {id, type: "extensionFailed", args: []}); + }); + return undefined; + } + + case "SPExtensionMessage": { + let id = aMessage.data.id; + let extension = this._extensions.get(id); + extension.testMessage(...aMessage.data.args); + return undefined; + } + + case "SPUnloadExtension": { + let id = aMessage.data.id; + let extension = this._extensions.get(id); + this._extensions.delete(id); + extension.shutdown(); + this._sendReply(aMessage, "SPExtensionMessage", {id, type: "extensionUnloaded", args: []}); + return undefined; + } + + case "SPClearAppPrivateData": { + let appId = aMessage.data.appId; + let browserOnly = aMessage.data.browserOnly; + + let attributes = { appId: appId }; + if (browserOnly) { + attributes.inIsolatedMozBrowser = true; + } + this._notifyCategoryAndObservers(null, + "clear-origin-attributes-data", + JSON.stringify(attributes)); + + let subject = { + appId: appId, + browserOnly: browserOnly, + QueryInterface: XPCOMUtils.generateQI([Ci.mozIApplicationClearPrivateDataParams]) + }; + this._notifyCategoryAndObservers(subject, "webapps-clear-data", null); + + return undefined; + } + + default: + throw new SpecialPowersError("Unrecognized Special Powers API"); + } + + // We throw an exception before reaching this explicit return because + // we should never be arriving here anyway. + throw new SpecialPowersError("Unreached code"); + return undefined; + } +}; diff --git a/testing/specialpowers/content/specialpowers.js b/testing/specialpowers/content/specialpowers.js new file mode 100644 index 000000000..09dbb5209 --- /dev/null +++ b/testing/specialpowers/content/specialpowers.js @@ -0,0 +1,278 @@ +/* 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 in + * order to be used as a replacement for UniversalXPConnect + */ + +function SpecialPowers(window) { + this.window = Components.utils.getWeakReference(window); + this._windowID = window.QueryInterface(Components.interfaces.nsIInterfaceRequestor) + .getInterface(Components.interfaces.nsIDOMWindowUtils) + .currentInnerWindowID; + this._encounteredCrashDumpFiles = []; + this._unexpectedCrashDumpFiles = { }; + this._crashDumpDir = null; + this.DOMWindowUtils = bindDOMWindowUtils(window); + Object.defineProperty(this, 'Components', { + configurable: true, enumerable: true, get: function() { + var win = this.window.get(); + if (!win) + return null; + return getRawComponents(win); + }}); + this._pongHandlers = []; + this._messageListener = this._messageReceived.bind(this); + this._grandChildFrameMM = null; + this._createFilesOnError = null; + this._createFilesOnSuccess = null; + this.SP_SYNC_MESSAGES = ["SPChromeScriptMessage", + "SPLoadChromeScript", + "SPImportInMainProcess", + "SPObserverService", + "SPPermissionManager", + "SPPrefService", + "SPProcessCrashService", + "SPSetTestPluginEnabledState", + "SPCleanUpSTSData"]; + + this.SP_ASYNC_MESSAGES = ["SpecialPowers.Focus", + "SpecialPowers.Quit", + "SpecialPowers.CreateFiles", + "SpecialPowers.RemoveFiles", + "SPPingService", + "SPLoadExtension", + "SPStartupExtension", + "SPUnloadExtension", + "SPExtensionMessage", + "SPClearAppPrivateData"]; + addMessageListener("SPPingService", this._messageListener); + addMessageListener("SpecialPowers.FilesCreated", this._messageListener); + addMessageListener("SpecialPowers.FilesError", this._messageListener); + let self = this; + Services.obs.addObserver(function onInnerWindowDestroyed(subject, topic, data) { + var id = subject.QueryInterface(Components.interfaces.nsISupportsPRUint64).data; + if (self._windowID === id) { + Services.obs.removeObserver(onInnerWindowDestroyed, "inner-window-destroyed"); + try { + removeMessageListener("SPPingService", self._messageListener); + removeMessageListener("SpecialPowers.FilesCreated", self._messageListener); + removeMessageListener("SpecialPowers.FilesError", self._messageListener); + } catch (e if e.result == Components.results.NS_ERROR_ILLEGAL_VALUE) { + // Ignore the exception which the message manager has been destroyed. + ; + } + } + }, "inner-window-destroyed", false); +} + +SpecialPowers.prototype = new SpecialPowersAPI(); + +SpecialPowers.prototype.toString = function() { return "[SpecialPowers]"; }; +SpecialPowers.prototype.sanityCheck = function() { return "foo"; }; + +// This gets filled in in the constructor. +SpecialPowers.prototype.DOMWindowUtils = undefined; +SpecialPowers.prototype.Components = undefined; +SpecialPowers.prototype.IsInNestedFrame = false; + +SpecialPowers.prototype._sendSyncMessage = function(msgname, msg) { + if (this.SP_SYNC_MESSAGES.indexOf(msgname) == -1) { + dump("TEST-INFO | specialpowers.js | Unexpected SP message: " + msgname + "\n"); + } + return sendSyncMessage(msgname, msg); +}; + +SpecialPowers.prototype._sendAsyncMessage = function(msgname, msg) { + if (this.SP_ASYNC_MESSAGES.indexOf(msgname) == -1) { + dump("TEST-INFO | specialpowers.js | Unexpected SP message: " + msgname + "\n"); + } + sendAsyncMessage(msgname, msg); +}; + +SpecialPowers.prototype._addMessageListener = function(msgname, listener) { + addMessageListener(msgname, listener); + sendAsyncMessage("SPPAddNestedMessageListener", { name: msgname }); +}; + +SpecialPowers.prototype._removeMessageListener = function(msgname, listener) { + removeMessageListener(msgname, listener); +}; + +SpecialPowers.prototype.registerProcessCrashObservers = function() { + addMessageListener("SPProcessCrashService", this._messageListener); + sendSyncMessage("SPProcessCrashService", { op: "register-observer" }); +}; + +SpecialPowers.prototype.unregisterProcessCrashObservers = function() { + removeMessageListener("SPProcessCrashService", this._messageListener); + sendSyncMessage("SPProcessCrashService", { op: "unregister-observer" }); +}; + +SpecialPowers.prototype._messageReceived = function(aMessage) { + switch (aMessage.name) { + case "SPProcessCrashService": + if (aMessage.json.type == "crash-observed") { + for (let e of aMessage.json.dumpIDs) { + this._encounteredCrashDumpFiles.push(e.id + "." + e.extension); + } + } + break; + + case "SPPingService": + if (aMessage.json.op == "pong") { + var handler = this._pongHandlers.shift(); + if (handler) { + handler(); + } + if (this._grandChildFrameMM) { + this._grandChildFrameMM.sendAsyncMessage("SPPingService", { op: "pong" }); + } + } + break; + + case "SpecialPowers.FilesCreated": + var handler = this._createFilesOnSuccess; + this._createFilesOnSuccess = null; + this._createFilesOnError = null; + if (handler) { + handler(aMessage.data); + } + break; + + case "SpecialPowers.FilesError": + var handler = this._createFilesOnError; + this._createFilesOnSuccess = null; + this._createFilesOnError = null; + if (handler) { + handler(aMessage.data); + } + break; + } + + return true; +}; + +SpecialPowers.prototype.quit = function() { + 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. +SpecialPowers.prototype.createFiles = function(fileRequests, onCreation, onError) { + if (this._createFilesOnSuccess || this._createFilesOnError) { + onError("Already waiting for SpecialPowers.createFiles() to finish."); + return; + } + + this._createFilesOnSuccess = onCreation; + this._createFilesOnError = onError; + sendAsyncMessage("SpecialPowers.CreateFiles", fileRequests); +}; + +// Remove the files that were created using |SpecialPowers.createFiles()|. +// This will be automatically called by |SimpleTest.finish()|. +SpecialPowers.prototype.removeFiles = function() { + sendAsyncMessage("SpecialPowers.RemoveFiles", {}); +}; + +SpecialPowers.prototype.executeAfterFlushingMessageQueue = function(aCallback) { + this._pongHandlers.push(aCallback); + sendAsyncMessage("SPPingService", { op: "ping" }); +}; + +SpecialPowers.prototype.nestedFrameSetup = function() { + let self = this; + Services.obs.addObserver(function onRemoteBrowserShown(subject, topic, data) { + let frameLoader = subject; + // get a ref to the app <iframe> + frameLoader.QueryInterface(Components.interfaces.nsIFrameLoader); + let frame = frameLoader.ownerElement; + let frameId = frame.getAttribute('id'); + if (frameId === "nested-parent-frame") { + Services.obs.removeObserver(onRemoteBrowserShown, "remote-browser-shown"); + + let mm = frame.QueryInterface(Components.interfaces.nsIFrameLoaderOwner).frameLoader.messageManager; + self._grandChildFrameMM = mm; + + self.SP_SYNC_MESSAGES.forEach(function (msgname) { + mm.addMessageListener(msgname, function (msg) { + return self._sendSyncMessage(msgname, msg.data)[0]; + }); + }); + self.SP_ASYNC_MESSAGES.forEach(function (msgname) { + mm.addMessageListener(msgname, function (msg) { + self._sendAsyncMessage(msgname, msg.data); + }); + }); + mm.addMessageListener("SPPAddNestedMessageListener", function(msg) { + self._addMessageListener(msg.json.name, function(aMsg) { + mm.sendAsyncMessage(aMsg.name, aMsg.data); + }); + }); + + mm.loadFrameScript("chrome://specialpowers/content/MozillaLogger.js", false); + mm.loadFrameScript("chrome://specialpowers/content/specialpowersAPI.js", false); + mm.loadFrameScript("chrome://specialpowers/content/specialpowers.js", false); + + let frameScript = "SpecialPowers.prototype.IsInNestedFrame=true;"; + mm.loadFrameScript("data:," + frameScript, false); + } + }, "remote-browser-shown", false); +}; + +SpecialPowers.prototype.isServiceWorkerRegistered = function() { + var swm = Components.classes["@mozilla.org/serviceworkers/manager;1"] + .getService(Components.interfaces.nsIServiceWorkerManager); + return swm.getAllRegistrations().length != 0; +}; + +// Attach our API to the window. +function attachSpecialPowersToWindow(aWindow) { + try { + if ((aWindow !== null) && + (aWindow !== undefined) && + (aWindow.wrappedJSObject) && + !(aWindow.wrappedJSObject.SpecialPowers)) { + let sp = new SpecialPowers(aWindow); + aWindow.wrappedJSObject.SpecialPowers = sp; + if (sp.IsInNestedFrame) { + sp.addPermission("allowXULXBL", true, aWindow.document); + } + } + } catch(ex) { + dump("TEST-INFO | specialpowers.js | Failed to attach specialpowers to window exception: " + ex + "\n"); + } +} + +// This is a frame script, so it may be running in a content process. +// In any event, it is targeted at a specific "tab", so we listen for +// the DOMWindowCreated event to be notified about content windows +// being created in this context. + +function SpecialPowersManager() { + addEventListener("DOMWindowCreated", this, false); +} + +SpecialPowersManager.prototype = { + handleEvent: function handleEvent(aEvent) { + var window = aEvent.target.defaultView; + attachSpecialPowersToWindow(window); + } +}; + + +var specialpowersmanager = new SpecialPowersManager(); + +this.SpecialPowers = SpecialPowers; +this.attachSpecialPowersToWindow = attachSpecialPowersToWindow; + +// In the case of Chrome mochitests that inject specialpowers.js as +// a regular content script +if (typeof window != 'undefined') { + window.addMessageListener = function() {} + window.removeMessageListener = function() {} + window.wrappedJSObject.SpecialPowers = new SpecialPowers(window); +} diff --git a/testing/specialpowers/content/specialpowersAPI.js b/testing/specialpowers/content/specialpowersAPI.js new file mode 100644 index 000000000..ee94e84a3 --- /dev/null +++ b/testing/specialpowers/content/specialpowersAPI.js @@ -0,0 +1,2100 @@ +/* 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 in + * order to be used as a replacement for UniversalXPConnect + */ + +"use strict"; + +var global = this; + +var Ci = Components.interfaces; +var Cc = Components.classes; +var Cu = Components.utils; + +Cu.import("chrome://specialpowers/content/MockFilePicker.jsm"); +Cu.import("chrome://specialpowers/content/MockColorPicker.jsm"); +Cu.import("chrome://specialpowers/content/MockPermissionPrompt.jsm"); +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/PrivateBrowsingUtils.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/NetUtil.jsm"); + +// We're loaded with "this" not set to the global in some cases, so we +// have to play some games to get at the global object here. Normally +// we'd try "this" from a function called with undefined this value, +// but this whole file is in strict mode. So instead fall back on +// returning "this" from indirect eval, which returns the global. +if (!(function() { var e = eval; return e("this"); })().File) { + Cu.importGlobalProperties(["File"]); +} + +// Allow stuff from this scope to be accessed from non-privileged scopes. This +// would crash if used outside of automation. +Cu.forcePermissiveCOWs(); + +function SpecialPowersAPI() { + this._consoleListeners = []; + this._encounteredCrashDumpFiles = []; + this._unexpectedCrashDumpFiles = { }; + this._crashDumpDir = null; + this._mfl = null; + this._prefEnvUndoStack = []; + this._pendingPrefs = []; + this._applyingPrefs = false; + this._permissionsUndoStack = []; + this._pendingPermissions = []; + this._applyingPermissions = false; + this._observingPermissions = false; + this._fm = null; + this._cb = null; +} + +function bindDOMWindowUtils(aWindow) { + if (!aWindow) + return + + var util = aWindow.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindowUtils); + return wrapPrivileged(util); +} + +function getRawComponents(aWindow) { + // If we're running in automation that supports enablePrivilege, then we also + // provided access to the privileged Components. + try { + let win = Cu.waiveXrays(aWindow); + if (typeof win.netscape.security.PrivilegeManager == 'object') + Cu.forcePrivilegedComponentsForScope(aWindow); + } catch (e) {} + return Cu.getComponentsForScope(aWindow); +} + +function isWrappable(x) { + if (typeof x === "object") + return x !== null; + return typeof x === "function"; +}; + +function isWrapper(x) { + return isWrappable(x) && (typeof x.SpecialPowers_wrappedObject !== "undefined"); +}; + +function unwrapIfWrapped(x) { + return isWrapper(x) ? unwrapPrivileged(x) : x; +}; + +function wrapIfUnwrapped(x) { + return isWrapper(x) ? x : wrapPrivileged(x); +} + +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.indexOf(className) != -1; +} + +// 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) { + + // Primitives pass straight through. + if (!isWrappable(obj)) + return obj; + + // No double wrapping. + if (isWrapper(obj)) + throw "Trying to double-wrap object!"; + + let dummy; + if (typeof obj === "function") + dummy = function() {}; + else + dummy = Object.create(null); + + return new Proxy(dummy, new SpecialPowersHandler(obj)); +}; + +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 "Trying to unwrap a non-wrapped object!"; + + var obj = x.SpecialPowers_wrappedObject; + // unwrapped. + return obj; +}; + +function SpecialPowersHandler(wrappedObject) { + this.wrappedObject = wrappedObject; +} + +SpecialPowersHandler.prototype = { + construct(target, args) { + // The arguments may or may not be wrappers. Unwrap them if necessary. + var unwrappedArgs = Array.prototype.slice.call(args).map(unwrapIfWrapped); + + // We want to invoke "obj" as a constructor, but using unwrappedArgs as + // the arguments. Make sure to wrap and re-throw exceptions! + try { + return wrapIfUnwrapped(Reflect.construct(this.wrappedObject, unwrappedArgs)); + } catch (e) { + throw wrapIfUnwrapped(e); + } + }, + + apply(target, thisValue, args) { + // The invocant and arguments may or may not be wrappers. Unwrap + // them if necessary. + var invocant = unwrapIfWrapped(thisValue); + var unwrappedArgs = Array.prototype.slice.call(args).map(unwrapIfWrapped); + + try { + return wrapIfUnwrapped(doApply(this.wrappedObject, invocant, unwrappedArgs)); + } catch (e) { + // Wrap exceptions and re-throw them. + throw wrapIfUnwrapped(e); + } + }, + + has(target, prop) { + if (prop === "SpecialPowers_wrappedObject") + return true; + + return Reflect.has(this.wrappedObject, prop); + }, + + get(target, prop, receiver) { + if (prop === "SpecialPowers_wrappedObject") + return this.wrappedObject; + + let obj = waiveXraysIfAppropriate(this.wrappedObject, prop); + return wrapIfUnwrapped(Reflect.get(obj, prop)); + }, + + set(target, prop, val, receiver) { + if (prop === "SpecialPowers_wrappedObject") + return false; + + let obj = waiveXraysIfAppropriate(this.wrappedObject, prop); + return Reflect.set(obj, prop, unwrapIfWrapped(val)); + }, + + delete(target, prop) { + if (prop === "SpecialPowers_wrappedObject") + return false; + + return Reflect.deleteProperty(this.wrappedObject, prop); + }, + + defineProperty(target, prop, descriptor) { + throw "Can't call defineProperty on SpecialPowers wrapped object"; + }, + + getOwnPropertyDescriptor(target, prop) { + // Handle our special API. + if (prop === "SpecialPowers_wrappedObject") { + return { value: this.wrappedObject, writeable: true, + configurable: true, enumerable: false }; + } + + let obj = waiveXraysIfAppropriate(this.wrappedObject, prop); + let desc = Reflect.getOwnPropertyDescriptor(obj, prop); + + if (desc === undefined) + return undefined; + + // Transitively maintain the wrapper membrane. + function wrapIfExists(key) { + if (key in desc) + desc[key] = wrapIfUnwrapped(desc[key]); + }; + + 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 desc; + }, + + ownKeys(target) { + // Insert our special API. It's not enumerable, but ownKeys() + // includes non-enumerable properties. + let props = ['SpecialPowers_wrappedObject']; + + // Do the normal thing. + let flt = (a) => !props.includes(a); + props = props.concat(Reflect.ownKeys(this.wrappedObject).filter(flt)); + + // If we've got an Xray wrapper, include the expandos as well. + if ('wrappedJSObject' in this.wrappedObject) { + props = props.concat(Reflect.ownKeys(this.wrappedObject.wrappedJSObject) + .filter(flt)); + } + + return props; + }, + + preventExtensions(target) { + throw "Can't call preventExtensions on SpecialPowers wrapped object"; + } +}; + +// 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) { + this.callback = callback; +} + +SPConsoleListener.prototype = { + observe: function(msg) { + let m = { message: msg.message, + errorMessage: null, + sourceName: null, + sourceLine: null, + lineNumber: null, + columnNumber: null, + category: null, + windowID: null, + isScriptError: false, + isWarning: false, + isException: false, + isStrict: false }; + if (msg instanceof Ci.nsIScriptError) { + m.errorMessage = msg.errorMessage; + 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.isScriptError = true; + m.isWarning = ((msg.flags & Ci.nsIScriptError.warningFlag) === 1); + m.isException = ((msg.flags & Ci.nsIScriptError.exceptionFlag) === 1); + m.isStrict = ((msg.flags & Ci.nsIScriptError.strictFlag) === 1); + } + + Object.freeze(m); + + this.callback.call(undefined, m); + + if (!m.isScriptError && m.message === "SENTINEL") + Services.console.unregisterListener(this); + }, + + QueryInterface: XPCOMUtils.generateQI([Ci.nsIConsoleListener]) +}; + +function wrapCallback(cb) { + return function SpecialPowersCallbackWrapper() { + var args = Array.prototype.map.call(arguments, wrapIfUnwrapped); + return cb.apply(this, args); + } +} + +function wrapCallbackObject(obj) { + obj = Cu.waiveXrays(obj); + var wrapper = {}; + for (var i in obj) { + if (typeof obj[i] == 'function') + wrapper[i] = wrapCallback(obj[i]); + else + wrapper[i] = obj[i]; + } + return wrapper; +} + +function setWrapped(obj, prop, val) { + if (!isWrapper(obj)) + throw "You only need to use this for SpecialPowers wrapped objects"; + + obj = unwrapPrivileged(obj); + return Reflect.set(obj, prop, val); +} + +SpecialPowersAPI.prototype = { + + /* + * 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: wrapIfUnwrapped, + unwrap: unwrapIfWrapped, + isWrapper: isWrapper, + + /* + * 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: wrapCallback, + wrapCallbackObject: wrapCallbackObject, + + /* + * Used for assigning a property to a SpecialPowers wrapper, without unwrapping + * the value that is assigned. + */ + setWrapped: setWrapped, + + /* + * Create blank privileged objects to use as out-params for privileged functions. + */ + createBlankObject: function () { + return new Object; + }, + + /* + * 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: function(a, b) { + return unwrapIfWrapped(a) === unwrapIfWrapped(b); + }, + + get MockFilePicker() { + return MockFilePicker; + }, + + get MockColorPicker() { + return MockColorPicker; + }, + + get MockPermissionPrompt() { + return MockPermissionPrompt; + }, + + /* + * Load a privileged script that runs same-process. This is different from + * |loadChromeScript|, which will run in the parent process in e10s mode. + */ + loadPrivilegedScript: function (aFunction) { + var str = "(" + aFunction.toString() + ")();"; + var systemPrincipal = Services.scriptSecurityManager.getSystemPrincipal(); + var sb = Cu.Sandbox(systemPrincipal); + var window = this.window.get(); + var mc = new window.MessageChannel(); + sb.port = mc.port1; + try { + sb.eval(str); + } catch (e) { + throw wrapIfUnwrapped(e); + } + + return mc.port2; + }, + + loadChromeScript: function (urlOrFunction) { + // 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 }; + if (typeof(urlOrFunction) == "function") { + scriptArgs.function = { + body: "(" + urlOrFunction.toString() + ")();", + name: urlOrFunction.name, + }; + } else { + scriptArgs.url = urlOrFunction; + } + this._sendSyncMessage("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: name, listener: 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._sendSyncMessage("SPChromeScriptMessage", + { id: id, name: name, message: message }); + }, + + sendSyncMessage: (name, message) => { + return this._sendSyncMessage("SPChromeScriptMessage", + { id, name, message }); + }, + + destroy: () => { + listeners = []; + this._removeMessageListener("SPChromeScriptMessage", chromeScript); + this._removeMessageListener("SPChromeScriptAssert", chromeScript); + }, + + receiveMessage: (aMessage) => { + let messageId = aMessage.json.id; + let name = aMessage.json.name; + let message = aMessage.json.message; + // Ignore message from other chrome script + if (messageId != id) + return; + + if (aMessage.name == "SPChromeScriptMessage") { + listeners.filter(o => (o.name == name)) + .forEach(o => o.listener(message)); + } else if (aMessage.name == "SPChromeScriptAssert") { + assert(aMessage.json); + } + } + }; + this._addMessageListener("SPChromeScriptMessage", chromeScript); + this._addMessageListener("SPChromeScriptAssert", chromeScript); + + let assert = json => { + // An assertion has been done in a mochitest chrome script + let {name, err, message, stack} = json; + + // Try to fetch a test runner from the mochitest + // in order to properly log these assertions and notify + // all usefull log observers + let window = this.window.get(); + let parentRunner, repr = o => o; + if (window) { + window = window.wrappedJSObject; + parentRunner = window.TestRunner; + if (window.repr) { + repr = window.repr; + } + } + + // Craft a mochitest-like report string + var resultString = err ? "TEST-UNEXPECTED-FAIL" : "TEST-PASS"; + var diagnostic = + message ? message : + ("assertion @ " + stack.filename + ":" + stack.lineNumber); + if (err) { + diagnostic += + " - got " + repr(err.actual) + + ", expected " + repr(err.expected) + + " (operator " + err.operator + ")"; + } + var msg = [resultString, name, diagnostic].join(" | "); + if (parentRunner) { + if (err) { + parentRunner.addFailedTest(name); + parentRunner.error(msg); + } else { + parentRunner.log(msg); + } + } else { + // When we are running only a single mochitest, there is no test runner + dump(msg + "\n"); + } + }; + + return this.wrap(chromeScript); + }, + + importInMainProcess: function (importString) { + var message = this._sendSyncMessage("SPImportInMainProcess", importString)[0]; + if (message.hadError) { + throw "SpecialPowers.importInMainProcess failed with error " + message.errorMessage; + } + return; + }, + + get Services() { + return wrapPrivileged(Services); + }, + + /* + * In general, any Components object created for unprivileged scopes is + * neutered (it implements nsIXPCComponentsBase, but not nsIXPCComponents). + * We override this in certain legacy automation configurations (see the + * implementation of getRawComponents() above), but don't want to support + * it in cases where it isn't already required. + * + * In scopes with neutered Components, we don't have a natural referent for + * things like SpecialPowers.Cc. So in those cases, we fall back to the + * Components object from the SpecialPowers scope. This doesn't quite behave + * the same way (in particular, SpecialPowers.Cc[foo].createInstance() will + * create an instance in the SpecialPowers scope), but SpecialPowers wrapping + * is already a YMMV / Whatever-It-Takes-To-Get-TBPL-Green sort of thing. + * + * It probably wouldn't be too much work to just make SpecialPowers.Components + * unconditionally point to the Components object in the SpecialPowers scope. + * Try will tell what needs to be fixed up. + */ + getFullComponents: function() { + if (this.Components && typeof this.Components.classes == 'object') { + return this.Components; + } + return Components; + }, + + /* + * Convenient shortcuts to the standard Components abbreviations. Note that + * we don't SpecialPowers-wrap Components.interfaces, because it's available + * to untrusted content, and wrapping it confuses QI and identity checks. + */ + get Cc() { return wrapPrivileged(this.getFullComponents().classes); }, + get Ci() { return this.Components ? this.Components.interfaces + : Components.interfaces; }, + get Cu() { return wrapPrivileged(this.getFullComponents().utils); }, + get Cr() { return wrapPrivileged(this.Components.results); }, + + /* + * SpecialPowers.getRawComponents() allows content to get a reference to a + * naked (and, in certain automation configurations, privileged) Components + * object for its scope. + * + * SpecialPowers.getRawComponents(window) is defined as the global property + * window.SpecialPowers.Components for convenience. + */ + getRawComponents: getRawComponents, + + getDOMWindowUtils: function(aWindow) { + if (aWindow == this.window.get() && this.DOMWindowUtils != null) + return this.DOMWindowUtils; + + return bindDOMWindowUtils(aWindow); + }, + + removeExpectedCrashDumpFiles: function(aExpectingProcessCrash) { + var success = true; + if (aExpectingProcessCrash) { + var message = { + op: "delete-crash-dump-files", + filenames: this._encounteredCrashDumpFiles + }; + if (!this._sendSyncMessage("SPProcessCrashService", message)[0]) { + success = false; + } + } + this._encounteredCrashDumpFiles.length = 0; + return success; + }, + + findUnexpectedCrashDumpFiles: function() { + var self = this; + var message = { + op: "find-crash-dump-files", + crashDumpFilesToIgnore: this._unexpectedCrashDumpFiles + }; + var crashDumpFiles = this._sendSyncMessage("SPProcessCrashService", message)[0]; + crashDumpFiles.forEach(function(aFilename) { + self._unexpectedCrashDumpFiles[aFilename] = true; + }); + return crashDumpFiles; + }, + + _setTimeout: function(callback) { + // for mochitest-browser + if (typeof window != 'undefined') + setTimeout(callback, 0); + // for mochitest-plain + else + content.window.setTimeout(callback, 0); + }, + + _delayCallbackTwice: function(callback) { + function delayedCallback() { + function delayAgain(aCallback) { + // Using this._setTimeout doesn't work here + // It causes failures in mochtests that use + // multiple pushPrefEnv calls + // For chrome/browser-chrome mochitests + if (typeof window != 'undefined') + setTimeout(aCallback, 0); + // For mochitest-plain + else + content.window.setTimeout(aCallback, 0); + } + delayAgain(delayAgain(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 + */ + pushPermissions: function(inPermissions, callback) { + inPermissions = Cu.waiveXrays(inPermissions); + var pendingPermissions = []; + var cleanupPermissions = []; + + for (var p in inPermissions) { + var permission = inPermissions[p]; + var originalValue = Ci.nsIPermissionManager.UNKNOWN_ACTION; + var context = Cu.unwaiveXrays(permission.context); // Sometimes |context| is a DOM object on which we expect + // to be able to access .nodePrincipal, so we need to unwaive. + if (this.testPermission(permission.type, Ci.nsIPermissionManager.ALLOW_ACTION, context)) { + originalValue = Ci.nsIPermissionManager.ALLOW_ACTION; + } else if (this.testPermission(permission.type, Ci.nsIPermissionManager.DENY_ACTION, context)) { + originalValue = Ci.nsIPermissionManager.DENY_ACTION; + } else if (this.testPermission(permission.type, Ci.nsIPermissionManager.PROMPT_ACTION, context)) { + originalValue = Ci.nsIPermissionManager.PROMPT_ACTION; + } else if (this.testPermission(permission.type, Ci.nsICookiePermission.ACCESS_SESSION, context)) { + originalValue = Ci.nsICookiePermission.ACCESS_SESSION; + } else if (this.testPermission(permission.type, Ci.nsICookiePermission.ACCESS_ALLOW_FIRST_PARTY_ONLY, context)) { + originalValue = Ci.nsICookiePermission.ACCESS_ALLOW_FIRST_PARTY_ONLY; + } else if (this.testPermission(permission.type, Ci.nsICookiePermission.ACCESS_LIMIT_THIRD_PARTY, context)) { + originalValue = Ci.nsICookiePermission.ACCESS_LIMIT_THIRD_PARTY; + } + + let principal = this._getPrincipalFromArg(context); + if (principal.isSystemPrincipal) { + continue; + } + + let perm; + if (typeof permission.allow !== 'boolean') { + perm = permission.allow; + } else { + perm = permission.allow ? Ci.nsIPermissionManager.ALLOW_ACTION + : Ci.nsIPermissionManager.DENY_ACTION; + } + + if (permission.remove == true) + perm = Ci.nsIPermissionManager.UNKNOWN_ACTION; + + if (originalValue == perm) { + continue; + } + + var todo = {'op': 'add', + 'type': permission.type, + 'permission': perm, + 'value': perm, + 'principal': 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 == true) + todo.op = 'remove'; + + pendingPermissions.push(todo); + + /* Push original permissions value or clear into cleanup array */ + if (originalValue == Ci.nsIPermissionManager.UNKNOWN_ACTION) { + cleanupTodo.op = 'remove'; + } else { + cleanupTodo.value = originalValue; + cleanupTodo.permission = originalValue; + } + cleanupPermissions.push(cleanupTodo); + } + + if (pendingPermissions.length > 0) { + // The callback needs to be delayed twice. One delay is because the pref + // service doesn't guarantee the order it calls its observers in, so it + // may notify the observer holding the callback before the other + // observers have been notified and given a chance to make the changes + // that the callback checks for. The second delay is because pref + // observers often defer making their changes by posting an event to the + // event loop. + if (!this._observingPermissions) { + this._observingPermissions = true; + // If specialpowers is in main-process, then we can add a observer + // to get all 'perm-changed' signals. Otherwise, it can't receive + // all signals, so we register a observer in specialpowersobserver(in + // main-process) and get signals from it. + if (this.isMainProcess()) { + this.permissionObserverProxy._specialPowersAPI = this; + Services.obs.addObserver(this.permissionObserverProxy, "perm-changed", false); + } else { + this.registerObservers("perm-changed"); + // bind() is used to set 'this' to SpecialPowersAPI itself. + this._addMessageListener("specialpowers-perm-changed", this.permChangedProxy.bind(this)); + } + } + this._permissionsUndoStack.push(cleanupPermissions); + this._pendingPermissions.push([pendingPermissions, + this._delayCallbackTwice(callback)]); + this._applyPermissions(); + } else { + this._setTimeout(callback); + } + }, + + /* + * 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. + * + * NOTICE: there is no implementation of _addMessageListener in + * ChromePowers.js + */ + registerObservers: function(topic) { + var msg = { + 'op': 'add', + 'observerTopic': topic, + }; + this._sendSyncMessage("SPObserverService", msg); + }, + + permChangedProxy: function(aMessage) { + let permission = aMessage.json.permission; + let aData = aMessage.json.aData; + this._permissionObserver.observe(permission, aData); + }, + + permissionObserverProxy: { + // 'this' in permChangedObserverProxy is the permChangedObserverProxy + // object itself. The '_specialPowersAPI' will be set to the 'SpecialPowersAPI' + // object to call the member function in SpecialPowersAPI. + _specialPowersAPI: null, + observe: function (aSubject, aTopic, aData) + { + if (aTopic == "perm-changed") { + var permission = aSubject.QueryInterface(Ci.nsIPermission); + this._specialPowersAPI._permissionObserver.observe(permission, aData); + } + } + }, + + popPermissions: function(callback) { + if (this._permissionsUndoStack.length > 0) { + // See pushPermissions comment regarding delay. + let cb = callback ? this._delayCallbackTwice(callback) : null; + /* Each pop from the stack will yield an object {op/type/permission/value/url/appid/isInIsolatedMozBrowserElement} or null */ + this._pendingPermissions.push([this._permissionsUndoStack.pop(), cb]); + this._applyPermissions(); + } else { + if (this._observingPermissions) { + this._observingPermissions = false; + this._removeMessageListener("specialpowers-perm-changed", this.permChangedProxy.bind(this)); + } + this._setTimeout(callback); + } + }, + + flushPermissions: function(callback) { + while (this._permissionsUndoStack.length > 1) + this.popPermissions(null); + + this.popPermissions(callback); + }, + + + setTestPluginEnabledState: function(newEnabledState, pluginName) { + return this._sendSyncMessage("SPSetTestPluginEnabledState", + { newEnabledState: newEnabledState, pluginName: pluginName })[0]; + }, + + + _permissionObserver: { + _self: null, + _lastPermission: {}, + _callBack: null, + _nextCallback: null, + _obsDataMap: { + 'deleted':'remove', + 'added':'add' + }, + observe: function (permission, aData) + { + if (this._self._applyingPermissions) { + if (permission.type == this._lastPermission.type) { + this._self._setTimeout(this._callback); + this._self._setTimeout(this._nextCallback); + this._callback = null; + this._nextCallback = null; + } + } else { + var found = false; + for (var i = 0; !found && i < this._self._permissionsUndoStack.length; i++) { + var undos = this._self._permissionsUndoStack[i]; + for (var j = 0; j < undos.length; j++) { + var undo = undos[j]; + if (undo.op == this._obsDataMap[aData] && + undo.principal.originAttributes.appId == permission.principal.originAttributes.appId && + undo.type == permission.type) { + // Remove this undo item if it has been done by others(not + // specialpowers itself.) + undos.splice(j,1); + found = true; + break; + } + } + if (!undos.length) { + // Remove the empty row in permissionsUndoStack + this._self._permissionsUndoStack.splice(i, 1); + } + } + } + } + }, + + /* + Iterate through one atomic set of permissions actions and perform allow/deny as appropriate. + All actions performed must modify the relevant permission. + */ + _applyPermissions: function() { + if (this._applyingPermissions || this._pendingPermissions.length <= 0) { + return; + } + + /* Set lock and get prefs from the _pendingPrefs queue */ + this._applyingPermissions = true; + var transaction = this._pendingPermissions.shift(); + var pendingActions = transaction[0]; + var callback = transaction[1]; + var lastPermission = pendingActions[pendingActions.length-1]; + + var self = this; + this._permissionObserver._self = self; + this._permissionObserver._lastPermission = lastPermission; + this._permissionObserver._callback = callback; + this._permissionObserver._nextCallback = function () { + self._applyingPermissions = false; + // Now apply any permissions that may have been queued while we were applying + self._applyPermissions(); + } + + for (var idx in pendingActions) { + var perm = pendingActions[idx]; + this._sendSyncMessage('SPPermissionManager', perm)[0]; + } + }, + + /** + * Helper to resolve a promise by calling the resolve function and call an + * optional callback. + */ + _resolveAndCallOptionalCallback(resolveFn, callback = null) { + resolveFn(); + + if (callback) { + callback(); + } + }, + + /** + * Take in a list of pref changes to make, then invokes |callback| and resolves + * the returned Promise once those changes have taken effect. 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. + * + * (Implementation note: _prefEnvUndoStack is a stack of values to revert to, + * not values which have been set!) + * + * TODO: complex values for original cleanup? + * + */ + pushPrefEnv: function(inPrefs, callback = null) { + var prefs = Services.prefs; + + var pref_string = []; + pref_string[prefs.PREF_INT] = "INT"; + pref_string[prefs.PREF_BOOL] = "BOOL"; + pref_string[prefs.PREF_STRING] = "CHAR"; + + var pendingActions = []; + var cleanupActions = []; + + for (var action in inPrefs) { /* set|clear */ + for (var idx in inPrefs[action]) { + var aPref = inPrefs[action][idx]; + var prefName = aPref[0]; + var prefValue = null; + var prefIid = null; + var prefType = prefs.PREF_INVALID; + var originalValue = null; + + if (aPref.length == 3) { + prefValue = aPref[1]; + prefIid = aPref[2]; + } else if (aPref.length == 2) { + prefValue = aPref[1]; + } + + /* If pref is not found or invalid it doesn't exist. */ + if (prefs.getPrefType(prefName) != prefs.PREF_INVALID) { + prefType = pref_string[prefs.getPrefType(prefName)]; + if ((prefs.prefHasUserValue(prefName) && action == 'clear') || + (action == 'set')) + originalValue = this._getPref(prefName, prefType); + } else if (action == 'set') { + /* prefName doesn't exist, so 'clear' is pointless */ + if (aPref.length == 3) { + prefType = "COMPLEX"; + } else if (aPref.length == 2) { + if (typeof(prefValue) == "boolean") + prefType = "BOOL"; + else if (typeof(prefValue) == "number") + prefType = "INT"; + else if (typeof(prefValue) == "string") + prefType = "CHAR"; + } + } + + /* PREF_INVALID: A non existing pref which we are clearing or invalid values for a set */ + if (prefType == prefs.PREF_INVALID) + continue; + + /* We are not going to set a pref if the value is the same */ + if (originalValue == prefValue) + continue; + + pendingActions.push({'action': action, 'type': prefType, 'name': prefName, 'value': prefValue, 'Iid': prefIid}); + + /* Push original preference value or clear into cleanup array */ + var cleanupTodo = {'action': action, 'type': prefType, 'name': prefName, 'value': originalValue, 'Iid': prefIid}; + if (originalValue == null) { + cleanupTodo.action = 'clear'; + } else { + cleanupTodo.action = 'set'; + } + cleanupActions.push(cleanupTodo); + } + } + + return new Promise(resolve => { + let done = this._resolveAndCallOptionalCallback.bind(this, resolve, callback); + if (pendingActions.length > 0) { + // The callback needs to be delayed twice. One delay is because the pref + // service doesn't guarantee the order it calls its observers in, so it + // may notify the observer holding the callback before the other + // observers have been notified and given a chance to make the changes + // that the callback checks for. The second delay is because pref + // observers often defer making their changes by posting an event to the + // event loop. + this._prefEnvUndoStack.push(cleanupActions); + this._pendingPrefs.push([pendingActions, + this._delayCallbackTwice(done)]); + this._applyPrefs(); + } else { + this._setTimeout(done); + } + }); + }, + + popPrefEnv: function(callback = null) { + return new Promise(resolve => { + let done = this._resolveAndCallOptionalCallback.bind(this, resolve, callback); + if (this._prefEnvUndoStack.length > 0) { + // See pushPrefEnv comment regarding delay. + let cb = this._delayCallbackTwice(done); + /* Each pop will have a valid block of preferences */ + this._pendingPrefs.push([this._prefEnvUndoStack.pop(), cb]); + this._applyPrefs(); + } else { + this._setTimeout(done); + } + }); + }, + + flushPrefEnv: function(callback = null) { + while (this._prefEnvUndoStack.length > 1) + this.popPrefEnv(null); + + return new Promise(resolve => { + let done = this._resolveAndCallOptionalCallback.bind(this, resolve, callback); + this.popPrefEnv(done); + }); + }, + + /* + Iterate through one atomic set of pref actions and perform sets/clears as appropriate. + All actions performed must modify the relevant pref. + */ + _applyPrefs: function() { + if (this._applyingPrefs || this._pendingPrefs.length <= 0) { + return; + } + + /* Set lock and get prefs from the _pendingPrefs queue */ + this._applyingPrefs = true; + var transaction = this._pendingPrefs.shift(); + var pendingActions = transaction[0]; + var callback = transaction[1]; + + var lastPref = pendingActions[pendingActions.length-1]; + + var pb = Services.prefs; + var self = this; + pb.addObserver(lastPref.name, function prefObs(subject, topic, data) { + pb.removeObserver(lastPref.name, prefObs); + + self._setTimeout(callback); + self._setTimeout(function () { + self._applyingPrefs = false; + // Now apply any prefs that may have been queued while we were applying + self._applyPrefs(); + }); + }, false); + + for (var idx in pendingActions) { + var pref = pendingActions[idx]; + if (pref.action == 'set') { + this._setPref(pref.name, pref.type, pref.value, pref.Iid); + } else if (pref.action == 'clear') { + this.clearUserPref(pref.name); + } + } + }, + + _proxiedObservers: { + "specialpowers-http-notify-request": function(aMessage) { + let uri = aMessage.json.uri; + Services.obs.notifyObservers(null, "specialpowers-http-notify-request", uri); + }, + "specialpowers-browser-fullZoom:zoomReset": function() { + Services.obs.notifyObservers(null, "specialpowers-browser-fullZoom:zoomReset", null); + }, + }, + + _addObserverProxy: function(notification) { + if (notification in this._proxiedObservers) { + this._addMessageListener(notification, this._proxiedObservers[notification]); + } + }, + _removeObserverProxy: function(notification) { + if (notification in this._proxiedObservers) { + this._removeMessageListener(notification, this._proxiedObservers[notification]); + } + }, + + addObserver: function(obs, notification, weak) { + this._addObserverProxy(notification); + obs = Cu.waiveXrays(obs); + if (typeof obs == 'object' && obs.observe.name != 'SpecialPowersCallbackWrapper') + obs.observe = wrapCallback(obs.observe); + Services.obs.addObserver(obs, notification, weak); + }, + removeObserver: function(obs, notification) { + this._removeObserverProxy(notification); + Services.obs.removeObserver(Cu.waiveXrays(obs), notification); + }, + notifyObservers: function(subject, topic, data) { + Services.obs.notifyObservers(subject, topic, data); + }, + + can_QI: function(obj) { + return obj.QueryInterface !== undefined; + }, + do_QueryInterface: function(obj, iface) { + return obj.QueryInterface(Ci[iface]); + }, + + call_Instanceof: function (obj1, obj2) { + obj1=unwrapIfWrapped(obj1); + obj2=unwrapIfWrapped(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: function(obj, name) { + return Object.prototype.__lookupGetter__.call(obj, name); + }, + + // Mimic the get*Pref API + getBoolPref: function(aPrefName) { + return (this._getPref(aPrefName, 'BOOL')); + }, + getIntPref: function(aPrefName) { + return (this._getPref(aPrefName, 'INT')); + }, + getCharPref: function(aPrefName) { + return (this._getPref(aPrefName, 'CHAR')); + }, + getComplexValue: function(aPrefName, aIid) { + return (this._getPref(aPrefName, 'COMPLEX', aIid)); + }, + + // Mimic the set*Pref API + setBoolPref: function(aPrefName, aValue) { + return (this._setPref(aPrefName, 'BOOL', aValue)); + }, + setIntPref: function(aPrefName, aValue) { + return (this._setPref(aPrefName, 'INT', aValue)); + }, + setCharPref: function(aPrefName, aValue) { + return (this._setPref(aPrefName, 'CHAR', aValue)); + }, + setComplexValue: function(aPrefName, aIid, aValue) { + return (this._setPref(aPrefName, 'COMPLEX', aValue, aIid)); + }, + + // Mimic the clearUserPref API + clearUserPref: function(aPrefName) { + var msg = {'op':'clear', 'prefName': aPrefName, 'prefType': ""}; + this._sendSyncMessage('SPPrefService', msg); + }, + + // Private pref functions to communicate to chrome + _getPref: function(aPrefName, aPrefType, aIid) { + var msg = {}; + if (aIid) { + // Overloading prefValue to handle complex prefs + msg = {'op':'get', 'prefName': aPrefName, 'prefType':aPrefType, 'prefValue':[aIid]}; + } else { + msg = {'op':'get', 'prefName': aPrefName,'prefType': aPrefType}; + } + var val = this._sendSyncMessage('SPPrefService', msg); + + if (val == null || val[0] == null) + throw "Error getting pref '" + aPrefName + "'"; + return val[0]; + }, + _setPref: function(aPrefName, aPrefType, aValue, aIid) { + var msg = {}; + if (aIid) { + msg = {'op':'set','prefName':aPrefName, 'prefType': aPrefType, 'prefValue': [aIid,aValue]}; + } else { + msg = {'op':'set', 'prefName': aPrefName, 'prefType': aPrefType, 'prefValue': aValue}; + } + return(this._sendSyncMessage('SPPrefService', msg)[0]); + }, + + _getDocShell: function(window) { + return window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebNavigation) + .QueryInterface(Ci.nsIDocShell); + }, + _getMUDV: function(window) { + return this._getDocShell(window).contentViewer; + }, + //XXX: these APIs really ought to be removed, they're not e10s-safe. + // (also they're pretty Firefox-specific) + _getTopChromeWindow: function(window) { + return window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIWebNavigation) + .QueryInterface(Ci.nsIDocShellTreeItem) + .rootTreeItem + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindow) + .QueryInterface(Ci.nsIDOMChromeWindow); + }, + _getAutoCompletePopup: function(window) { + return this._getTopChromeWindow(window).document + .getElementById("PopupAutoComplete"); + }, + addAutoCompletePopupEventListener: function(window, eventname, listener) { + this._getAutoCompletePopup(window).addEventListener(eventname, + listener, + false); + }, + removeAutoCompletePopupEventListener: function(window, eventname, listener) { + this._getAutoCompletePopup(window).removeEventListener(eventname, + listener, + false); + }, + get formHistory() { + let tmp = {}; + Cu.import("resource://gre/modules/FormHistory.jsm", tmp); + return wrapPrivileged(tmp.FormHistory); + }, + getFormFillController: function(window) { + return Components.classes["@mozilla.org/satchel/form-fill-controller;1"] + .getService(Components.interfaces.nsIFormFillController); + }, + attachFormFillControllerTo: function(window) { + this.getFormFillController() + .attachToBrowser(this._getDocShell(window), + this._getAutoCompletePopup(window)); + }, + detachFormFillControllerFrom: function(window) { + this.getFormFillController().detachFromBrowser(this._getDocShell(window)); + }, + isBackButtonEnabled: function(window) { + return !this._getTopChromeWindow(window).document + .getElementById("Browser:Back") + .hasAttribute("disabled"); + }, + //XXX end of problematic APIs + + addChromeEventListener: function(type, listener, capture, allowUntrusted) { + addEventListener(type, listener, capture, allowUntrusted); + }, + removeChromeEventListener: function(type, listener, capture) { + removeEventListener(type, listener, capture); + }, + + // 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: function(callback) { + let listener = new SPConsoleListener(callback); + Services.console.registerListener(listener); + }, + postConsoleSentinel: function() { + Services.console.logStringMessage("SENTINEL"); + }, + resetConsole: function() { + Services.console.reset(); + }, + + getFullZoom: function(window) { + return this._getMUDV(window).fullZoom; + }, + setFullZoom: function(window, zoom) { + this._getMUDV(window).fullZoom = zoom; + }, + getTextZoom: function(window) { + return this._getMUDV(window).textZoom; + }, + setTextZoom: function(window, zoom) { + this._getMUDV(window).textZoom = zoom; + }, + + getOverrideDPPX: function(window) { + return this._getMUDV(window).overrideDPPX; + }, + setOverrideDPPX: function(window, dppx) { + this._getMUDV(window).overrideDPPX = dppx; + }, + + emulateMedium: function(window, mediaType) { + this._getMUDV(window).emulateMedium(mediaType); + }, + stopEmulatingMedium: function(window) { + this._getMUDV(window).stopEmulatingMedium(); + }, + + snapshotWindowWithOptions: function (win, rect, bgcolor, options) { + var el = this.window.get().document.createElementNS("http://www.w3.org/1999/xhtml", "canvas"); + if (rect === undefined) { + rect = { top: win.scrollY, left: win.scrollX, + width: win.innerWidth, height: win.innerHeight }; + } + if (bgcolor === undefined) { + bgcolor = "rgb(255,255,255)"; + } + if (options === undefined) { + options = { }; + } + + el.width = rect.width; + el.height = rect.height; + var ctx = el.getContext("2d"); + var flags = 0; + + for (var option in options) { + flags |= options[option] && ctx[option]; + } + + ctx.drawWindow(win, + rect.left, rect.top, rect.width, rect.height, + bgcolor, + flags); + return el; + }, + + snapshotWindow: function (win, withCaret, rect, bgcolor) { + return this.snapshotWindowWithOptions(win, rect, bgcolor, + { DRAWWINDOW_DRAW_CARET: withCaret }); + }, + + snapshotRect: function (win, rect, bgcolor) { + return this.snapshotWindowWithOptions(win, rect, bgcolor); + }, + + gc: function() { + this.DOMWindowUtils.garbageCollect(); + }, + + forceGC: function() { + Cu.forceGC(); + }, + + forceCC: function() { + Cu.forceCC(); + }, + + finishCC: function() { + Cu.finishCC(); + }, + + ccSlice: function(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: function(callback) { + let count = 0; + + function genGCCallback(cb) { + return function() { + Cu.forceCC(); + if (++count < 2) { + Cu.schedulePreciseGC(genGCCallback(cb)); + } else if (cb) { + cb(); + } + } + } + + Cu.schedulePreciseGC(genGCCallback(callback)); + }, + + setGCZeal: function(zeal) { + Cu.setGCZeal(zeal); + }, + + isMainProcess: function() { + try { + return Cc["@mozilla.org/xre/app-info;1"]. + getService(Ci.nsIXULRuntime). + processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT; + } catch (e) { } + return true; + }, + + _xpcomabi: null, + + get XPCOMABI() { + if (this._xpcomabi != null) + return this._xpcomabi; + + var xulRuntime = Cc["@mozilla.org/xre/app-info;1"] + .getService(Components.interfaces.nsIXULAppInfo) + .QueryInterface(Components.interfaces.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: function(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); + }, + + _os: null, + + get OS() { + if (this._os != null) + return this._os; + + var xulRuntime = Cc["@mozilla.org/xre/app-info;1"] + .getService(Components.interfaces.nsIXULAppInfo) + .QueryInterface(Components.interfaces.nsIXULRuntime); + + this._os = xulRuntime.OS; + return this._os; + }, + + get isB2G() { +#ifdef MOZ_B2G + return true; +#else + return false; +#endif + }, + + addSystemEventListener: function(target, type, listener, useCapture) { + Cc["@mozilla.org/eventlistenerservice;1"]. + getService(Ci.nsIEventListenerService). + addSystemEventListener(target, type, listener, useCapture); + }, + removeSystemEventListener: function(target, type, listener, useCapture) { + Cc["@mozilla.org/eventlistenerservice;1"]. + getService(Ci.nsIEventListenerService). + 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: function(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: function() { + 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 res; + }, + + setLogFile: function(path) { + this._mfl = new MozillaFileLogger(path); + }, + + log: function(data) { + this._mfl.log(data); + }, + + closeLogFile: function() { + this._mfl.close(); + }, + + addCategoryEntry: function(category, entry, value, persists, replace) { + Components.classes["@mozilla.org/categorymanager;1"]. + getService(Components.interfaces.nsICategoryManager). + addCategoryEntry(category, entry, value, persists, replace); + }, + + deleteCategoryEntry: function(category, entry, persists) { + Components.classes["@mozilla.org/categorymanager;1"]. + getService(Components.interfaces.nsICategoryManager). + deleteCategoryEntry(category, entry, persists); + }, + openDialog: function(win, args) { + return win.openDialog.apply(win, args); + }, + // This is a blocking call which creates and spins a native event loop + spinEventLoop: function(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: function(obj, props) { + var parts = props.split('.'); + for (var i = 0; i < parts.length; i++) { + var p = parts[i]; + if (obj[p]) { + obj = obj[p]; + } else { + return null; + } + } + return obj; + }, + + get focusManager() { + if (this._fm != null) + return this._fm; + + this._fm = Components.classes["@mozilla.org/focus-manager;1"]. + getService(Components.interfaces.nsIFocusManager); + + return this._fm; + }, + + getFocusedElementForWindow: function(targetWindow, aDeep) { + var outParam = {}; + this.focusManager.getFocusedElementForWindow(targetWindow, aDeep, outParam); + return outParam.value; + }, + + activeWindow: function() { + return this.focusManager.activeWindow; + }, + + focusedWindow: function() { + return this.focusManager.focusedWindow; + }, + + focus: function(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(); + var mm = global; + if (aWindow) { + try { + mm = aWindow.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDocShell) + .QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIContentFrameMessageManager); + } catch (ex) { + /* Ignore exceptions for e.g. XUL chrome windows from mochitest-chrome + * which won't have a message manager */ + } + } + mm.sendAsyncMessage("SpecialPowers.Focus", {}); + }, + + getClipboardData: function(flavor, whichClipboard) { + if (this._cb == null) + this._cb = Components.classes["@mozilla.org/widget/clipboard;1"]. + getService(Components.interfaces.nsIClipboard); + if (whichClipboard === undefined) + whichClipboard = this._cb.kGlobalClipboard; + + var xferable = Components.classes["@mozilla.org/widget/transferable;1"]. + createInstance(Components.interfaces.nsITransferable); + // in e10s b-c tests |content.window| is a CPOW whereas |window| works fine. + // for some non-e10s mochi tests, |window| is null whereas |content.window| + // works fine. So we take whatever is non-null! + xferable.init(this._getDocShell(typeof(window) == "undefined" ? content.window : window) + .QueryInterface(Components.interfaces.nsILoadContext)); + xferable.addDataFlavor(flavor); + this._cb.getData(xferable, whichClipboard); + var data = {}; + try { + xferable.getTransferData(flavor, data, {}); + } catch (e) {} + data = data.value || null; + if (data == null) + return ""; + + return data.QueryInterface(Components.interfaces.nsISupportsString).data; + }, + + clipboardCopyString: function(str) { + Cc["@mozilla.org/widget/clipboardhelper;1"]. + getService(Ci.nsIClipboardHelper). + copyString(str); + }, + + supportsSelectionClipboard: function() { + if (this._cb == null) { + this._cb = Components.classes["@mozilla.org/widget/clipboard;1"]. + getService(Components.interfaces.nsIClipboard); + } + return this._cb.supportsSelectionClipboard(); + }, + + swapFactoryRegistration: function(cid, contractID, newFactory, oldFactory) { + newFactory = Cu.waiveXrays(newFactory); + oldFactory = Cu.waiveXrays(oldFactory); + + var componentRegistrar = Components.manager.QueryInterface(Components.interfaces.nsIComponentRegistrar); + + var unregisterFactory = newFactory; + var registerFactory = oldFactory; + + if (cid == null) { + if (contractID != null) { + cid = componentRegistrar.contractIDToCID(contractID); + oldFactory = Components.manager.getClassObject(Components.classes[contractID], + Components.interfaces.nsIFactory); + } else { + return {'error': "trying to register a new contract ID: Missing contractID"}; + } + + unregisterFactory = oldFactory; + registerFactory = newFactory; + } + componentRegistrar.unregisterFactory(cid, + unregisterFactory); + + // Restore the original factory. + componentRegistrar.registerFactory(cid, + "", + contractID, + registerFactory); + return {'cid':cid, 'originalFactory':oldFactory}; + }, + + _getElement: function(aWindow, id) { + return ((typeof(id) == "string") ? + aWindow.document.getElementById(id) : id); + }, + + dispatchEvent: function(aWindow, target, event) { + var el = this._getElement(aWindow, target); + return el.dispatchEvent(event); + }, + + get isDebugBuild() { + delete SpecialPowersAPI.prototype.isDebugBuild; + + var debug = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2); + return SpecialPowersAPI.prototype.isDebugBuild = debug.isDebugBuild; + }, + assertionCount: function() { + var debugsvc = Cc['@mozilla.org/xpcom/debug;1'].getService(Ci.nsIDebug2); + return debugsvc.assertionCount; + }, + + /** + * Get the message manager associated with an <iframe mozbrowser>. + */ + getBrowserFrameMessageManager: function(aFrameElement) { + return this.wrap(aFrameElement.QueryInterface(Ci.nsIFrameLoaderOwner) + .frameLoader + .messageManager); + }, + + _getPrincipalFromArg: function(arg) { + let principal; + let secMan = Services.scriptSecurityManager; + + if (typeof(arg) == "string") { + // It's an URL. + let uri = Services.io.newURI(arg, null, null); + principal = secMan.createCodebasePrincipal(uri, {}); + } else if (arg.manifestURL) { + // It's a thing representing an app. + let appsSvc = Cc["@mozilla.org/AppsService;1"] + .getService(Ci.nsIAppsService) + let app = appsSvc.getAppByManifestURL(arg.manifestURL); + if (!app) { + throw "No app for this manifest!"; + } + + principal = app.principal; + } else if (arg.nodePrincipal) { + // It's a document. + // In some tests the arg is a wrapped DOM element, so we unwrap it first. + principal = unwrapIfWrapped(arg).nodePrincipal; + } else { + let uri = Services.io.newURI(arg.url, null, null); + let attrs = arg.originAttributes || {}; + principal = secMan.createCodebasePrincipal(uri, attrs); + } + + return principal; + }, + + addPermission: function(type, allow, arg, expireType, expireTime) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return; // nothing to do + } + + let permission; + if (typeof allow !== 'boolean') { + permission = allow; + } else { + permission = allow ? Ci.nsIPermissionManager.ALLOW_ACTION + : Ci.nsIPermissionManager.DENY_ACTION; + } + + var msg = { + 'op': 'add', + 'type': type, + 'permission': permission, + 'principal': principal, + 'expireType': (typeof expireType === "number") ? expireType : 0, + 'expireTime': (typeof expireTime === "number") ? expireTime : 0 + }; + + this._sendSyncMessage('SPPermissionManager', msg); + }, + + removePermission: function(type, arg) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return; // nothing to do + } + + var msg = { + 'op': 'remove', + 'type': type, + 'principal': principal + }; + + this._sendSyncMessage('SPPermissionManager', msg); + }, + + hasPermission: function (type, arg) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return true; // system principals have all permissions + } + + var msg = { + 'op': 'has', + 'type': type, + 'principal': principal + }; + + return this._sendSyncMessage('SPPermissionManager', msg)[0]; + }, + + testPermission: function (type, value, arg) { + let principal = this._getPrincipalFromArg(arg); + if (principal.isSystemPrincipal) { + return true; // system principals have all permissions + } + + var msg = { + 'op': 'test', + 'type': type, + 'value': value, + 'principal': principal + }; + return this._sendSyncMessage('SPPermissionManager', msg)[0]; + }, + + isContentWindowPrivate: function(win) { + return PrivateBrowsingUtils.isContentWindowPrivate(win); + }, + + notifyObserversInParentProcess: function(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 + }; + this._sendSyncMessage('SPObserverService', msg); + }, + + removeAllServiceWorkerData: function() { + this.notifyObserversInParentProcess(null, "browser:purge-session-history", ""); + }, + + removeServiceWorkerDataForExampleDomain: function() { + this.notifyObserversInParentProcess(null, "browser:purge-domain-data", "example.com"); + }, + + cleanUpSTSData: function(origin, flags) { + return this._sendSyncMessage('SPCleanUpSTSData', {origin: origin, flags: flags || 0}); + }, + + _nextExtensionID: 0, + _extensionListeners: null, + + loadExtension: function(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++; + + let resolveStartup, resolveUnload, rejectStartup; + let startupPromise = new Promise((resolve, reject) => { + resolveStartup = resolve; + rejectStartup = reject; + }); + let unloadPromise = new Promise(resolve => { resolveUnload = resolve; }); + + startupPromise.catch(() => { + this._extensionListeners.delete(listener); + }); + + handler = Cu.waiveXrays(handler); + ext = Cu.waiveXrays(ext); + + let sp = this; + let state = "uninitialized"; + let extension = { + get state() { return state; }, + + startup() { + state = "pending"; + sp._sendAsyncMessage("SPStartupExtension", {id}); + return startupPromise; + }, + + unload() { + state = "unloading"; + sp._sendAsyncMessage("SPUnloadExtension", {id}); + return unloadPromise; + }, + + sendMessage(...args) { + sp._sendAsyncMessage("SPExtensionMessage", {id, args}); + }, + }; + + this._sendAsyncMessage("SPLoadExtension", {ext, id}); + + let listener = (msg) => { + if (msg.data.id == id) { + if (msg.data.type == "extensionStarted") { + state = "running"; + resolveStartup(); + } else if (msg.data.type == "extensionSetId") { + extension.id = msg.data.args[0]; + } else if (msg.data.type == "extensionFailed") { + state = "failed"; + rejectStartup("startup failed"); + } else if (msg.data.type == "extensionUnloaded") { + this._extensionListeners.delete(listener); + state = "unloaded"; + resolveUnload(); + } else if (msg.data.type in handler) { + handler[msg.data.type](...msg.data.args); + } else { + dump(`Unexpected: ${msg.data.type}\n`); + } + } + }; + + this._extensionListeners.add(listener); + return extension; + }, + + invalidateExtensionStorageCache: function() { + this.notifyObserversInParentProcess(null, "extension-invalidate-storage-cache", ""); + }, + + allowMedia: function(window, enable) { + this._getDocShell(window).allowMedia = enable; + }, + + createChromeCache: function(name, url) { + let principal = this._getPrincipalFromArg(url); + return wrapIfUnwrapped(new content.window.CacheStorage(name, principal)); + }, + + loadChannelAndReturnStatus: function(url, loadUsingSystemPrincipal) { + const BinaryInputStream = + Components.Constructor("@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream"); + + return new Promise(function(resolve) { + let listener = { + httpStatus : 0, + + onStartRequest: function(request, context) { + request.QueryInterface(Ci.nsIHttpChannel); + this.httpStatus = request.responseStatus; + }, + + onDataAvailable: function(request, context, stream, offset, count) { + new BinaryInputStream(stream).readByteArray(count); + }, + + onStopRequest: function(request, context, 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.asyncOpen2(listener); + }); + }, + + _pu: null, + + 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: function(src, flags) { + return pu.sanitize(src, flags); + }, + convertToPlainText: function(src, flags, wrapCol) { + return pu.convertToPlainText(src, flags, wrapCol); + }, + parseFragment: function(fragment, flags, isXML, baseURL, element) { + let baseURI = baseURL ? NetUtil.newURI(baseURL) : null; + return pu.parseFragment(unwrapIfWrapped(fragment), + flags, isXML, baseURI, + unwrapIfWrapped(element)); + }, + }; + return this._pu; + }, + + createDOMWalker: function(node, showAnonymousContent) { + node = unwrapIfWrapped(node); + let walker = Cc["@mozilla.org/inspector/deep-tree-walker;1"]. + createInstance(Ci.inIDeepTreeWalker); + walker.showAnonymousContent = showAnonymousContent; + walker.init(node.ownerDocument, Ci.nsIDOMNodeFilter.SHOW_ALL); + walker.currentNode = node; + return { + get firstChild() { + return wrapIfUnwrapped(walker.firstChild()); + }, + get lastChild() { + return wrapIfUnwrapped(walker.lastChild()); + }, + }; + }, + + observeMutationEvents: function(mo, node, nativeAnonymousChildList, subtree) { + unwrapIfWrapped(mo).observe(unwrapIfWrapped(node), + {nativeAnonymousChildList, subtree}); + }, + + doCommand(window, cmd) { + return this._getDocShell(window).doCommand(cmd); + }, + + setCommandNode(window, node) { + return this._getDocShell(window).contentViewer + .QueryInterface(Ci.nsIContentViewerEdit) + .setCommandNode(node); + }, +}; + +this.SpecialPowersAPI = SpecialPowersAPI; +this.bindDOMWindowUtils = bindDOMWindowUtils; +this.getRawComponents = getRawComponents; |