From 0ebf5bdf043a27fd3dfb7f92e0cb63d88954c44d Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 03:47:29 +0200 Subject: Adding upstream version 115.8.0esr. Signed-off-by: Daniel Baumann --- .../handling/ContentDispatchChooser.sys.mjs | 450 +++++++++++++++++++++ toolkit/mozapps/handling/components.conf | 14 + toolkit/mozapps/handling/content/appChooser.js | 369 +++++++++++++++++ toolkit/mozapps/handling/content/appChooser.xhtml | 66 +++ toolkit/mozapps/handling/content/handler.css | 59 +++ .../mozapps/handling/content/permissionDialog.js | 210 ++++++++++ .../handling/content/permissionDialog.xhtml | 52 +++ toolkit/mozapps/handling/jar.mn | 11 + toolkit/mozapps/handling/moz.build | 18 + 9 files changed, 1249 insertions(+) create mode 100644 toolkit/mozapps/handling/ContentDispatchChooser.sys.mjs create mode 100644 toolkit/mozapps/handling/components.conf create mode 100644 toolkit/mozapps/handling/content/appChooser.js create mode 100644 toolkit/mozapps/handling/content/appChooser.xhtml create mode 100644 toolkit/mozapps/handling/content/handler.css create mode 100644 toolkit/mozapps/handling/content/permissionDialog.js create mode 100644 toolkit/mozapps/handling/content/permissionDialog.xhtml create mode 100644 toolkit/mozapps/handling/jar.mn create mode 100644 toolkit/mozapps/handling/moz.build (limited to 'toolkit/mozapps/handling') diff --git a/toolkit/mozapps/handling/ContentDispatchChooser.sys.mjs b/toolkit/mozapps/handling/ContentDispatchChooser.sys.mjs new file mode 100644 index 0000000000..cf9a2444a3 --- /dev/null +++ b/toolkit/mozapps/handling/ContentDispatchChooser.sys.mjs @@ -0,0 +1,450 @@ +/* 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/. */ + +// Constants + +import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs"; + +import { E10SUtils } from "resource://gre/modules/E10SUtils.sys.mjs"; + +const DIALOG_URL_APP_CHOOSER = + "chrome://mozapps/content/handling/appChooser.xhtml"; +const DIALOG_URL_PERMISSION = + "chrome://mozapps/content/handling/permissionDialog.xhtml"; + +const gPrefs = {}; +XPCOMUtils.defineLazyPreferenceGetter( + gPrefs, + "promptForExternal", + "network.protocol-handler.prompt-from-external", + true +); + +const PROTOCOL_HANDLER_OPEN_PERM_KEY = "open-protocol-handler"; +const PERMISSION_KEY_DELIMITER = "^"; + +export class nsContentDispatchChooser { + /** + * Prompt the user to open an external application. + * If the triggering principal doesn't have permission to open apps for the + * protocol of aURI, we show a permission prompt first. + * If the caller has permission and a preferred handler is set, we skip the + * dialogs and directly open the handler. + * @param {nsIHandlerInfo} aHandler - Info about protocol and handlers. + * @param {nsIURI} aURI - URI to be handled. + * @param {nsIPrincipal} [aPrincipal] - Principal which triggered the load. + * @param {BrowsingContext} [aBrowsingContext] - Context of the load. + * @param {bool} [aTriggeredExternally] - Whether the load came from outside + * this application. + */ + async handleURI( + aHandler, + aURI, + aPrincipal, + aBrowsingContext, + aTriggeredExternally = false + ) { + let callerHasPermission = this._hasProtocolHandlerPermission( + aHandler.type, + aPrincipal + ); + + // Force showing the dialog for links passed from outside the application. + // This avoids infinite loops, see bug 1678255, bug 1667468, etc. + if ( + aTriggeredExternally && + gPrefs.promptForExternal && + // ... unless we intend to open the link with a website or extension: + !( + aHandler.preferredAction == Ci.nsIHandlerInfo.useHelperApp && + aHandler.preferredApplicationHandler instanceof Ci.nsIWebHandlerApp + ) + ) { + aHandler.alwaysAskBeforeHandling = true; + } + + // Skip the dialog if a preferred application is set and the caller has + // permission. + if ( + callerHasPermission && + !aHandler.alwaysAskBeforeHandling && + (aHandler.preferredAction == Ci.nsIHandlerInfo.useHelperApp || + aHandler.preferredAction == Ci.nsIHandlerInfo.useSystemDefault) + ) { + try { + aHandler.launchWithURI(aURI, aBrowsingContext); + return; + } catch (error) { + // We are not supposed to ask, but when file not found the user most likely + // uninstalled the application which handles the uri so we will continue + // by application chooser dialog. + if (error.result == Cr.NS_ERROR_FILE_NOT_FOUND) { + aHandler.alwaysAskBeforeHandling = true; + } else { + throw error; + } + } + } + + let shouldOpenHandler = false; + + try { + shouldOpenHandler = await this._prompt( + aHandler, + aPrincipal, + callerHasPermission, + aBrowsingContext, + aURI + ); + } catch (error) { + console.error(error.message); + } + + if (!shouldOpenHandler) { + return; + } + + // Site was granted permission and user chose to open application. + // Launch the external handler. + aHandler.launchWithURI(aURI, aBrowsingContext); + } + + /** + * Get the name of the application set to handle the the protocol. + * @param {nsIHandlerInfo} aHandler - Info about protocol and handlers. + * @returns {string|null} - Human readable handler name or null if the user + * is expected to set a handler. + */ + _getHandlerName(aHandler) { + if (aHandler.alwaysAskBeforeHandling) { + return null; + } + if ( + aHandler.preferredAction == Ci.nsIHandlerInfo.useSystemDefault && + aHandler.hasDefaultHandler + ) { + return aHandler.defaultDescription; + } + return aHandler.preferredApplicationHandler?.name; + } + + /** + * Show permission or/and app chooser prompt. + * @param {nsIHandlerInfo} aHandler - Info about protocol and handlers. + * @param {nsIPrincipal} aPrincipal - Principal which triggered the load. + * @param {boolean} aHasPermission - Whether the caller has permission to + * open the protocol. + * @param {BrowsingContext} [aBrowsingContext] - Context associated with the + * protocol navigation. + */ + async _prompt(aHandler, aPrincipal, aHasPermission, aBrowsingContext, aURI) { + let shouldOpenHandler = false; + let resetHandlerChoice = false; + let updateHandlerData = false; + + const isStandardProtocol = E10SUtils.STANDARD_SAFE_PROTOCOLS.includes( + aURI.scheme + ); + const { + hasDefaultHandler, + preferredApplicationHandler, + alwaysAskBeforeHandling, + } = aHandler; + + // This will skip the app chooser dialog flow unless the user explicitly opts to choose + // another app in the permission dialog. + if ( + !isStandardProtocol && + hasDefaultHandler && + preferredApplicationHandler == null && + alwaysAskBeforeHandling + ) { + aHandler.alwaysAskBeforeHandling = false; + updateHandlerData = true; + } + + // If caller does not have permission, prompt the user. + if (!aHasPermission) { + let canPersistPermission = this._isSupportedPrincipal(aPrincipal); + + let outArgs = Cc["@mozilla.org/hash-property-bag;1"].createInstance( + Ci.nsIWritablePropertyBag + ); + // Whether the permission request was granted + outArgs.setProperty("granted", false); + // If the user wants to select a new application for the protocol. + // This will cause us to show the chooser dialog, even if an app is set. + outArgs.setProperty("resetHandlerChoice", null); + // If the we should store the permission and not prompt again for it. + outArgs.setProperty("remember", null); + + await this._openDialog( + DIALOG_URL_PERMISSION, + { + handler: aHandler, + principal: aPrincipal, + browsingContext: aBrowsingContext, + outArgs, + canPersistPermission, + preferredHandlerName: this._getHandlerName(aHandler), + }, + aBrowsingContext + ); + if (!outArgs.getProperty("granted")) { + // User denied request + return false; + } + + // Check if user wants to set a new application to handle the protocol. + resetHandlerChoice = outArgs.getProperty("resetHandlerChoice"); + + // If the user wants to select a new app we don't persist the permission. + if (!resetHandlerChoice && aPrincipal) { + let remember = outArgs.getProperty("remember"); + this._updatePermission(aPrincipal, aHandler.type, remember); + } + + shouldOpenHandler = true; + } + + // Prompt if the user needs to make a handler choice for the protocol. + if (aHandler.alwaysAskBeforeHandling || resetHandlerChoice) { + // User has not set a preferred application to handle this protocol scheme. + // Open the application chooser dialog + let outArgs = Cc["@mozilla.org/hash-property-bag;1"].createInstance( + Ci.nsIWritablePropertyBag + ); + outArgs.setProperty("openHandler", false); + outArgs.setProperty("preferredAction", aHandler.preferredAction); + outArgs.setProperty( + "preferredApplicationHandler", + aHandler.preferredApplicationHandler + ); + outArgs.setProperty( + "alwaysAskBeforeHandling", + aHandler.alwaysAskBeforeHandling + ); + let usePrivateBrowsing = aBrowsingContext?.usePrivateBrowsing; + await this._openDialog( + DIALOG_URL_APP_CHOOSER, + { + handler: aHandler, + outArgs, + usePrivateBrowsing, + enableButtonDelay: aHasPermission, + }, + aBrowsingContext + ); + + shouldOpenHandler = outArgs.getProperty("openHandler"); + + // If the user accepted the dialog, apply their selection. + if (shouldOpenHandler) { + for (let prop of [ + "preferredAction", + "preferredApplicationHandler", + "alwaysAskBeforeHandling", + ]) { + aHandler[prop] = outArgs.getProperty(prop); + } + updateHandlerData = true; + } + } + + if (updateHandlerData) { + // Store handler data + Cc["@mozilla.org/uriloader/handler-service;1"] + .getService(Ci.nsIHandlerService) + .store(aHandler); + } + + return shouldOpenHandler; + } + + /** + * Test if a given principal has the open-protocol-handler permission for a + * specific protocol. + * @param {string} scheme - Scheme of the protocol. + * @param {nsIPrincipal} aPrincipal - Principal to test for permission. + * @returns {boolean} - true if permission is set, false otherwise. + */ + _hasProtocolHandlerPermission(scheme, aPrincipal) { + // Permission disabled by pref + if (!nsContentDispatchChooser.isPermissionEnabled) { + return true; + } + + // If a handler is set to open externally by default we skip the dialog. + if ( + Services.prefs.getBoolPref( + "network.protocol-handler.external." + scheme, + false + ) + ) { + return true; + } + + if (!aPrincipal) { + return false; + } + + let key = this._getSkipProtoDialogPermissionKey(scheme); + return ( + Services.perms.testPermissionFromPrincipal(aPrincipal, key) === + Services.perms.ALLOW_ACTION + ); + } + + /** + * Get open-protocol-handler permission key for a protocol. + * @param {string} aProtocolScheme - Scheme of the protocol. + * @returns {string} - Permission key. + */ + _getSkipProtoDialogPermissionKey(aProtocolScheme) { + return ( + PROTOCOL_HANDLER_OPEN_PERM_KEY + + PERMISSION_KEY_DELIMITER + + aProtocolScheme + ); + } + + /** + * Opens a dialog as a SubDialog on tab level. + * If we don't have a BrowsingContext we will fallback to a standalone window. + * @param {string} aDialogURL - URL of the dialog to open. + * @param {Object} aDialogArgs - Arguments passed to the dialog. + * @param {BrowsingContext} [aBrowsingContext] - BrowsingContext associated + * with the tab the dialog is associated with. + */ + async _openDialog(aDialogURL, aDialogArgs, aBrowsingContext) { + // Make the app chooser dialog resizable + let resizable = `resizable=${ + aDialogURL == DIALOG_URL_APP_CHOOSER ? "yes" : "no" + }`; + + if (aBrowsingContext) { + let window = aBrowsingContext.topChromeWindow; + if (!window) { + throw new Error( + "Can't show external protocol dialog. BrowsingContext has no chrome window associated." + ); + } + + let { topFrameElement } = aBrowsingContext; + if (topFrameElement?.tagName != "browser") { + throw new Error( + "Can't show external protocol dialog. BrowsingContext has no browser associated." + ); + } + + let tabDialogBox = window.gBrowser.getTabDialogBox(topFrameElement); + return tabDialogBox.open( + aDialogURL, + { + features: resizable, + allowDuplicateDialogs: false, + keepOpenSameOriginNav: true, + }, + aDialogArgs + ).closedPromise; + } + + // If we don't have a BrowsingContext, we need to show a standalone window. + let win = Services.ww.openWindow( + null, + aDialogURL, + null, + `chrome,dialog=yes,centerscreen,${resizable}`, + aDialogArgs + ); + + // Wait until window is closed. + return new Promise(resolve => { + win.addEventListener("unload", function onUnload(event) { + if (event.target.location != aDialogURL) { + return; + } + win.removeEventListener("unload", onUnload); + resolve(); + }); + }); + } + + /** + * Update the open-protocol-handler permission for the site which triggered + * the dialog. Sites with this permission may skip this dialog. + * @param {nsIPrincipal} aPrincipal - subject to update the permission for. + * @param {string} aScheme - Scheme of protocol to allow. + * @param {boolean} aAllow - Whether to set / unset the permission. + */ + _updatePermission(aPrincipal, aScheme, aAllow) { + // If enabled, store open-protocol-handler permission for content principals. + if ( + !nsContentDispatchChooser.isPermissionEnabled || + aPrincipal.isSystemPrincipal || + !this._isSupportedPrincipal(aPrincipal) + ) { + return; + } + + let principal = aPrincipal; + + // If this action was triggered by an extension content script then set the + // permission on the extension's principal. + let addonPolicy = aPrincipal.contentScriptAddonPolicy; + if (addonPolicy) { + principal = Services.scriptSecurityManager.principalWithOA( + addonPolicy.extension.principal, + principal.originAttributes + ); + } + + let permKey = this._getSkipProtoDialogPermissionKey(aScheme); + if (aAllow) { + Services.perms.addFromPrincipal( + principal, + permKey, + Services.perms.ALLOW_ACTION, + Services.perms.EXPIRE_NEVER + ); + } else { + Services.perms.removeFromPrincipal(principal, permKey); + } + } + + /** + * Determine if we can use a principal to store permissions. + * @param {nsIPrincipal} aPrincipal - Principal to test. + * @returns {boolean} - true if we can store permissions, false otherwise. + */ + _isSupportedPrincipal(aPrincipal) { + if (!aPrincipal) { + return false; + } + + // If this is an add-on content script then we will be able to store + // permissions against the add-on's principal. + if (aPrincipal.contentScriptAddonPolicy) { + return true; + } + + return ["http", "https", "moz-extension", "file"].some(scheme => + aPrincipal.schemeIs(scheme) + ); + } +} + +nsContentDispatchChooser.prototype.classID = Components.ID( + "e35d5067-95bc-4029-8432-e8f1e431148d" +); +nsContentDispatchChooser.prototype.QueryInterface = ChromeUtils.generateQI([ + "nsIContentDispatchChooser", +]); + +XPCOMUtils.defineLazyPreferenceGetter( + nsContentDispatchChooser, + "isPermissionEnabled", + "security.external_protocol_requires_permission", + true +); diff --git a/toolkit/mozapps/handling/components.conf b/toolkit/mozapps/handling/components.conf new file mode 100644 index 0000000000..95afe50a87 --- /dev/null +++ b/toolkit/mozapps/handling/components.conf @@ -0,0 +1,14 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +Classes = [ + { + 'cid': '{e35d5067-95bc-4029-8432-e8f1e431148d}', + 'contract_ids': ['@mozilla.org/content-dispatch-chooser;1'], + 'esModule': 'resource://gre/modules/ContentDispatchChooser.sys.mjs', + 'constructor': 'nsContentDispatchChooser', + }, +] diff --git a/toolkit/mozapps/handling/content/appChooser.js b/toolkit/mozapps/handling/content/appChooser.js new file mode 100644 index 0000000000..2958ad68b4 --- /dev/null +++ b/toolkit/mozapps/handling/content/appChooser.js @@ -0,0 +1,369 @@ +/* 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 { PrivateBrowsingUtils } = ChromeUtils.importESModule( + "resource://gre/modules/PrivateBrowsingUtils.sys.mjs" +); +const { EnableDelayHelper } = ChromeUtils.importESModule( + "resource://gre/modules/PromptUtils.sys.mjs" +); + +class MozHandler extends window.MozElements.MozRichlistitem { + static get markup() { + return ` + + + + + + `; + } + + connectedCallback() { + this.textContent = ""; + this.appendChild(this.constructor.fragment); + this.initializeAttributeInheritance(); + } + + static get inheritedAttributes() { + return { + img: "src=image,disabled", + ".name": "value=name,disabled", + ".description": "value=description,disabled", + }; + } + + get label() { + return `${this.getAttribute("name")} ${this.getAttribute("description")}`; + } +} + +customElements.define("mozapps-handler", MozHandler, { + extends: "richlistitem", +}); + +window.addEventListener("DOMContentLoaded", () => dialog.initialize(), { + once: true, +}); + +let dialog = { + /** + * This function initializes the content of the dialog. + */ + initialize() { + let args = window.arguments[0].wrappedJSObject || window.arguments[0]; + let { handler, outArgs, usePrivateBrowsing, enableButtonDelay } = args; + + this._handlerInfo = handler.QueryInterface(Ci.nsIHandlerInfo); + this._outArgs = outArgs; + + this.isPrivate = + usePrivateBrowsing || + (window.opener && PrivateBrowsingUtils.isWindowPrivate(window.opener)); + + this._dialog = document.querySelector("dialog"); + this._itemChoose = document.getElementById("item-choose"); + this._rememberCheck = document.getElementById("remember"); + + // Register event listener for the checkbox hint. + this._rememberCheck.addEventListener("change", () => this.onCheck()); + + document.addEventListener("dialogaccept", () => { + this.onAccept(); + }); + + // UI is ready, lets populate our list + this.populateList(); + + this.initL10n(); + + if (enableButtonDelay) { + this._delayHelper = new EnableDelayHelper({ + disableDialog: () => { + this._acceptBtnDisabled = true; + this.updateAcceptButton(); + }, + enableDialog: () => { + this._acceptBtnDisabled = false; + this.updateAcceptButton(); + }, + focusTarget: window, + }); + } + }, + + initL10n() { + let rememberLabel = document.getElementById("remember-label"); + document.l10n.setAttributes(rememberLabel, "chooser-dialog-remember", { + scheme: this._handlerInfo.type, + }); + + let description = document.getElementById("description"); + document.l10n.setAttributes(description, "chooser-dialog-description", { + scheme: this._handlerInfo.type, + }); + }, + + /** + * Populates the list that a user can choose from. + */ + populateList: function populateList() { + var items = document.getElementById("items"); + var possibleHandlers = this._handlerInfo.possibleApplicationHandlers; + var preferredHandler = this._handlerInfo.preferredApplicationHandler; + for (let i = possibleHandlers.length - 1; i >= 0; --i) { + let app = possibleHandlers.queryElementAt(i, Ci.nsIHandlerApp); + let elm = document.createXULElement("richlistitem", { + is: "mozapps-handler", + }); + elm.setAttribute("name", app.name); + elm.obj = app; + + // We defer loading the favicon so it doesn't delay load. The dialog is + // opened in a SubDialog which will only show on window load. + if (app instanceof Ci.nsILocalHandlerApp) { + // See if we have an nsILocalHandlerApp and set the icon + let uri = Services.io.newFileURI(app.executable); + elm.setAttribute("image", "moz-icon://" + uri.spec + "?size=32"); + } else if (app instanceof Ci.nsIWebHandlerApp) { + let uri = Services.io.newURI(app.uriTemplate); + if (/^https?$/.test(uri.scheme)) { + // Unfortunately we can't use the favicon service to get the favicon, + // because the service looks for a record with the exact URL we give + // it, and users won't have such records for URLs they don't visit, + // and users won't visit the handler's URL template, they'll only + // visit URLs derived from that template (i.e. with %s in the template + // replaced by the URL of the content being handled). + elm.setAttribute("image", uri.prePath + "/favicon.ico"); + } + elm.setAttribute("description", uri.prePath); + + // Check for extensions needing private browsing access before + // creating UI elements. + if (this.isPrivate) { + let policy = WebExtensionPolicy.getByURI(uri); + if (policy && !policy.privateBrowsingAllowed) { + elm.setAttribute("disabled", true); + this.getPrivateBrowsingDisabledLabel().then(label => { + elm.setAttribute("description", label); + }); + if (app == preferredHandler) { + preferredHandler = null; + } + } + } + } else if (app instanceof Ci.nsIDBusHandlerApp) { + elm.setAttribute("description", app.method); + } else if (!(app instanceof Ci.nsIGIOMimeApp)) { + // We support GIO application handler, but no action required there + throw new Error("unknown handler type"); + } + + items.insertBefore(elm, this._itemChoose); + if (preferredHandler && app == preferredHandler) { + this.selectedItem = elm; + } + } + + if (this._handlerInfo.hasDefaultHandler) { + let elm = document.createXULElement("richlistitem", { + is: "mozapps-handler", + }); + elm.id = "os-default-handler"; + elm.setAttribute("name", this._handlerInfo.defaultDescription); + + items.insertBefore(elm, items.firstChild); + if ( + this._handlerInfo.preferredAction == Ci.nsIHandlerInfo.useSystemDefault + ) { + this.selectedItem = elm; + } + } + + // Add gio handlers + if (Cc["@mozilla.org/gio-service;1"]) { + let gIOSvc = Cc["@mozilla.org/gio-service;1"].getService( + Ci.nsIGIOService + ); + var gioApps = gIOSvc.getAppsForURIScheme(this._handlerInfo.type); + for (let handler of gioApps.enumerate(Ci.nsIHandlerApp)) { + // OS handler share the same name, it's most likely the same app, skipping... + if (handler.name == this._handlerInfo.defaultDescription) { + continue; + } + // Check if the handler is already in possibleHandlers + let appAlreadyInHandlers = false; + for (let i = possibleHandlers.length - 1; i >= 0; --i) { + let app = possibleHandlers.queryElementAt(i, Ci.nsIHandlerApp); + // nsGIOMimeApp::Equals is able to compare with nsILocalHandlerApp + if (handler.equals(app)) { + appAlreadyInHandlers = true; + break; + } + } + if (!appAlreadyInHandlers) { + let elm = document.createXULElement("richlistitem", { + is: "mozapps-handler", + }); + elm.setAttribute("name", handler.name); + elm.obj = handler; + items.insertBefore(elm, this._itemChoose); + } + } + } + + items.ensureSelectedElementIsVisible(); + }, + + /** + * Brings up a filepicker and allows a user to choose an application. + */ + async chooseApplication() { + let title = await this.getChooseAppWindowTitle(); + + var fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker); + fp.init(window, title, Ci.nsIFilePicker.modeOpen); + fp.appendFilters(Ci.nsIFilePicker.filterApps); + + fp.open(rv => { + if (rv == Ci.nsIFilePicker.returnOK && fp.file) { + let uri = Services.io.newFileURI(fp.file); + + let handlerApp = Cc[ + "@mozilla.org/uriloader/local-handler-app;1" + ].createInstance(Ci.nsILocalHandlerApp); + handlerApp.executable = fp.file; + + // if this application is already in the list, select it and don't add it again + let parent = document.getElementById("items"); + for (let i = 0; i < parent.childNodes.length; ++i) { + let elm = parent.childNodes[i]; + if ( + elm.obj instanceof Ci.nsILocalHandlerApp && + elm.obj.equals(handlerApp) + ) { + parent.selectedItem = elm; + parent.ensureSelectedElementIsVisible(); + return; + } + } + + let elm = document.createXULElement("richlistitem", { + is: "mozapps-handler", + }); + elm.setAttribute("name", fp.file.leafName); + elm.setAttribute("image", "moz-icon://" + uri.spec + "?size=32"); + elm.obj = handlerApp; + + parent.selectedItem = parent.insertBefore(elm, parent.firstChild); + parent.ensureSelectedElementIsVisible(); + } + }); + }, + + /** + * Function called when the OK button is pressed. + */ + onAccept() { + this.updateHandlerData(this._rememberCheck.checked); + this._outArgs.setProperty("openHandler", true); + }, + + /** + * Determines if the accept button should be disabled or not + */ + updateAcceptButton() { + this._dialog.setAttribute( + "buttondisabledaccept", + this._acceptBtnDisabled || this._itemChoose.selected + ); + }, + + /** + * Update the handler info to reflect the user choice. + * @param {boolean} skipAsk - Whether we should persist the application + * choice and skip asking next time. + */ + updateHandlerData(skipAsk) { + // We need to make sure that the default is properly set now + if (this.selectedItem.obj) { + // default OS handler doesn't have this property + this._outArgs.setProperty( + "preferredAction", + Ci.nsIHandlerInfo.useHelperApp + ); + this._outArgs.setProperty( + "preferredApplicationHandler", + this.selectedItem.obj + ); + } else { + this._outArgs.setProperty( + "preferredAction", + Ci.nsIHandlerInfo.useSystemDefault + ); + } + this._outArgs.setProperty("alwaysAskBeforeHandling", !skipAsk); + }, + + /** + * Updates the UI based on the checkbox being checked or not. + */ + onCheck() { + if (document.getElementById("remember").checked) { + document.getElementById("remember-text").setAttribute("visible", "true"); + } else { + document.getElementById("remember-text").removeAttribute("visible"); + } + }, + + /** + * Function called when the user double clicks on an item of the list + */ + onDblClick: function onDblClick() { + if (this.selectedItem == this._itemChoose) { + this.chooseApplication(); + } else { + this._dialog.acceptDialog(); + } + }, + + // Getters / Setters + + /** + * Returns/sets the selected element in the richlistbox + */ + get selectedItem() { + return document.getElementById("items").selectedItem; + }, + set selectedItem(aItem) { + document.getElementById("items").selectedItem = aItem; + }, + + /** + * Lazy l10n getter for the title of the app chooser window + */ + async getChooseAppWindowTitle() { + if (!this._chooseAppWindowTitle) { + this._chooseAppWindowTitle = await document.l10n.formatValues([ + "choose-other-app-window-title", + ]); + } + return this._chooseAppWindowTitle; + }, + + /** + * Lazy l10n getter for handler menu items which are disabled due to private + * browsing. + */ + async getPrivateBrowsingDisabledLabel() { + if (!this._privateBrowsingDisabledLabel) { + this._privateBrowsingDisabledLabel = await document.l10n.formatValues([ + "choose-dialog-privatebrowsing-disabled", + ]); + } + return this._privateBrowsingDisabledLabel; + }, +}; diff --git a/toolkit/mozapps/handling/content/appChooser.xhtml b/toolkit/mozapps/handling/content/appChooser.xhtml new file mode 100644 index 0000000000..a87286cf12 --- /dev/null +++ b/toolkit/mozapps/handling/content/appChooser.xhtml @@ -0,0 +1,66 @@ + + + + + + + + + + + + + + + +