From 43a97878ce14b72f0981164f87f2e35e14151312 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:22:09 +0200 Subject: Adding upstream version 110.0.1. Signed-off-by: Daniel Baumann --- .../specialpowers/content/MockFilePicker.sys.mjs | 315 +++++++++++++++++++++ 1 file changed, 315 insertions(+) create mode 100644 testing/specialpowers/content/MockFilePicker.sys.mjs (limited to 'testing/specialpowers/content/MockFilePicker.sys.mjs') diff --git a/testing/specialpowers/content/MockFilePicker.sys.mjs b/testing/specialpowers/content/MockFilePicker.sys.mjs new file mode 100644 index 0000000000..6c6754e851 --- /dev/null +++ b/testing/specialpowers/content/MockFilePicker.sys.mjs @@ -0,0 +1,315 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +const lazy = {}; + +ChromeUtils.defineESModuleGetters(lazy, { + FileUtils: "resource://gre/modules/FileUtils.sys.mjs", + WrapPrivileged: "resource://specialpowers/WrapPrivileged.sys.mjs", +}); + +const Cm = Components.manager; + +const CONTRACT_ID = "@mozilla.org/filepicker;1"; + +if (import.meta.url.includes("specialpowers")) { + Cu.crashIfNotInAutomation(); +} + +var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar); +var oldClassID; +var newClassID = Services.uuid.generateUUID(); +var newFactory = function(window) { + return { + createInstance(aIID) { + return new MockFilePickerInstance(window).QueryInterface(aIID); + }, + QueryInterface: ChromeUtils.generateQI(["nsIFactory"]), + }; +}; + +export var MockFilePicker = { + returnOK: Ci.nsIFilePicker.returnOK, + returnCancel: Ci.nsIFilePicker.returnCancel, + returnReplace: Ci.nsIFilePicker.returnReplace, + + filterAll: Ci.nsIFilePicker.filterAll, + filterHTML: Ci.nsIFilePicker.filterHTML, + filterText: Ci.nsIFilePicker.filterText, + filterImages: Ci.nsIFilePicker.filterImages, + filterXML: Ci.nsIFilePicker.filterXML, + filterXUL: Ci.nsIFilePicker.filterXUL, + filterApps: Ci.nsIFilePicker.filterApps, + filterAllowURLs: Ci.nsIFilePicker.filterAllowURLs, + filterAudio: Ci.nsIFilePicker.filterAudio, + filterVideo: Ci.nsIFilePicker.filterVideo, + + window: null, + pendingPromises: [], + + init(window) { + this.window = window; + + this.reset(); + this.factory = newFactory(window); + if (!registrar.isCIDRegistered(newClassID)) { + oldClassID = registrar.contractIDToCID(CONTRACT_ID); + registrar.registerFactory(newClassID, "", CONTRACT_ID, this.factory); + } + }, + + reset() { + this.appendFilterCallback = null; + this.appendFiltersCallback = null; + this.displayDirectory = null; + this.displaySpecialDirectory = ""; + this.filterIndex = 0; + this.mode = null; + this.returnData = []; + this.returnValue = null; + this.showCallback = null; + this.afterOpenCallback = null; + this.shown = false; + this.showing = false; + }, + + cleanup() { + var previousFactory = this.factory; + this.reset(); + this.factory = null; + if (oldClassID) { + registrar.unregisterFactory(newClassID, previousFactory); + registrar.registerFactory(oldClassID, "", CONTRACT_ID, null); + } + }, + + internalFileData(obj) { + return { + nsIFile: "nsIFile" in obj ? obj.nsIFile : null, + domFile: "domFile" in obj ? obj.domFile : null, + domDirectory: "domDirectory" in obj ? obj.domDirectory : null, + }; + }, + + useAnyFile() { + var file = lazy.FileUtils.getDir("TmpD", [], false); + file.append("testfile"); + file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, 0o644); + let promise = this.window.File.createFromNsIFile(file) + .then( + domFile => domFile, + () => null + ) + // domFile can be null. + .then(domFile => { + this.returnData = [this.internalFileData({ nsIFile: file, domFile })]; + }) + .then(() => file); + + this.pendingPromises = [promise]; + + // We return a promise in order to support some existing mochitests. + return promise; + }, + + useBlobFile() { + var blob = new this.window.Blob([]); + var file = new this.window.File([blob], "helloworld.txt", { + type: "plain/text", + }); + this.returnData = [this.internalFileData({ domFile: file })]; + this.pendingPromises = []; + }, + + useDirectory(aPath) { + var directory = new this.window.Directory(aPath); + this.returnData = [this.internalFileData({ domDirectory: directory })]; + this.pendingPromises = []; + }, + + setFiles(files) { + this.returnData = []; + this.pendingPromises = []; + + for (let file of files) { + if (this.window.File.isInstance(file)) { + this.returnData.push(this.internalFileData({ domFile: file })); + } else { + let promise = this.window.File.createFromNsIFile(file, { + existenceCheck: false, + }); + + promise.then(domFile => { + this.returnData.push( + this.internalFileData({ nsIFile: file, domFile }) + ); + }); + this.pendingPromises.push(promise); + } + } + }, + + getNsIFile() { + if (this.returnData.length >= 1) { + return this.returnData[0].nsIFile; + } + return null; + }, +}; + +function MockFilePickerInstance(window) { + this.window = window; + this.showCallback = null; + this.showCallbackWrapped = null; +} +MockFilePickerInstance.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIFilePicker"]), + init(aParent, aTitle, aMode) { + this.mode = aMode; + this.filterIndex = MockFilePicker.filterIndex; + this.parent = aParent; + }, + appendFilter(aTitle, aFilter) { + if (typeof MockFilePicker.appendFilterCallback == "function") { + MockFilePicker.appendFilterCallback(this, aTitle, aFilter); + } + }, + appendFilters(aFilterMask) { + if (typeof MockFilePicker.appendFiltersCallback == "function") { + MockFilePicker.appendFiltersCallback(this, aFilterMask); + } + }, + defaultString: "", + defaultExtension: "", + parent: null, + filterIndex: 0, + displayDirectory: null, + displaySpecialDirectory: "", + get file() { + if (MockFilePicker.returnData.length >= 1) { + return MockFilePicker.returnData[0].nsIFile; + } + + return null; + }, + + // We don't support directories here. + get domFileOrDirectory() { + if (MockFilePicker.returnData.length < 1) { + return null; + } + + if (MockFilePicker.returnData[0].domFile) { + return MockFilePicker.returnData[0].domFile; + } + + if (MockFilePicker.returnData[0].domDirectory) { + return MockFilePicker.returnData[0].domDirectory; + } + + return null; + }, + get fileURL() { + if ( + MockFilePicker.returnData.length >= 1 && + MockFilePicker.returnData[0].nsIFile + ) { + return Services.io.newFileURI(MockFilePicker.returnData[0].nsIFile); + } + + return null; + }, + *getFiles(asDOM) { + for (let d of MockFilePicker.returnData) { + if (asDOM) { + yield d.domFile || d.domDirectory; + } else if (d.nsIFile) { + yield d.nsIFile; + } else { + throw Components.Exception("", Cr.NS_ERROR_FAILURE); + } + } + }, + get files() { + return this.getFiles(false); + }, + get domFileOrDirectoryEnumerator() { + return this.getFiles(true); + }, + open(aFilePickerShownCallback) { + MockFilePicker.showing = true; + Services.tm.dispatchToMainThread(() => { + // Maybe all the pending promises are already resolved, but we want to be sure. + Promise.all(MockFilePicker.pendingPromises) + .then( + () => { + return Ci.nsIFilePicker.returnOK; + }, + () => { + return Ci.nsIFilePicker.returnCancel; + } + ) + .then(result => { + // Nothing else has to be done. + MockFilePicker.pendingPromises = []; + + if (result == Ci.nsIFilePicker.returnCancel) { + return result; + } + + MockFilePicker.displayDirectory = this.displayDirectory; + MockFilePicker.displaySpecialDirectory = this.displaySpecialDirectory; + MockFilePicker.shown = true; + if (typeof MockFilePicker.showCallback == "function") { + if (MockFilePicker.showCallback != this.showCallback) { + this.showCallback = MockFilePicker.showCallback; + if (Cu.isXrayWrapper(this.window)) { + this.showCallbackWrapped = lazy.WrapPrivileged.wrapCallback( + MockFilePicker.showCallback, + this.window + ); + } else { + this.showCallbackWrapped = this.showCallback; + } + } + try { + var returnValue = this.showCallbackWrapped(this); + if (typeof returnValue != "undefined") { + return returnValue; + } + } catch (ex) { + return Ci.nsIFilePicker.returnCancel; + } + } + + return MockFilePicker.returnValue; + }) + .then(result => { + // Some additional result file can be set by the callback. Let's + // resolve the pending promises again. + return Promise.all(MockFilePicker.pendingPromises).then( + () => { + return result; + }, + () => { + return Ci.nsIFilePicker.returnCancel; + } + ); + }) + .then(result => { + MockFilePicker.pendingPromises = []; + + if (aFilePickerShownCallback) { + aFilePickerShownCallback.done(result); + } + + if (typeof MockFilePicker.afterOpenCallback == "function") { + Services.tm.dispatchToMainThread(() => { + MockFilePicker.afterOpenCallback(this); + }); + } + }); + }); + }, +}; -- cgit v1.2.3