diff options
Diffstat (limited to 'toolkit/components/prompts')
36 files changed, 6983 insertions, 0 deletions
diff --git a/toolkit/components/prompts/content/adjustableTitle.js b/toolkit/components/prompts/content/adjustableTitle.js new file mode 100644 index 0000000000..16442142a8 --- /dev/null +++ b/toolkit/components/prompts/content/adjustableTitle.js @@ -0,0 +1,193 @@ +/* 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"; + +let { PromptUtils } = ChromeUtils.import( + "resource://gre/modules/SharedPromptUtils.jsm" +); + +const AdjustableTitle = { + _cssSnippet: ` + #titleContainer { + /* This gets display: flex by virtue of being a row in a subdialog, from + * commonDialog.css . */ + flex-shrink: 0; + + flex-direction: row; + align-items: baseline; + + margin-inline: 4px; + /* Ensure we don't exceed the bounds of the dialog: */ + max-width: calc(100vw - 32px); + + --icon-size: 16px; + } + + #titleContainer[noicon] > .titleIcon { + display: none; + } + + .titleIcon { + width: var(--icon-size); + height: var(--icon-size); + padding-inline-end: 4px; + flex-shrink: 0; + + background-image: var(--icon-url, url("chrome://global/skin/icons/defaultFavicon.svg")); + background-size: 16px 16px; + background-origin: content-box; + background-repeat: no-repeat; + background-color: var(--in-content-page-background); + -moz-context-properties: fill; + fill: currentColor; + } + + #titleCropper:not([nomaskfade]) { + display: inline-flex; + } + + #titleCropper { + overflow: hidden; + + justify-content: right; + mask-repeat: no-repeat; + /* go from left to right with the mask: */ + --mask-dir: right; + } + + #titleContainer:not([noicon]) > #titleCropper { + /* Align the icon and text: */ + translate: 0 calc(-1px - max(.6 * var(--icon-size) - .6em, 0px)); + } + + #titleCropper[rtlorigin] { + justify-content: left; + /* go from right to left with the mask: */ + --mask-dir: left; + } + + + #titleCropper:not([nomaskfade]) #titleText { + display: inline-flex; + white-space: nowrap; + } + + #titleText { + font-weight: 600; + flex: 1 0 auto; /* Grow but do not shrink. */ + unicode-bidi: plaintext; /* Ensure we align RTL text correctly. */ + text-align: match-parent; + } + + #titleCropper[overflown] { + mask-image: linear-gradient(to var(--mask-dir), transparent, black 100px); + } + + /* hide the old title */ + #infoTitle { + display: none; + } + `, + + _insertMarkup() { + let iconEl = document.createElement("span"); + iconEl.className = "titleIcon"; + this._titleCropEl = document.createElement("span"); + this._titleCropEl.id = "titleCropper"; + this._titleEl = document.createElement("span"); + this._titleEl.id = "titleText"; + this._containerEl = document.createElement("div"); + this._containerEl.id = "titleContainer"; + this._containerEl.className = "dialogRow titleContainer"; + this._titleCropEl.append(this._titleEl); + this._containerEl.append(iconEl, this._titleCropEl); + let targetID = document.documentElement.getAttribute("headerparent"); + document.getElementById(targetID).prepend(this._containerEl); + let styleEl = document.createElement("style"); + styleEl.textContent = this._cssSnippet; + document.documentElement.prepend(styleEl); + }, + + _overflowHandler() { + requestAnimationFrame(async () => { + let isOverflown; + try { + isOverflown = await window.promiseDocumentFlushed(() => { + return ( + this._titleCropEl.getBoundingClientRect().width < + this._titleEl.getBoundingClientRect().width + ); + }); + } catch (ex) { + // In automated tests, this can fail with a DOM exception if + // the window has closed by the time layout tries to call us. + // In this case, just bail, and only log any other errors: + if ( + !DOMException.isInstance(ex) || + ex.name != "NoModificationAllowedError" + ) { + Cu.reportError(ex); + } + return; + } + this._titleCropEl.toggleAttribute("overflown", isOverflown); + if (isOverflown) { + this._titleEl.setAttribute("title", this._titleEl.textContent); + } else { + this._titleEl.removeAttribute("title"); + } + }); + }, + + _updateTitle(title) { + title = JSON.parse(title); + if (title.raw) { + this._titleEl.textContent = title.raw; + let { DIRECTION_RTL } = window.windowUtils; + this._titleCropEl.toggleAttribute( + "rtlorigin", + window.windowUtils.getDirectionFromText(title.raw) == DIRECTION_RTL + ); + } else { + document.l10n.setAttributes(this._titleEl, title.l10nId); + } + + if (!document.documentElement.hasAttribute("neediconheader")) { + this._containerEl.setAttribute("noicon", "true"); + } else if (title.shouldUseMaskFade) { + this._overflowHandler(); + } else { + this._titleCropEl.toggleAttribute("nomaskfade", true); + } + }, + + init() { + // Only run this if we're embedded and proton modals are enabled. + if (!window.docShell.chromeEventHandler) { + return; + } + + this._insertMarkup(); + let title = document.documentElement.getAttribute("headertitle"); + if (title) { + this._updateTitle(title); + } + this._mutObs = new MutationObserver(() => { + this._updateTitle(document.documentElement.getAttribute("headertitle")); + }); + this._mutObs.observe(document.documentElement, { + attributes: true, + attributeFilter: ["headertitle"], + }); + }, +}; + +document.addEventListener( + "DOMContentLoaded", + () => { + AdjustableTitle.init(); + }, + { once: true } +); diff --git a/toolkit/components/prompts/content/commonDialog.css b/toolkit/components/prompts/content/commonDialog.css new file mode 100644 index 0000000000..3521af13c6 --- /dev/null +++ b/toolkit/components/prompts/content/commonDialog.css @@ -0,0 +1,124 @@ +/* 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/. */ + +:root { + min-width: 29em; +} + +dialog[insecureauth] { + --icon-url: url("chrome://global/skin/icons/security-broken.svg"); +} + +#dialogGrid { + display: grid; + grid-template-columns: auto 1fr; + align-items: center; + max-height: 100%; +} + +.dialogRow:not([hidden]) { + display: contents; +} + +#iconContainer { + align-self: start; +} + +#infoContainer { + max-width: 45em; +} + +#infoTitle { + margin-bottom: 1em; +} + +#infoBody { + -moz-user-focus: normal; + user-select: text; + cursor: text !important; + white-space: pre-wrap; + word-break: break-word; + unicode-bidi: plaintext; + overflow-y: auto; +} + +.sizeDetermined, +.sizeDetermined::part(content-box), +.sizeDetermined #infoBody, +.sizeDetermined #infoRow, +.sizeDetermined #infoContainer { + /* Allow stuff to shrink */ + min-height: 0; +} + +.sizeDetermined #infoRow { + /* Make the info row take all the available space, potentially shrinking, + * since it's what contains the infoBody, which is scrollable */ + flex: 1; +} + +#loginLabel, #password1Label { + text-align: start; +} + +#loginTextbox, +#password1Textbox { + text-align: match-parent; +} + +/* use flexbox instead of grid: */ +dialog[subdialog], +dialog[subdialog] #dialogGrid, +dialog[subdialog] #infoContainer, +dialog[subdialog] .dialogRow:not([hidden]) { + display: flex; + flex-direction: column; + align-items: stretch; +} + +dialog[subdialog] #iconContainer { + display: none; +} + +/* Fix padding/spacing */ +dialog[subdialog] { + --grid-padding: 16px; + /* All the inner items should have 4px inline margin, leading to 1.16em spacing + * between the dialog and its contents, and 8px horizontal spacing between items. */ + padding: var(--grid-padding) calc(var(--grid-padding) - 4px); +} + +/* Use an ID selector for the dialog to win on specificity... */ +#commonDialog[subdialog] description, +#commonDialog[subdialog] checkbox { + margin: 0 4px; +} + +#commonDialog[subdialog] label { + margin: 4px; /* Labels for input boxes should get block as well as the regular inline margin. */ +} + +#commonDialog[subdialog] .checkbox-label { + /* The checkbox already has the horizontal margin, so override the rule + * above. */ + margin: 0; +} + +#commonDialog[subdialog] input { + margin: 0 4px 4px; +} + +/* Add vertical spaces between rows: */ +dialog[subdialog] .dialogRow { + margin-block: 0 var(--grid-padding); +} + +/* Fix spacing in the `prompt()` case: */ +dialog[subdialog] #loginLabel[value=""] { + display: none; +} + +dialog[subdialog][windowtype="prompt:prompt"] #infoRow { + margin-bottom: 4px; +} diff --git a/toolkit/components/prompts/content/commonDialog.js b/toolkit/components/prompts/content/commonDialog.js new file mode 100644 index 0000000000..f11d3c3785 --- /dev/null +++ b/toolkit/components/prompts/content/commonDialog.js @@ -0,0 +1,147 @@ +/* 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 { CommonDialog } = ChromeUtils.import( + "resource://gre/modules/CommonDialog.jsm" +); + +// imported by adjustableTitle.js loaded in the same context: +/* globals PromptUtils */ + +var propBag, args, Dialog; + +// Inherit color scheme overrides from parent window. This is to inherit the +// color scheme of dark themed PBM windows. +{ + let openerColorSchemeOverride = + window.opener?.browsingContext?.top.prefersColorSchemeOverride; + if ( + openerColorSchemeOverride && + window.browsingContext == window.browsingContext.top + ) { + window.browsingContext.prefersColorSchemeOverride = openerColorSchemeOverride; + } +} + +function commonDialogOnLoad() { + propBag = window.arguments[0] + .QueryInterface(Ci.nsIWritablePropertyBag2) + .QueryInterface(Ci.nsIWritablePropertyBag); + // Convert to a JS object + args = {}; + for (let prop of propBag.enumerator) { + args[prop.name] = prop.value; + } + + let dialog = document.getElementById("commonDialog"); + + let needIconifiedHeader = + args.modalType == Ci.nsIPrompt.MODAL_TYPE_CONTENT || + ["promptUserAndPass", "promptPassword"].includes(args.promptType) || + args.headerIconURL; + let root = document.documentElement; + if (needIconifiedHeader) { + root.setAttribute("neediconheader", "true"); + } + let title = { raw: args.title }; + let { promptPrincipal } = args; + if (promptPrincipal) { + if (promptPrincipal.isNullPrincipal) { + title = { l10nId: "common-dialog-title-null" }; + } else if (promptPrincipal.isSystemPrincipal) { + title = { l10nId: "common-dialog-title-system" }; + root.style.setProperty( + "--icon-url", + "url('chrome://branding/content/icon32.png')" + ); + } else if (promptPrincipal.addonPolicy) { + title.raw = promptPrincipal.addonPolicy.name; + } else if (promptPrincipal.isContentPrincipal) { + try { + title.raw = promptPrincipal.URI.displayHostPort; + } catch (ex) { + // hostPort getter can throw, e.g. for about URIs. + title.raw = promptPrincipal.originNoSuffix; + } + // hostPort can be empty for file URIs. + if (!title.raw) { + title.raw = promptPrincipal.prePath; + } + } else { + title = { l10nId: "common-dialog-title-unknown" }; + } + } else if (args.authOrigin) { + title = { raw: args.authOrigin }; + } + if (args.headerIconURL) { + root.style.setProperty("--icon-url", `url('${args.headerIconURL}')`); + } + // Fade and crop potentially long raw titles, e.g., origins and hostnames. + title.shouldUseMaskFade = title.raw && (args.authOrigin || promptPrincipal); + root.setAttribute("headertitle", JSON.stringify(title)); + if (args.isInsecureAuth) { + dialog.setAttribute("insecureauth", "true"); + } + + let ui = { + prompt: window, + loginContainer: document.getElementById("loginContainer"), + loginTextbox: document.getElementById("loginTextbox"), + loginLabel: document.getElementById("loginLabel"), + password1Container: document.getElementById("password1Container"), + password1Textbox: document.getElementById("password1Textbox"), + password1Label: document.getElementById("password1Label"), + infoRow: document.getElementById("infoRow"), + infoBody: document.getElementById("infoBody"), + infoTitle: document.getElementById("infoTitle"), + infoIcon: document.getElementById("infoIcon"), + checkbox: document.getElementById("checkbox"), + checkboxContainer: document.getElementById("checkboxContainer"), + button3: dialog.getButton("extra2"), + button2: dialog.getButton("extra1"), + button1: dialog.getButton("cancel"), + button0: dialog.getButton("accept"), + focusTarget: window, + }; + + Dialog = new CommonDialog(args, ui); + window.addEventListener("dialogclosing", function(aEvent) { + if (aEvent.detail?.abort) { + Dialog.abortPrompt(); + } + }); + document.addEventListener("dialogaccept", function() { + Dialog.onButton0(); + }); + document.addEventListener("dialogcancel", function() { + Dialog.onButton1(); + }); + document.addEventListener("dialogextra1", function() { + Dialog.onButton2(); + window.close(); + }); + document.addEventListener("dialogextra2", function() { + Dialog.onButton3(); + window.close(); + }); + document.subDialogSetDefaultFocus = isInitialFocus => + Dialog.setDefaultFocus(isInitialFocus); + Dialog.onLoad(dialog); + + // resize the window to the content + window.sizeToContent(); + + // If the icon hasn't loaded yet, size the window to the content again when + // it does, as its layout can change. + ui.infoIcon.addEventListener("load", () => window.sizeToContent()); + + window.getAttention(); +} + +function commonDialogOnUnload() { + // Convert args back into property bag + for (let propName in args) { + propBag.setProperty(propName, args[propName]); + } +} diff --git a/toolkit/components/prompts/content/commonDialog.xhtml b/toolkit/components/prompts/content/commonDialog.xhtml new file mode 100644 index 0000000000..ec6dec010a --- /dev/null +++ b/toolkit/components/prompts/content/commonDialog.xhtml @@ -0,0 +1,81 @@ +<?xml version="1.0"?> +<!-- 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/. --> + + +<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?> +<?xml-stylesheet href="chrome://global/content/commonDialog.css" type="text/css"?> +<?xml-stylesheet href="chrome://global/skin/commonDialog.css" type="text/css"?> + +<!DOCTYPE window> + +<window id="commonDialogWindow" + xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + xmlns:html="http://www.w3.org/1999/xhtml" + xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul" + aria-describedby="infoBody" + headerparent="dialogGrid" + onunload="commonDialogOnUnload();"> +<dialog id="commonDialog" + buttonpack="end"> + + <linkset> + <html:link rel="localization" href="branding/brand.ftl"/> + <html:link rel="localization" href="toolkit/global/commonDialog.ftl"/> + </linkset> + <script src="chrome://global/content/adjustableTitle.js"/> + <script src="chrome://global/content/commonDialog.js"/> + <script src="chrome://global/content/globalOverlay.js"/> + <script src="chrome://global/content/editMenuOverlay.js"/> + <script src="chrome://global/content/customElements.js"/> + <script> + /* eslint-disable no-undef */ + document.addEventListener("DOMContentLoaded", function() { + commonDialogOnLoad(); + }); + </script> + + <commandset id="selectEditMenuItems"> + <command id="cmd_copy" oncommand="goDoCommand('cmd_copy')" disabled="true"/> + <command id="cmd_selectAll" oncommand="goDoCommand('cmd_selectAll')"/> + </commandset> + + <popupset id="contentAreaContextSet"> + <menupopup id="contentAreaContextMenu" + onpopupshowing="goUpdateCommand('cmd_copy')"> + <menuitem id="context-copy" + data-l10n-id="common-dialog-copy-cmd" + command="cmd_copy" + disabled="true"/> + <menuitem id="context-selectall" + data-l10n-id="common-dialog-select-all-cmd" + command="cmd_selectAll"/> + </menupopup> + </popupset> + + <div xmlns="http://www.w3.org/1999/xhtml" id="dialogGrid"> + <div class="dialogRow" id="infoRow" hidden="hidden"> + <div id="iconContainer"> + <xul:image id="infoIcon"/> + </div> + <div id="infoContainer"> + <xul:description id="infoTitle"/> + <xul:description id="infoBody" context="contentAreaContextMenu" noinitialfocus="true"/> + </div> + </div> + <div id="loginContainer" class="dialogRow" hidden="hidden"> + <xul:label id="loginLabel" data-l10n-id="common-dialog-username" control="loginTextbox"/> + <input type="text" id="loginTextbox" dir="ltr"/> + </div> + <div id="password1Container" class="dialogRow" hidden="hidden"> + <xul:label id="password1Label" data-l10n-id="common-dialog-password" control="password1Textbox"/> + <input type="password" id="password1Textbox" dir="ltr"/> + </div> + <div id="checkboxContainer" class="dialogRow" hidden="hidden"> + <div/> <!-- spacer --> + <xul:checkbox id="checkbox" oncommand="Dialog.onCheckbox()"/> + </div> + </div> +</dialog> +</window> diff --git a/toolkit/components/prompts/content/selectDialog.js b/toolkit/components/prompts/content/selectDialog.js new file mode 100644 index 0000000000..d079beb755 --- /dev/null +++ b/toolkit/components/prompts/content/selectDialog.js @@ -0,0 +1,83 @@ +/* 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/. */ + +// Defined in dialog.xml. +/* globals centerWindowOnScreen:false, moveToAlertPosition:false */ + +var propBag, listBox, args; + +function onDCL() { + propBag = window.arguments[0] + .QueryInterface(Ci.nsIWritablePropertyBag2) + .QueryInterface(Ci.nsIWritablePropertyBag); + + // Convert to a JS object + let args = {}; + for (let prop of propBag.enumerator) { + args[prop.name] = prop.value; + } + + let promptType = propBag.getProperty("promptType"); + if (promptType != "select") { + Cu.reportError("selectDialog opened for unknown type: " + promptType); + window.close(); + } + + // Default to canceled. + propBag.setProperty("ok", false); + + document.title = propBag.getProperty("title"); + + let text = propBag.getProperty("text"); + document.getElementById("info.txt").setAttribute("value", text); + + let items = propBag.getProperty("list"); + listBox = document.getElementById("list"); + + for (let i = 0; i < items.length; i++) { + let str = items[i]; + if (str == "") { + str = "<>"; + } + listBox.appendItem(str); + listBox.getItemAtIndex(i).addEventListener("dblclick", dialogDoubleClick); + } + listBox.selectedIndex = 0; +} + +function onLoad() { + listBox.focus(); + + document.addEventListener("dialogaccept", dialogOK); + // resize the window to the content + window.sizeToContent(); + + // Move to the right location + moveToAlertPosition(); + centerWindowOnScreen(); + + // play sound + try { + if (!args.openedWithTabDialog) { + Cc["@mozilla.org/sound;1"] + .getService(Ci.nsISound) + .playEventSound(Ci.nsISound.EVENT_SELECT_DIALOG_OPEN); + } + } catch (e) {} + + Services.obs.notifyObservers(window, "select-dialog-loaded"); +} + +function dialogOK() { + propBag.setProperty("selected", listBox.selectedIndex); + propBag.setProperty("ok", true); +} + +function dialogDoubleClick() { + dialogOK(); + window.close(); +} + +document.addEventListener("DOMContentLoaded", onDCL); +window.addEventListener("load", onLoad, { once: true }); diff --git a/toolkit/components/prompts/content/selectDialog.xhtml b/toolkit/components/prompts/content/selectDialog.xhtml new file mode 100644 index 0000000000..877e0e7140 --- /dev/null +++ b/toolkit/components/prompts/content/selectDialog.xhtml @@ -0,0 +1,22 @@ +<?xml version="1.0"?> + +<!-- 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/. --> + +<?xml-stylesheet href="chrome://global/skin/global.css" type="text/css"?> +<!DOCTYPE window> + +<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> +<dialog> + + <script src="chrome://global/content/selectDialog.js" /> + <keyset id="dialogKeys"/> + <vbox style="width: 24em;margin: 5px;"> + <label id="info.txt"/> + <vbox> + <richlistbox id="list" class="theme-listbox" style="height: 8em;"/> + </vbox> + </vbox> +</dialog> +</window> diff --git a/toolkit/components/prompts/content/tabprompts.css b/toolkit/components/prompts/content/tabprompts.css new file mode 100644 index 0000000000..9d9147d05d --- /dev/null +++ b/toolkit/components/prompts/content/tabprompts.css @@ -0,0 +1,119 @@ +/* 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/. */ + +/* Tab Modal Prompt boxes */ + +.tabModalBackground { + -moz-box-pack: center; + -moz-box-orient: vertical; +} + +.tabModalBackground, +tabmodalprompt { + width: 100%; + height: 100%; +} + +tabmodalprompt { + --tabmodalprompt-padding: 20px; + overflow: hidden; + text-shadow: none; /* remove lightweight theme text-shadow */ +} + +tabmodalprompt:not([hidden]) { + display: grid; + grid-template-rows: 1fr [dialog-start] auto [dialog-end] 2fr; + justify-items: center; +} + +/* + Adjustments for chrome level tab-prompts to make them + overlap with the upper chrome UI and move them in + front of content prompts. +*/ +tabmodalprompt.tab-prompt { + overflow: visible; + z-index: 1; + grid-template-rows: [dialog-start] auto [dialog-end] 1fr; +} + +tabmodalprompt.tab-prompt .tabmodalprompt-mainContainer { + margin-top: -5px; +} + +.tabmodalprompt-mainContainer { + min-width: 20em; + min-height: 12em; + max-width: calc(60% + calc(var(--tabmodalprompt-padding) * 2)); + -moz-user-focus: normal; + grid-row: dialog; + + display: flex; + flex-direction: column; +} + +.tabmodalprompt-topContainer { + flex-grow: 1; + padding: var(--tabmodalprompt-padding); + display: grid; + grid-template-columns: auto 1fr; + align-items: baseline; + align-content: center; /* center content vertically */ + max-width: 100%; + min-height: 0; + max-height: 60vh; + box-sizing: border-box; +} + +.tabmodalprompt-topContainer > div:not(.tabmodalprompt-infoContainer, [hidden]) { + display: contents; +} + +.tabmodalprompt-infoContainer { + grid-column: span 2; + + display: block; + margin-block: auto; + max-width: 100%; + height: 100%; + min-height: 0; + justify-self: center; /* center text, but only when it fits in one line */ +} + +/* When all elements in the first column are hidden, prevent the second column + from becoming the first one because it won't have the right fraction */ +.tabmodalprompt-topContainer > div > *:nth-child(2) { + grid-column: 2; +} + +.infoTitle { + margin-bottom: 1em !important; + font-weight: bold; +} + +.infoBody { + margin: 0 !important; + -moz-user-focus: normal; + user-select: text; + cursor: text !important; + white-space: pre-wrap; + unicode-bidi: plaintext; + outline: none; /* remove focus outline */ + overflow: auto; + max-width: 100%; + max-height: 100%; +} + +tabmodalprompt label[value=""] { + display: none; +} + +.tabmodalprompt-buttonContainer { + display: flex; + padding: 12px var(--tabmodalprompt-padding) 15px; +} + +.tabmodalprompt-buttonSpacer { + flex-grow: 1; +} diff --git a/toolkit/components/prompts/content/tabprompts.jsm b/toolkit/components/prompts/content/tabprompts.jsm new file mode 100644 index 0000000000..13a75f01a9 --- /dev/null +++ b/toolkit/components/prompts/content/tabprompts.jsm @@ -0,0 +1,307 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +"use strict"; + +var EXPORTED_SYMBOLS = ["TabModalPrompt"]; + +const { AppConstants } = ChromeUtils.importESModule( + "resource://gre/modules/AppConstants.sys.mjs" +); + +var TabModalPrompt = class { + constructor(win) { + this.win = win; + let newPrompt = (this.element = win.document.createElement( + "tabmodalprompt" + )); + win.MozXULElement.insertFTLIfNeeded("toolkit/global/tabprompts.ftl"); + newPrompt.setAttribute("role", "dialog"); + let randomIdSuffix = Math.random() + .toString(32) + .substring(2); + newPrompt.setAttribute("aria-describedby", `infoBody-${randomIdSuffix}`); + newPrompt.appendChild( + win.MozXULElement.parseXULToFragment( + ` + <div class="tabmodalprompt-mainContainer" xmlns="http://www.w3.org/1999/xhtml" xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"> + <div class="tabmodalprompt-topContainer"> + <div class="tabmodalprompt-infoContainer"> + <div class="tabmodalprompt-infoTitle infoTitle" hidden="hidden"/> + <div class="tabmodalprompt-infoBody infoBody" id="infoBody-${randomIdSuffix}" tabindex="-1"/> + </div> + + <div class="tabmodalprompt-loginContainer" hidden="hidden"> + <xul:label class="tabmodalprompt-loginLabel" data-l10n-id="tabmodalprompt-username" control="loginTextbox-${randomIdSuffix}"/> + <input class="tabmodalprompt-loginTextbox" id="loginTextbox-${randomIdSuffix}"/> + </div> + + <div class="tabmodalprompt-password1Container" hidden="hidden"> + <xul:label class="tabmodalprompt-password1Label" data-l10n-id="tabmodalprompt-password" control="password1Textbox-${randomIdSuffix}"/> + <input class="tabmodalprompt-password1Textbox" type="password" id="password1Textbox-${randomIdSuffix}"/> + </div> + + <div class="tabmodalprompt-checkboxContainer" hidden="hidden"> + <div/> + <xul:checkbox class="tabmodalprompt-checkbox"/> + </div> + + <!-- content goes here --> + </div> + <div class="tabmodalprompt-buttonContainer"> + <xul:button class="tabmodalprompt-button3" hidden="true"/> + <div class="tabmodalprompt-buttonSpacer"/> + <xul:button class="tabmodalprompt-button0" data-l10n-id="tabmodalprompt-ok-button"/> + <xul:button class="tabmodalprompt-button2" hidden="true"/> + <xul:button class="tabmodalprompt-button1" data-l10n-id="tabmodalprompt-cancel-button"/> + </div> + </div>` + ) + ); + + this.ui = { + prompt: this, + promptContainer: this.element, + mainContainer: newPrompt.querySelector(".tabmodalprompt-mainContainer"), + loginContainer: newPrompt.querySelector(".tabmodalprompt-loginContainer"), + loginTextbox: newPrompt.querySelector(".tabmodalprompt-loginTextbox"), + loginLabel: newPrompt.querySelector(".tabmodalprompt-loginLabel"), + password1Container: newPrompt.querySelector( + ".tabmodalprompt-password1Container" + ), + password1Textbox: newPrompt.querySelector( + ".tabmodalprompt-password1Textbox" + ), + password1Label: newPrompt.querySelector(".tabmodalprompt-password1Label"), + infoContainer: newPrompt.querySelector(".tabmodalprompt-infoContainer"), + infoBody: newPrompt.querySelector(".tabmodalprompt-infoBody"), + infoTitle: newPrompt.querySelector(".tabmodalprompt-infoTitle"), + infoIcon: null, + rows: newPrompt.querySelector(".tabmodalprompt-topContainer"), + checkbox: newPrompt.querySelector(".tabmodalprompt-checkbox"), + checkboxContainer: newPrompt.querySelector( + ".tabmodalprompt-checkboxContainer" + ), + button3: newPrompt.querySelector(".tabmodalprompt-button3"), + button2: newPrompt.querySelector(".tabmodalprompt-button2"), + button1: newPrompt.querySelector(".tabmodalprompt-button1"), + button0: newPrompt.querySelector(".tabmodalprompt-button0"), + // focusTarget (for BUTTON_DELAY_ENABLE) not yet supported + }; + + if (AppConstants.XP_UNIX) { + // Reorder buttons on Linux + let buttonContainer = newPrompt.querySelector( + ".tabmodalprompt-buttonContainer" + ); + buttonContainer.appendChild(this.ui.button3); + buttonContainer.appendChild(this.ui.button2); + buttonContainer.appendChild( + newPrompt.querySelector(".tabmodalprompt-buttonSpacer") + ); + buttonContainer.appendChild(this.ui.button1); + buttonContainer.appendChild(this.ui.button0); + } + + this.ui.button0.addEventListener( + "command", + this.onButtonClick.bind(this, 0) + ); + this.ui.button1.addEventListener( + "command", + this.onButtonClick.bind(this, 1) + ); + this.ui.button2.addEventListener( + "command", + this.onButtonClick.bind(this, 2) + ); + this.ui.button3.addEventListener( + "command", + this.onButtonClick.bind(this, 3) + ); + // Anonymous wrapper used here because |Dialog| doesn't exist until init() is called! + this.ui.checkbox.addEventListener("command", () => { + this.Dialog.onCheckbox(); + }); + + /** + * Based on dialog.xml handlers + */ + this.element.addEventListener( + "keypress", + event => { + switch (event.keyCode) { + case KeyEvent.DOM_VK_RETURN: + this.onKeyAction("default", event); + break; + + case KeyEvent.DOM_VK_ESCAPE: + this.onKeyAction("cancel", event); + break; + + default: + if ( + AppConstants.platform == "macosx" && + event.key == "." && + event.metaKey + ) { + this.onKeyAction("cancel", event); + } + break; + } + }, + { mozSystemGroup: true } + ); + + this.element.addEventListener( + "focus", + event => { + let bnum = this.args.defaultButtonNum || 0; + let defaultButton = this.ui["button" + bnum]; + + if (AppConstants.platform == "macosx") { + // On OS X, the default button always stays marked as such (until + // the entire prompt blurs). + defaultButton.setAttribute("default", "true"); + } else { + // On other platforms, the default button is only marked as such + // when no other button has focus. XUL buttons on not-OSX will + // react to pressing enter as a command, so you can't trigger the + // default without tabbing to it or something that isn't a button. + let focusedDefault = event.originalTarget == defaultButton; + let someButtonFocused = + event.originalTarget.localName == "button" || + event.originalTarget.localName == "toolbarbutton"; + if (focusedDefault || !someButtonFocused) { + defaultButton.setAttribute("default", "true"); + } + } + }, + true + ); + + this.element.addEventListener("blur", () => { + // If focus shifted to somewhere else in the browser, don't make + // the default button look active. + let bnum = this.args.defaultButtonNum || 0; + let button = this.ui["button" + bnum]; + button.removeAttribute("default"); + }); + } + + init(args, linkedTab, onCloseCallback) { + this.args = args; + this.linkedTab = linkedTab; + this.onCloseCallback = onCloseCallback; + + if (args.enableDelay) { + throw new Error( + "BUTTON_DELAY_ENABLE not yet supported for tab-modal prompts" + ); + } + + // Apply styling depending on modalType (content or tab prompt) + if (args.modalType === Ci.nsIPrompt.MODAL_TYPE_TAB) { + this.element.classList.add("tab-prompt"); + } else { + this.element.classList.add("content-prompt"); + } + + // We need to remove the prompt when the tab or browser window is closed or + // the page navigates, else we never unwind the event loop and that's sad times. + // Remember to cleanup in shutdownPrompt()! + this.win.addEventListener("resize", this); + this.win.addEventListener("unload", this); + if (linkedTab) { + linkedTab.addEventListener("TabClose", this); + } + // Note: + // nsPrompter.js or in e10s mode browser-parent.js call abortPrompt, + // when the domWindow, for which the prompt was created, generates + // a "pagehide" event. + + let { CommonDialog } = ChromeUtils.import( + "resource://gre/modules/CommonDialog.jsm" + ); + this.Dialog = new CommonDialog(args, this.ui); + this.Dialog.onLoad(null); + + // For content prompts display the tabprompt title that shows the prompt origin when + // the prompt origin is not the same as that of the top window. + if ( + args.modalType == Ci.nsIPrompt.MODAL_TYPE_CONTENT && + args.showCallerOrigin + ) { + this.ui.infoTitle.removeAttribute("hidden"); + } + + // TODO: should unhide buttonSpacer on Windows when there are 4 buttons. + // Better yet, just drop support for 4-button dialogs. (bug 609510) + } + + shutdownPrompt() { + // remove our event listeners + try { + this.win.removeEventListener("resize", this); + this.win.removeEventListener("unload", this); + if (this.linkedTab) { + this.linkedTab.removeEventListener("TabClose", this); + } + } catch (e) {} + // invoke callback + this.onCloseCallback(); + this.win = null; + this.ui = null; + // Intentionally not cleaning up |this.element| here -- + // TabModalPromptBox.removePrompt() would need it and it might not + // be called yet -- see browser_double_close_tabs.js. + } + + abortPrompt() { + // Called from other code when the page changes. + this.Dialog.abortPrompt(); + this.shutdownPrompt(); + } + + handleEvent(aEvent) { + switch (aEvent.type) { + case "unload": + case "TabClose": + this.abortPrompt(); + break; + } + } + + onButtonClick(buttonNum) { + // We want to do all the work her asynchronously off a Gecko + // runnable, because of situations like the one described in + // https://bugzilla.mozilla.org/show_bug.cgi?id=1167575#c35 : we + // get here off processing of an OS event and will also process + // one more Gecko runnable before we break out of the event loop + // spin whoever posted the prompt is doing. If we do all our + // work sync, we will exit modal state _before_ processing that + // runnable, and if exiting moral state posts a runnable we will + // incorrectly process that runnable before leaving our event + // loop spin. + Services.tm.dispatchToMainThread(() => { + this.Dialog["onButton" + buttonNum](); + this.shutdownPrompt(); + }); + } + + onKeyAction(action, event) { + if (event.defaultPrevented) { + return; + } + + event.stopPropagation(); + if (action == "default") { + let bnum = this.args.defaultButtonNum || 0; + this.onButtonClick(bnum); + } else { + // action == "cancel" + this.onButtonClick(1); // Cancel button + } + } +}; diff --git a/toolkit/components/prompts/docs/index.rst b/toolkit/components/prompts/docs/index.rst new file mode 100644 index 0000000000..c518bef41b --- /dev/null +++ b/toolkit/components/prompts/docs/index.rst @@ -0,0 +1,10 @@ +======= +Prompts +======= + +.. toctree:: + :maxdepth: 1 + + nsIPromptService + nsIPromptService-reference + modalTypes diff --git a/toolkit/components/prompts/docs/modal-type-content.png b/toolkit/components/prompts/docs/modal-type-content.png Binary files differnew file mode 100644 index 0000000000..730fe7828c --- /dev/null +++ b/toolkit/components/prompts/docs/modal-type-content.png diff --git a/toolkit/components/prompts/docs/modal-type-tab.png b/toolkit/components/prompts/docs/modal-type-tab.png Binary files differnew file mode 100644 index 0000000000..66da8ef782 --- /dev/null +++ b/toolkit/components/prompts/docs/modal-type-tab.png diff --git a/toolkit/components/prompts/docs/modal-type-window.png b/toolkit/components/prompts/docs/modal-type-window.png Binary files differnew file mode 100644 index 0000000000..505850e8de --- /dev/null +++ b/toolkit/components/prompts/docs/modal-type-window.png diff --git a/toolkit/components/prompts/docs/modalTypes.rst b/toolkit/components/prompts/docs/modalTypes.rst new file mode 100644 index 0000000000..1425d6832c --- /dev/null +++ b/toolkit/components/prompts/docs/modalTypes.rst @@ -0,0 +1,95 @@ +================== +Prompt Modal Types +================== + +Window Prompts +-------------- + +Window prompts are system prompts. They are clearly distinguishable from website +content and can be opened with or without a parent window. +While a window prompt is open, the parent window cannot be interacted with. +That means the user can not close the window or switch tabs. +Providing a parent window is optional, but highly encouraged. If you do not +pass a parent the implementation will try to find one or fallback to aborted +standalone window. + +**When to use**: This should be reserved for important browser-wide messages +with the intent to block any further user interaction until the message has been +read. + +**Flag**: `MODAL_TYPE_WINDOW` + +.. caution:: + + When using window prompts, make sure they can not be spawned by web content. + We've seen `cases <https://bugzilla.mozilla.org/show_bug.cgi?id=1571003>`_ + of DoS attacks in the wild where websites spammed window prompts to lock up + the browser. + This prompt type should only be used when necessary and with proper rate + limiting. Most of the time, a tab prompt can be be used. + +.. figure:: modal-type-window.png + :width: 425px + :height: 230px + :alt: Screenshot of a window prompt. + + Window alert prompt + +Tab Prompts +----------- + +Tab prompts are system prompts like window prompts. As opposed to window +prompts, they are tab modal and don't steal focus from the parent window. +Multiple tab prompts cannot be shown at the same time. When opening additional +prompts, they are FIFO queued. + +When the user closes the tab or navigates to a different URI, prompts associated +with the given tab are closed. +In this case an exception will be thrown: + +.. code-block:: + + /* + Exception: prompt aborted by user + undefined:425 + */ + +**When to use**: This prompt should be used for dialogs that were caused by web +content and thus should be bound to the scope and lifetime of a specific tab, +but should still look like secure browser UI. Examples are HTTP Auth prompt or +the dialog to add a new search provider for the current website. + +**Flag**: `MODAL_TYPE_TAB` + + +.. figure:: modal-type-tab.png + :width: 425px + :height: 230px + :alt: Screenshot of a tab prompt. + + Tab alert prompt + +Content Prompts +--------------- + +Content prompts are like tab prompts, but they belong to the web content. Thus, +they are positioned in the center of the selected browser. + +**When to use**: The prompt is triggered by or as a result of an action of web +content and is **not** intended to look like secure browser UI. + +**Flag**: `MODAL_TYPE_CONTENT` + +.. figure:: modal-type-content.png + :width: 425px + :height: 230px + :alt: Screenshot of a content prompt. + + Content alert prompt + + +Disabling tab/content modal prompts +----------------------------------- +You can disable tab and content modal prompts and get back window-modal for +individual prompts by setting the `prompts.modalType.<promptName>` preference to +`3`. diff --git a/toolkit/components/prompts/docs/nsIPromptService-reference.rst b/toolkit/components/prompts/docs/nsIPromptService-reference.rst new file mode 100644 index 0000000000..9879cd753a --- /dev/null +++ b/toolkit/components/prompts/docs/nsIPromptService-reference.rst @@ -0,0 +1,10 @@ +======================== +Prompt Service Reference +======================== + +This is the JSDoc from the Prompter.jsm implementation. You can find the full +interface definition in +`nsIPromptService.idl <https://searchfox.org/mozilla-central/source/toolkit/components/windowwatcher/nsIPromptService.idl>`_. + +.. js:autoclass:: Prompter + :members: diff --git a/toolkit/components/prompts/docs/nsIPromptService.rst b/toolkit/components/prompts/docs/nsIPromptService.rst new file mode 100644 index 0000000000..386572ef3f --- /dev/null +++ b/toolkit/components/prompts/docs/nsIPromptService.rst @@ -0,0 +1,195 @@ +============== +Prompt Service +============== + +The `nsIPromptService` provides methods for opening various types of prompts. +See the `interface documentation <nsIPromptService-reference.html>`_ for a list +of prompt types. +Every prompt method has 3 different versions: + +- **Prompt by window**: + This is considered the legacy way of prompting and only works if the window + you want to prompt for is in the same process. + Only supports window prompts. + +- **Prompt by browsing context (synchronous)**: + Use a browsing context as parent for the prompt. Works cross process from + parent and content process. + +- **Prompt by browsing context (asynchronous)**: + Returns a promise which resolves once the prompt closes. + + +The synchronous prompt methods use call by reference (XPCOM `inout` or `out`) to +return the updated prompt arguments to the caller. +When prompting async the arguments are passed in by value. Prompt results are +returned in an `nsIPropertyBag` when the Promise resolves. + + +.. note:: + If you don't provide a parent window or browsing context the prompt service + will fallback to a window prompt. + The same goes for browsing contexts of chrome windows, because there is no + clear association to a browser / tab. + + +Examples +-------- + +JavaScript Sync +~~~~~~~~~~~~~~~ + +Here is an example of opening a confirm prompt from JavaScript. We are in the +parent process and we want to show a tab prompt: + +.. code-block:: javascript + + // Get the browsing context for the currently selected tab + let browsingContext = gBrowser.selectedBrowser.browsingContext; + + // Specify prompt type, can be MODAL_TYPE_TAB, MODAL_TYPE_CONTENT, + // MODAL_TYPE_WINDOW + let modalType = Services.prompt.MODAL_TYPE_TAB; + + // Object for checkbox state to pass by reference. + let check = { value: false }; + + // Prompt synchronously and store result + let confirmed = Services.prompt.confirmCheckBC(browsingContext, modalType, + "My Title", "Hello, World!", "Check this box if you agree", check); + + // check.value now contains final checkbox state + // confirmed is a boolean which indicates whether the user pressed ok (true) + // or cancel (false) + console.debug("User checked checkbox?", check.value); + console.debug("User confirmed prompt?", confirmed); + + +JavaScript Async +~~~~~~~~~~~~~~~~ + +The same prompt as above, but called async: + +.. code-block:: javascript + + // Get the browsing context for the currently selected tab + let browsingContext = gBrowser.selectedBrowser.browsingContext; + + // Specify prompt type, can be MODAL_TYPE_TAB, MODAL_TYPE_CONTENT, + // MODAL_TYPE_WINDOW + let modalType = Services.prompt.MODAL_TYPE_TAB; + + // Note that the checkbox state variable is not an object in this case, + because we get the checkbox result via the result object. + let check = false; + + // Prompt asynchronously and await result + let propBag = await Services.prompt.asyncConfirmCheck(browsingContext, + modalType, + "My Title", + "Hello, World!", + "Check this box if you agree", + check); + + let ok = propBag.getProperty("ok"); + let checked = propBag.getProperty("checked"); + + // ok is the boolean indicating if the user clicked "ok" (true) or + // "cancel" (false). + // checked is a boolean indicating the final checkbox state + console.debug("User checked checkbox?", checked); + console.debug("User confirmed prompt?", ok); + + +C++ Sync +~~~~~~~~ + +.. code-block:: c++ + + nsCOMPtr<nsIPromptService> promptSvc = + do_GetService("@mozilla.org/prompter;1"); + + if(!promptSvc) { + // Error handling + return; + } + + // Assuming you have the browsing context as a member. + // You might need to get the browsing context from somewhere else. + BrowsingContext* bc = mBrowsingContext; + + bool ok; + bool checked = false; + + nsresult rv = promptSvc->confirmCheck(mBrowsingContext, + nsIPromptService::MODAL_TYPE_TAB, + "My Title"_ns + "Hello, World!"_ns, + "Check this box if you agree"_ns, + &checked, &ok); + + // ok is the boolean indicating if the user clicked "ok" (true) or + // "cancel" (false). + // checked is a boolean indicating the final checkbox state + +C++ Async +~~~~~~~~~ + +.. code-block:: c++ + + nsCOMPtr<nsIPromptService> promptSvc = + do_GetService("@mozilla.org/prompter;1"); + + if(!promptSvc) { + // Error handling + return; + } + + bool checked = false; + Promise* promise; + + // Assuming you have the browsing context as a member. + // You might need to get the browsing context from somewhere else. + BrowsingContext* bc = mBrowsingContext; + + // As opposed to the sync case, here we pass the checked flag by value + nsresult rv = promptSvc->confirmCheckAsync(mBrowsingContext, + nsIPromptService::MODAL_TYPE_TAB, "My Title"_ns, + "Hello, World!"_ns, + "Check this box if you agree"_ns, + checked, promise); + + // Attach a promise handler + RefPtr<PromptHandler> handler = new PromptHandler(promise); + promise->AppendNativeHandler(handler); + +Then, in your promise handler callback function: + +.. code-block:: c++ + + void PromptHandler::ResolvedCallback(JSContext* aCx, + JS::Handle<JS::Value> aValue) { + JS::Rooted<JSObject*> detailObj(aCx, &aValue.toObject()); + + // Convert the JSObject back to a property bag + nsresult rv; + nsCOMPtr<nsIPropertyBag2> propBag; + rv = UnwrapArg<nsIPropertyBag2>(aCx, detailObj, getter_AddRefs(propBag)); + if (NS_FAILED(rv)) return; + + bool ok; + bool checked; + propBag->GetPropertyAsBool(u"ok"_ns, &ok); + propBag->GetPropertyAsBool(u"checked"_ns, &checked); + + // ok is the boolean indicating if the user clicked "ok" (true) or + // "cancel" (false). + // checked is a boolean indicating the final checkbox state. + } + + + + + +For a full list of prompt methods check +`nsIPromptService reference <nsIPromptService-reference.html>`_. diff --git a/toolkit/components/prompts/jar.mn b/toolkit/components/prompts/jar.mn new file mode 100644 index 0000000000..ed674bc43e --- /dev/null +++ b/toolkit/components/prompts/jar.mn @@ -0,0 +1,13 @@ +# 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/. + +toolkit.jar: + content/global/adjustableTitle.js (content/adjustableTitle.js) + content/global/commonDialog.js (content/commonDialog.js) + content/global/commonDialog.xhtml (content/commonDialog.xhtml) + content/global/commonDialog.css (content/commonDialog.css) + content/global/selectDialog.js (content/selectDialog.js) + content/global/selectDialog.xhtml (content/selectDialog.xhtml) + content/global/tabprompts.css (content/tabprompts.css) + content/global/tabprompts.jsm (content/tabprompts.jsm) diff --git a/toolkit/components/prompts/moz.build b/toolkit/components/prompts/moz.build new file mode 100644 index 0000000000..17fb416f06 --- /dev/null +++ b/toolkit/components/prompts/moz.build @@ -0,0 +1,24 @@ +# -*- 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/. + +with Files("**"): + BUG_COMPONENT = ("Toolkit", "Notifications and Alerts") + +DIRS += ["src"] + +SPHINX_TREES["prompts"] = "docs" + +with Files("docs/**"): + SCHEDULES.exclusive = ["docs"] + +TESTING_JS_MODULES += [ + "test/PromptTestUtils.jsm", +] + +MOCHITEST_MANIFESTS += ["test/mochitest.ini"] +MOCHITEST_CHROME_MANIFESTS += ["test/chrome.ini"] + +JAR_MANIFESTS += ["jar.mn"] diff --git a/toolkit/components/prompts/src/CommonDialog.jsm b/toolkit/components/prompts/src/CommonDialog.jsm new file mode 100644 index 0000000000..8081bb34eb --- /dev/null +++ b/toolkit/components/prompts/src/CommonDialog.jsm @@ -0,0 +1,386 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var EXPORTED_SYMBOLS = ["CommonDialog"]; + +const lazy = {}; +ChromeUtils.defineModuleGetter( + lazy, + "EnableDelayHelper", + "resource://gre/modules/SharedPromptUtils.jsm" +); + +const { AppConstants } = ChromeUtils.importESModule( + "resource://gre/modules/AppConstants.sys.mjs" +); + +function CommonDialog(args, ui) { + this.args = args; + this.ui = ui; + this.initialFocusPromise = new Promise(resolve => { + this.initialFocusResolver = resolve; + }); +} + +CommonDialog.prototype = { + args: null, + ui: null, + + hasInputField: true, + numButtons: undefined, + iconClass: undefined, + soundID: undefined, + focusTimer: null, + initialFocusPromise: null, + initialFocusResolver: null, + + /** + * @param [commonDialogEl] - Dialog element from commonDialog.xhtml, + * null for TabModalPrompts. + */ + async onLoad(commonDialogEl = null) { + let isEmbedded = !!commonDialogEl?.ownerGlobal.docShell.chromeEventHandler; + + switch (this.args.promptType) { + case "alert": + case "alertCheck": + this.hasInputField = false; + this.numButtons = 1; + this.iconClass = ["alert-icon"]; + this.soundID = Ci.nsISound.EVENT_ALERT_DIALOG_OPEN; + break; + case "confirmCheck": + case "confirm": + this.hasInputField = false; + this.numButtons = 2; + this.iconClass = ["question-icon"]; + this.soundID = Ci.nsISound.EVENT_CONFIRM_DIALOG_OPEN; + break; + case "confirmEx": + var numButtons = 0; + if (this.args.button0Label) { + numButtons++; + } + if (this.args.button1Label) { + numButtons++; + } + if (this.args.button2Label) { + numButtons++; + } + if (this.args.button3Label) { + numButtons++; + } + if (numButtons == 0) { + throw new Error("A dialog with no buttons? Can not haz."); + } + this.numButtons = numButtons; + this.hasInputField = false; + this.iconClass = ["question-icon"]; + this.soundID = Ci.nsISound.EVENT_CONFIRM_DIALOG_OPEN; + break; + case "prompt": + this.numButtons = 2; + this.iconClass = ["question-icon"]; + this.soundID = Ci.nsISound.EVENT_PROMPT_DIALOG_OPEN; + this.initTextbox("login", this.args.value); + // Clear the label, since this isn't really a username prompt. + this.ui.loginLabel.setAttribute("value", ""); + // Ensure the labeling for the prompt is correct. + this.ui.loginTextbox.setAttribute("aria-labelledby", "infoBody"); + break; + case "promptUserAndPass": + this.numButtons = 2; + this.iconClass = ["authentication-icon", "question-icon"]; + this.soundID = Ci.nsISound.EVENT_PROMPT_DIALOG_OPEN; + this.initTextbox("login", this.args.user); + this.initTextbox("password1", this.args.pass); + break; + case "promptPassword": + this.numButtons = 2; + this.iconClass = ["authentication-icon", "question-icon"]; + this.soundID = Ci.nsISound.EVENT_PROMPT_DIALOG_OPEN; + this.initTextbox("password1", this.args.pass); + // Clear the label, since the message presumably indicates its purpose. + this.ui.password1Label.setAttribute("value", ""); + break; + default: + Cu.reportError( + "commonDialog opened for unknown type: " + this.args.promptType + ); + throw new Error("unknown dialog type"); + } + + if (commonDialogEl) { + commonDialogEl.setAttribute( + "windowtype", + "prompt:" + this.args.promptType + ); + } + + // set the document title + let title = this.args.title; + let infoTitle = this.ui.infoTitle; + infoTitle.appendChild(infoTitle.ownerDocument.createTextNode(title)); + + // Specific check to prevent showing the title on the old content prompts for macOS. + // This should be removed when the old content prompts are removed. + let contentSubDialogPromptEnabled = Services.prefs.getBoolPref( + "prompts.contentPromptSubDialog" + ); + let isOldContentPrompt = + !contentSubDialogPromptEnabled && + this.args.modalType == Ci.nsIPrompt.MODAL_TYPE_CONTENT; + + // After making these preventative checks, we can determine to show it if we're on + // macOS (where there is no titlebar) or if the prompt is a common dialog document + // and has been embedded (has a chromeEventHandler). + infoTitle.hidden = + isOldContentPrompt || !(AppConstants.platform === "macosx" || isEmbedded); + + if (commonDialogEl) { + commonDialogEl.ownerDocument.title = title; + } + + // Set button labels and visibility + // + // This assumes that button0 defaults to a visible "ok" button, and + // button1 defaults to a visible "cancel" button. The other 2 buttons + // have no default labels (and are hidden). + switch (this.numButtons) { + case 4: + this.setLabelForNode(this.ui.button3, this.args.button3Label); + this.ui.button3.hidden = false; + // fall through + case 3: + this.setLabelForNode(this.ui.button2, this.args.button2Label); + this.ui.button2.hidden = false; + // fall through + case 2: + // Defaults to a visible "cancel" button + if (this.args.button1Label) { + this.setLabelForNode(this.ui.button1, this.args.button1Label); + } + break; + + case 1: + this.ui.button1.hidden = true; + break; + } + // Defaults to a visible "ok" button + if (this.args.button0Label) { + this.setLabelForNode(this.ui.button0, this.args.button0Label); + } + + // display the main text + let croppedMessage = ""; + if (this.args.text) { + // Bug 317334 - crop string length as a workaround. + croppedMessage = this.args.text.substr(0, 10000); + // TabModalPrompts don't have an infoRow to hide / not hide here, so + // guard on that here so long as they are in use. + if (this.ui.infoRow) { + this.ui.infoRow.hidden = false; + } + } + let infoBody = this.ui.infoBody; + infoBody.appendChild(infoBody.ownerDocument.createTextNode(croppedMessage)); + + let label = this.args.checkLabel; + if (label) { + // Only show the checkbox if label has a value. + this.ui.checkboxContainer.hidden = false; + this.ui.checkboxContainer.clientTop; // style flush to assure binding is attached + this.setLabelForNode(this.ui.checkbox, label); + this.ui.checkbox.checked = this.args.checked; + } + + // set the icon + let icon = this.ui.infoIcon; + if (icon) { + this.iconClass.forEach((el, idx, arr) => icon.classList.add(el)); + } + + // set default result to cancelled + this.args.ok = false; + this.args.buttonNumClicked = 1; + + // Set the default button + let b = this.args.defaultButtonNum || 0; + let button = this.ui["button" + b]; + + if (commonDialogEl) { + commonDialogEl.defaultButton = ["accept", "cancel", "extra1", "extra2"][ + b + ]; + } else { + button.setAttribute("default", "true"); + } + + if (!isEmbedded && !this.ui.promptContainer?.hidden) { + // Set default focus and select textbox contents if applicable. If we're + // embedded SubDialogManager will call setDefaultFocus for us. + this.setDefaultFocus(true); + } + + if (this.args.enableDelay) { + this.delayHelper = new lazy.EnableDelayHelper({ + disableDialog: () => this.setButtonsEnabledState(false), + enableDialog: () => this.setButtonsEnabledState(true), + focusTarget: this.ui.focusTarget, + }); + } + + // Play a sound (unless we're showing a content prompt -- don't want those + // to feel like OS prompts). + try { + if (commonDialogEl && this.soundID && !this.args.openedWithTabDialog) { + Cc["@mozilla.org/sound;1"] + .getService(Ci.nsISound) + .playEventSound(this.soundID); + } + } catch (e) { + Cu.reportError("Couldn't play common dialog event sound: " + e); + } + + if (commonDialogEl) { + if (isEmbedded) { + // If we delayed default focus above, wait for it to be ready before + // sending the notification. + await this.initialFocusPromise; + } + Services.obs.notifyObservers(this.ui.prompt, "common-dialog-loaded"); + } else { + // ui.promptContainer is the <tabmodalprompt> element. + Services.obs.notifyObservers( + this.ui.promptContainer, + "tabmodal-dialog-loaded" + ); + } + }, + + setLabelForNode(aNode, aLabel) { + // This is for labels which may contain embedded access keys. + // If we end in (&X) where X represents the access key, optionally preceded + // by spaces and/or followed by the ':' character, store the access key and + // remove the access key placeholder + leading spaces from the label. + // Otherwise a character preceded by one but not two &s is the access key. + // Store it and remove the &. + + // Note that if you change the following code, see the comment of + // nsTextBoxFrame::UpdateAccessTitle. + var accessKey = null; + if (/ *\(\&([^&])\)(:?)$/.test(aLabel)) { + aLabel = RegExp.leftContext + RegExp.$2; + accessKey = RegExp.$1; + } else if (/^([^&]*)\&(([^&]).*$)/.test(aLabel)) { + aLabel = RegExp.$1 + RegExp.$2; + accessKey = RegExp.$3; + } + + // && is the magic sequence to embed an & in your label. + aLabel = aLabel.replace(/\&\&/g, "&"); + aNode.label = aLabel; + + // XXXjag bug 325251 + // Need to set this after aNode.setAttribute("value", aLabel); + if (accessKey) { + aNode.accessKey = accessKey; + } + }, + + initTextbox(aName, aValue) { + this.ui[aName + "Container"].hidden = false; + this.ui[aName + "Textbox"].setAttribute( + "value", + aValue !== null ? aValue : "" + ); + }, + + setButtonsEnabledState(enabled) { + this.ui.button0.disabled = !enabled; + // button1 (cancel) remains enabled. + this.ui.button2.disabled = !enabled; + this.ui.button3.disabled = !enabled; + }, + + setDefaultFocus(isInitialLoad) { + let b = this.args.defaultButtonNum || 0; + let button = this.ui["button" + b]; + + if (!this.hasInputField) { + let isOSX = "nsILocalFileMac" in Ci; + // If the infoRow exists and is is hidden, then the infoBody is also hidden, + // which means it can't be focused. At that point, we fall back to focusing + // the default button, regardless of platform. + if (isOSX && !(this.ui.infoRow && this.ui.infoRow.hidden)) { + this.ui.infoBody.focus(); + } else { + button.focus({ focusVisible: false }); + } + } else if (this.args.promptType == "promptPassword") { + // When the prompt is initialized, focus and select the textbox + // contents. Afterwards, only focus the textbox. + if (isInitialLoad) { + this.ui.password1Textbox.select(); + } else { + this.ui.password1Textbox.focus(); + } + } else if (isInitialLoad) { + this.ui.loginTextbox.select(); + } else { + this.ui.loginTextbox.focus(); + } + + if (isInitialLoad) { + this.initialFocusResolver(); + } + }, + + onCheckbox() { + this.args.checked = this.ui.checkbox.checked; + }, + + onButton0() { + this.args.promptActive = false; + this.args.ok = true; + this.args.buttonNumClicked = 0; + + let username = this.ui.loginTextbox.value; + let password = this.ui.password1Textbox.value; + + // Return textfield values + switch (this.args.promptType) { + case "prompt": + this.args.value = username; + break; + case "promptUserAndPass": + this.args.user = username; + this.args.pass = password; + break; + case "promptPassword": + this.args.pass = password; + break; + } + }, + + onButton1() { + this.args.promptActive = false; + this.args.buttonNumClicked = 1; + }, + + onButton2() { + this.args.promptActive = false; + this.args.buttonNumClicked = 2; + }, + + onButton3() { + this.args.promptActive = false; + this.args.buttonNumClicked = 3; + }, + + abortPrompt() { + this.args.promptActive = false; + this.args.promptAborted = true; + }, +}; diff --git a/toolkit/components/prompts/src/Prompter.jsm b/toolkit/components/prompts/src/Prompter.jsm new file mode 100644 index 0000000000..caeef99f15 --- /dev/null +++ b/toolkit/components/prompts/src/Prompter.jsm @@ -0,0 +1,1818 @@ +/* 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"; + +const { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); +// This is redefined below, for strange and unfortunate reasons. +var { PromptUtils } = ChromeUtils.import( + "resource://gre/modules/SharedPromptUtils.jsm" +); + +const { + MODAL_TYPE_TAB, + MODAL_TYPE_CONTENT, + MODAL_TYPE_WINDOW, + MODAL_TYPE_INTERNAL_WINDOW, +} = Ci.nsIPrompt; + +const COMMON_DIALOG = "chrome://global/content/commonDialog.xhtml"; +const SELECT_DIALOG = "chrome://global/content/selectDialog.xhtml"; + +function Prompter() { + // Note that EmbedPrompter clones this implementation. +} + +/** + * Implements nsIPromptService and nsIPromptFactory + * @class Prompter + */ +Prompter.prototype = { + classID: Components.ID("{1c978d25-b37f-43a8-a2d6-0c7a239ead87}"), + QueryInterface: ChromeUtils.generateQI([ + "nsIPromptFactory", + "nsIPromptService", + ]), + + /* ---------- private members ---------- */ + + pickPrompter(options) { + return new ModalPrompter(options); + }, + + /* ---------- nsIPromptFactory ---------- */ + + getPrompt(domWin, iid) { + // This is still kind of dumb; the C++ code delegated to login manager + // here, which in turn calls back into us via nsIPromptService. + if (iid.equals(Ci.nsIAuthPrompt2) || iid.equals(Ci.nsIAuthPrompt)) { + try { + let pwmgr = Cc[ + "@mozilla.org/passwordmanager/authpromptfactory;1" + ].getService(Ci.nsIPromptFactory); + return pwmgr.getPrompt(domWin, iid); + } catch (e) { + Cu.reportError( + "nsPrompter: Delegation to password manager failed: " + e + ); + } + } + + let p = new ModalPrompter({ domWin }); + p.QueryInterface(iid); + return p; + }, + + /* ---------- nsIPromptService ---------- */ + + /** + * Puts up an alert dialog with an OK button. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + */ + alert(domWin, title, text) { + let p = this.pickPrompter({ domWin }); + p.alert(title, text); + }, + + /** + * Puts up an alert dialog with an OK button. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + */ + alertBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + p.alert(...promptArgs); + }, + + /** + * Puts up an alert dialog with an OK button. + * + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @returns {Promise} A promise which resolves when the prompt is dismissed. + */ + asyncAlert(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.alert(...promptArgs); + }, + + /** + * Puts up an alert dialog with an OK button and a labeled checkbox. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} checkLabel - Text to appear with the checkbox. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + */ + alertCheck(domWin, title, text, checkLabel, checkValue) { + let p = this.pickPrompter({ domWin }); + p.alertCheck(title, text, checkLabel, checkValue); + }, + + /** + * Puts up an alert dialog with an OK button and a labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} checkLabel - Text to appear with the checkbox. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + */ + alertCheckBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + p.alertCheck(...promptArgs); + }, + + /** + * Puts up an alert dialog with an OK button and a labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} checkLabel - Text to appear with the checkbox. + * @param {Boolean} checkValue - The initial checked state of the checkbox. + * @returns {Promise<nsIPropertyBag<{ checked: Boolean }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncAlertCheck(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.alertCheck(...promptArgs); + }, + + /** + * Puts up a dialog with OK and Cancel buttons. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @returns {Boolean} true for OK, false for Cancel. + */ + confirm(domWin, title, text) { + let p = this.pickPrompter({ domWin }); + return p.confirm(title, text); + }, + + /** + * Puts up a dialog with OK and Cancel buttons. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @returns {Boolean} true for OK, false for Cancel. + */ + confirmBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.confirm(...promptArgs); + }, + + /** + * Puts up a dialog with OK and Cancel buttons. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @returns {Promise<nsIPropertyBag<{ ok: Boolean }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncConfirm(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.confirm(...promptArgs); + }, + + /** + * Puts up a dialog with OK and Cancel buttons and a labeled checkbox. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} checkLabel - Text to appear with the checkbox. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + */ + confirmCheck(domWin, title, text, checkLabel, checkValue) { + let p = this.pickPrompter({ domWin }); + return p.confirmCheck(title, text, checkLabel, checkValue); + }, + + /** + * Puts up a dialog with OK and Cancel buttons and a labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} checkLabel - Text to appear with the checkbox. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + * @returns {Boolean} true for OK, false for Cancel + */ + confirmCheckBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.confirmCheck(...promptArgs); + }, + + /** + * Puts up a dialog with OK and Cancel buttons and a labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} checkLabel - Text to appear with the checkbox. + * @param {Boolean} checkValue - The initial checked state of the checkbox. + * @returns {Promise<nsIPropertyBag<{ ok: Boolean, checked: Boolean }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncConfirmCheck(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.confirmCheck(...promptArgs); + }, + + /** + * Puts up a dialog with up to 3 buttons and an optional, labeled checkbox. + * + * Buttons are numbered 0 - 2. Button 0 is the default button unless one of + * the Button Default Flags is specified. + * + * A button may use a predefined title, specified by one of the Button Title + * Flags values. Each title value can be multiplied by a position value to + * assign the title to a particular button. If BUTTON_TITLE_IS_STRING is + * used for a button, the string parameter for that button will be used. If + * the value for a button position is zero, the button will not be shown. + * + * In general, flags is constructed per the following example: + * + * flags = (BUTTON_POS_0) * (BUTTON_TITLE_AAA) + + * (BUTTON_POS_1) * (BUTTON_TITLE_BBB) + + * BUTTON_POS_1_DEFAULT; + * + * where "AAA" and "BBB" correspond to one of the button titles. + * + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Number} flags - A combination of Button Flags. + * @param {String} button0 - Used when button 0 uses TITLE_IS_STRING. + * @param {String} button1 - Used when button 1 uses TITLE_IS_STRING. + * @param {String} button2 - Used when button 2 uses TITLE_IS_STRING. + * @param {String} checkLabel - Text to appear with the checkbox. + * Null if no checkbox. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method + * is called and the final checked state after this method returns. + * @returns {Number} The index of the button pressed. + */ + confirmEx( + domWin, + title, + text, + flags, + button0, + button1, + button2, + checkLabel, + checkValue + ) { + let p = this.pickPrompter({ domWin }); + return p.confirmEx( + title, + text, + flags, + button0, + button1, + button2, + checkLabel, + checkValue + ); + }, + + /** + * Puts up a dialog with up to 3 buttons and an optional, labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Number} flags - A combination of Button Flags. + * @param {String} button0 - Used when button 0 uses TITLE_IS_STRING. + * @param {String} button1 - Used when button 1 uses TITLE_IS_STRING. + * @param {String} button2 - Used when button 2 uses TITLE_IS_STRING. + * @param {String} checkLabel - Text to appear with the checkbox. + * Null if no checkbox. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + * @returns {Number} The index of the button pressed. + */ + confirmExBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.confirmEx(...promptArgs); + }, + + /** + * Puts up a dialog with up to 3 buttons and an optional, labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Number} flags - A combination of Button Flags. + * @param {String} button0 - Used when button 0 uses TITLE_IS_STRING. + * @param {String} button1 - Used when button 1 uses TITLE_IS_STRING. + * @param {String} button2 - Used when button 2 uses TITLE_IS_STRING. + * @param {String} checkLabel - Text to appear with the checkbox. + * Null if no checkbox. + * @param {Boolean} checkValue - The initial checked state of the checkbox. + * @param {Object} [extraArgs] - Extra arguments for the prompt metadata. + * @returns {Promise<nsIPropertyBag<{ buttonNumClicked: Number, checked: Boolean }>>} + */ + asyncConfirmEx(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.confirmEx(...promptArgs); + }, + + /** + * Puts up a dialog with an edit field and an optional, labeled checkbox. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Object} value - Contains the default value for the dialog field + * when this method is called (null value is ok). Upon return, if + * the user pressed OK, then this parameter contains a newly + * allocated string value. + * Otherwise, the parameter's value is unmodified. + * @param {String} checkLabel - Text to appear with the checkbox. + * If null, check box will not be shown. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + * @returns {Boolean} true for OK, false for Cancel. + */ + prompt(domWin, title, text, value, checkLabel, checkValue) { + let p = this.pickPrompter({ domWin }); + return p.nsIPrompt_prompt(title, text, value, checkLabel, checkValue); + }, + + /** + * Puts up a dialog with an edit field and an optional, labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Object} value - Contains the default value for the dialog field + * when this method is called (null value is ok). Upon return, if + * the user pressed OK, then this parameter contains a newly + * allocated string value. + * Otherwise, the parameter's value is unmodified. + * @param {String} checkLabel - Text to appear with the checkbox. + * If null, check box will not be shown. + * @param {Object} checkValue - Contains the initial checked state of the + * checkbox when this method is called and the final checked state + * after this method returns. + * @returns {Boolean} true for OK, false for Cancel. + */ + promptBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.nsIPrompt_prompt(...promptArgs); + }, + + /** + * Puts up a dialog with an edit field and an optional, labeled checkbox. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} value - The default value for the dialog text field. + * @param {String} checkLabel - Text to appear with the checkbox. + * If null, check box will not be shown. + * @param {Boolean} checkValue - The initial checked state of the checkbox. + * @returns {Promise<nsIPropertyBag<{ ok: Boolean, checked: Boolean, value: String }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncPrompt(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.nsIPrompt_prompt(...promptArgs); + }, + + /** + * Puts up a dialog with an edit field and a password field. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Object} user - Contains the default value for the username + * field when this method is called (null value is ok). + * Upon return, if the user pressed OK, then this parameter contains + * a newly allocated string value. Otherwise, the parameter's value + * is unmodified. + * @param {Object} pass - Contains the default value for the password field + * when this method is called (null value is ok). Upon return, if the + * user pressed OK, this parameter contains a newly allocated string + * value. Otherwise, the parameter's value is unmodified. + * @returns {Boolean} true for OK, false for Cancel. + */ + promptUsernameAndPassword(domWin, title, text, user, pass) { + let p = this.pickPrompter({ domWin }); + return p.nsIPrompt_promptUsernameAndPassword(null, title, text, user, pass); + }, + + /** + * Puts up a dialog with an edit field and a password field. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Object} user - Contains the default value for the username + * field when this method is called (null value is ok). + * Upon return, if the user pressed OK, then this parameter contains + * a newly allocated string value. Otherwise, the parameter's value + * is unmodified. + * @param {Object} pass - Contains the default value for the password field + * when this method is called (null value is ok). Upon return, if the + * user pressed OK, this parameter contains a newly allocated string + * value. Otherwise, the parameter's value is unmodified. + * @returns {Boolean} true for OK, false for Cancel. + */ + promptUsernameAndPasswordBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.nsIPrompt_promptUsernameAndPassword(null, ...promptArgs); + }, + + /** + * Puts up a dialog with an edit field and a password field. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} user - Default value for the username field. + * @param {String} pass - Contains the default value for the password field. + * @returns {Promise<nsIPropertyBag<{ ok: Boolean, user: String, pass: String }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncPromptUsernameAndPassword(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.nsIPrompt_promptUsernameAndPassword(null, ...promptArgs); + }, + + /** + * Puts up a dialog with a password field. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Object} pass - Contains the default value for the password field + * when this method is called (null value is ok). Upon return, if the + * user pressed OK, this parameter contains a newly allocated string + * value. Otherwise, the parameter's value is unmodified. + * @returns {Boolean} true for OK, false for Cancel. + */ + promptPassword(domWin, title, text, pass) { + let p = this.pickPrompter({ domWin }); + return p.nsIPrompt_promptPassword( + null, // no channel. + title, + text, + pass + ); + }, + + /** + * Puts up a dialog with a password field. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {Object} pass - Contains the default value for the password field + * when this method is called (null value is ok). Upon return, if the + * user pressed OK, this parameter contains a newly allocated string + * value. Otherwise, the parameter's value is unmodified. + * @returns {Boolean} true for OK, false for Cancel. + */ + promptPasswordBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.nsIPrompt_promptPassword(null, ...promptArgs); + }, + + /** + * Puts up a dialog with a password field. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String} pass - Contains the default value for the password field. + * @returns {Promise<nsIPropertyBag<{ ok: Boolean, pass: String }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncPromptPassword(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.nsIPrompt_promptPassword(null, ...promptArgs); + }, + + /** + * Puts up a dialog box which has a list box of strings from which the user + * may make a single selection. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String[]} list - The list of strings to display. + * @param {Object} selected - Contains the index of the selected item in the + * list when this method returns true. + * @returns {Boolean} true for OK, false for Cancel. + */ + select(domWin, title, text, list, selected) { + let p = this.pickPrompter({ domWin }); + return p.select(title, text, list, selected); + }, + + /** + * Puts up a dialog box which has a list box of strings from which the user + * may make a single selection. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String[]} list - The list of strings to display. + * @param {Object} selected - Contains the index of the selected item in the + * list when this method returns true. + * @returns {Boolean} true for OK, false for Cancel. + */ + selectBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.select(...promptArgs); + }, + + /** + * Puts up a dialog box which has a list box of strings from which the user + * may make a single selection. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} title - Text to appear in the title of the dialog. + * @param {String} text - Text to appear in the body of the dialog. + * @param {String[]} list - The list of strings to display. + * @returns {Promise<nsIPropertyBag<{ selected: Number, ok: Boolean }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncSelect(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.select(...promptArgs); + }, + + /** + * Requests a username and a password. Shows a dialog with username and + * password field, depending on flags also a domain field. + * @param {mozIDOMWindowProxy} domWin - The parent window or null. + * @param {nsIChannel} channel - The channel that requires authentication. + * @param {Number} level - Security level of the credential transmission. + * Any of nsIAuthPrompt2.<LEVEL_NONE|LEVEL_PW_ENCRYPTED|LEVEL_SECURE> + * @param {nsIAuthInformation} authInfo - Authentication information object. + * @returns {Boolean} + * true: Authentication can proceed using the values + * in the authInfo object. + * false: Authentication should be cancelled, usually because the + * user did not provide username/password. + */ + promptAuth(domWin, channel, level, authInfo) { + let p = this.pickPrompter({ domWin }); + return p.promptAuth(channel, level, authInfo); + }, + + /** + * Requests a username and a password. Shows a dialog with username and + * password field, depending on flags also a domain field. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {nsIChannel} channel - The channel that requires authentication. + * @param {Number} level - Security level of the credential transmission. + * Any of nsIAuthPrompt2.<LEVEL_NONE|LEVEL_PW_ENCRYPTED|LEVEL_SECURE> + * @param {nsIAuthInformation} authInfo - Authentication information object. + * @returns {Boolean} + * true: Authentication can proceed using the values + * in the authInfo object. + * false: Authentication should be cancelled, usually because the + * user did not provide username/password. + */ + promptAuthBC(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType }); + return p.promptAuth(...promptArgs); + }, + + /** + * Requests a username and a password. Shows a dialog with username and + * password field, depending on flags also a domain field. + * @param {BrowsingContext} browsingContext - The browsing context the + * prompt should be opened for. + * @param {Number} modalType - The modal type of the prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {nsIChannel} channel - The channel that requires authentication. + * @param {Number} level - Security level of the credential transmission. + * Any of nsIAuthPrompt2.<LEVEL_NONE|LEVEL_PW_ENCRYPTED|LEVEL_SECURE> + * @param {nsIAuthInformation} authInfo - Authentication information object. + * @returns {Promise<nsIPropertyBag<{ ok: Boolean }>>} + * A promise which resolves when the prompt is dismissed. + */ + asyncPromptAuth(browsingContext, modalType, ...promptArgs) { + let p = this.pickPrompter({ browsingContext, modalType, async: true }); + return p.promptAuth(...promptArgs); + }, +}; + +// Common utils not specific to a particular prompter style. +var InternalPromptUtils = { + getLocalizedString(key, formatArgs) { + if (formatArgs) { + return this.strBundle.formatStringFromName(key, formatArgs); + } + return this.strBundle.GetStringFromName(key); + }, + + confirmExHelper(flags, button0, button1, button2) { + const BUTTON_DEFAULT_MASK = 0x03000000; + let defaultButtonNum = (flags & BUTTON_DEFAULT_MASK) >> 24; + let isDelayEnabled = flags & Ci.nsIPrompt.BUTTON_DELAY_ENABLE; + + // Flags can be used to select a specific pre-defined button label or + // a caller-supplied string (button0/button1/button2). If no flags are + // set for a button, then the button won't be shown. + let argText = [button0, button1, button2]; + let buttonLabels = [null, null, null]; + for (let i = 0; i < 3; i++) { + let buttonLabel; + switch (flags & 0xff) { + case Ci.nsIPrompt.BUTTON_TITLE_OK: + buttonLabel = this.getLocalizedString("OK"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_CANCEL: + buttonLabel = this.getLocalizedString("Cancel"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_YES: + buttonLabel = this.getLocalizedString("Yes"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_NO: + buttonLabel = this.getLocalizedString("No"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_SAVE: + buttonLabel = this.getLocalizedString("Save"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_DONT_SAVE: + buttonLabel = this.getLocalizedString("DontSave"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_REVERT: + buttonLabel = this.getLocalizedString("Revert"); + break; + case Ci.nsIPrompt.BUTTON_TITLE_IS_STRING: + buttonLabel = argText[i]; + break; + } + if (buttonLabel) { + buttonLabels[i] = buttonLabel; + } + flags >>= 8; + } + + return [ + buttonLabels[0], + buttonLabels[1], + buttonLabels[2], + defaultButtonNum, + isDelayEnabled, + ]; + }, + + getAuthInfo(authInfo) { + let username, password; + + let flags = authInfo.flags; + if (flags & Ci.nsIAuthInformation.NEED_DOMAIN && authInfo.domain) { + username = authInfo.domain + "\\" + authInfo.username; + } else { + username = authInfo.username; + } + + password = authInfo.password; + + return [username, password]; + }, + + setAuthInfo(authInfo, username, password) { + let flags = authInfo.flags; + if (flags & Ci.nsIAuthInformation.NEED_DOMAIN) { + // Domain is separated from username by a backslash + let idx = username.indexOf("\\"); + if (idx == -1) { + authInfo.username = username; + } else { + authInfo.domain = username.substring(0, idx); + authInfo.username = username.substring(idx + 1); + } + } else { + authInfo.username = username; + } + authInfo.password = password; + }, + + /** + * Strip out things like userPass and path for display. + */ + getFormattedHostname(uri) { + return uri.scheme + "://" + uri.hostPort; + }, + + // Note: there's a similar implementation in the login manager. + getAuthTarget(aChannel, aAuthInfo) { + let displayHost, realm; + + // If our proxy is demanding authentication, don't use the + // channel's actual destination. + if (aAuthInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY) { + if (!(aChannel instanceof Ci.nsIProxiedChannel)) { + throw new Error("proxy auth needs nsIProxiedChannel"); + } + + let info = aChannel.proxyInfo; + if (!info) { + throw new Error("proxy auth needs nsIProxyInfo"); + } + + // Proxies don't have a scheme, but we'll use "moz-proxy://" + // so that it's more obvious what the login is for. + let idnService = Cc["@mozilla.org/network/idn-service;1"].getService( + Ci.nsIIDNService + ); + displayHost = + "moz-proxy://" + + idnService.convertUTF8toACE(info.host) + + ":" + + info.port; + realm = aAuthInfo.realm; + if (!realm) { + realm = displayHost; + } + + return { realm, displayHost }; + } + + displayHost = this.getFormattedHostname(aChannel.URI); + let displayHostOnly = aChannel.URI.hostPort; + + // If a HTTP WWW-Authenticate header specified a realm, that value + // will be available here. If it wasn't set or wasn't HTTP, we'll use + // the formatted hostname instead. + realm = aAuthInfo.realm; + if (!realm) { + realm = displayHost; + } + + return { realm, displayHostOnly, displayHost }; + }, + + makeAuthMessage(prompt, channel, authInfo) { + if (prompt.modalType != MODAL_TYPE_TAB) { + return this._legacyMakeAuthMessage(channel, authInfo); + } + + let isProxy = authInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY; + let isPassOnly = authInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD; + let isCrossOrig = + authInfo.flags & Ci.nsIAuthInformation.CROSS_ORIGIN_SUB_RESOURCE; + let username = authInfo.username; + + // We use the realm and displayHost only for proxy auth, + // and the displayHostOnly (hostPort) only for x-origin auth prompts. + // Otherwise we rely on the title of the dialog displaying the correct + // title. + let { displayHost, realm, displayHostOnly } = this.getAuthTarget( + channel, + authInfo + ); + + if (isProxy) { + // The realm is server-controlled. Trim it if it's very long, to + // avoid the dialog becoming unusable. + // For background, see https://bugzilla.mozilla.org/show_bug.cgi?id=244273 + if (realm.length > 150) { + realm = realm.substring(0, 150); + // Append "..." (or localized equivalent). + realm += this.ellipsis; + } + + return this.getLocalizedString("EnterLoginForProxy3", [ + realm, + displayHost, + ]); + } + if (isPassOnly) { + return this.getLocalizedString("EnterPasswordOnlyFor", [username]); + } + if (isCrossOrig) { + return this.getLocalizedString("EnterCredentialsCrossOrigin", [ + displayHostOnly, + ]); + } + return this.getLocalizedString("EnterCredentials"); + }, + + _legacyMakeAuthMessage(channel, authInfo) { + let isProxy = authInfo.flags & Ci.nsIAuthInformation.AUTH_PROXY; + let isPassOnly = authInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD; + let isCrossOrig = + authInfo.flags & Ci.nsIAuthInformation.CROSS_ORIGIN_SUB_RESOURCE; + + let username = authInfo.username; + let { displayHost, realm } = this.getAuthTarget(channel, authInfo); + + // Suppress "the site says: $realm" when we synthesized a missing realm. + if (!authInfo.realm && !isProxy) { + realm = ""; + } + + // The realm is server-controlled. Trim it if it's very long, to + // avoid the dialog becoming unusable. + // For background, see https://bugzilla.mozilla.org/show_bug.cgi?id=244273 + if (realm.length > 150) { + realm = realm.substring(0, 150); + // Append "..." (or localized equivalent). + realm += this.ellipsis; + } + + let text; + if (isProxy) { + text = this.getLocalizedString("EnterLoginForProxy3", [ + realm, + displayHost, + ]); + } else if (isPassOnly) { + text = this.getLocalizedString("EnterPasswordFor", [ + username, + displayHost, + ]); + } else if (isCrossOrig) { + text = this.getLocalizedString("EnterUserPasswordForCrossOrigin2", [ + displayHost, + ]); + } else if (!realm) { + text = this.getLocalizedString("EnterUserPasswordFor2", [displayHost]); + } else { + text = this.getLocalizedString("EnterLoginForRealm3", [ + realm, + displayHost, + ]); + } + + return text; + }, + + getBrandFullName() { + return this.brandBundle.GetStringFromName("brandFullName"); + }, +}; + +XPCOMUtils.defineLazyGetter(InternalPromptUtils, "strBundle", function() { + let bundle = Services.strings.createBundle( + "chrome://global/locale/commonDialogs.properties" + ); + if (!bundle) { + throw new Error("String bundle for Prompter not present!"); + } + return bundle; +}); + +XPCOMUtils.defineLazyGetter(InternalPromptUtils, "brandBundle", function() { + let bundle = Services.strings.createBundle( + "chrome://branding/locale/brand.properties" + ); + if (!bundle) { + throw new Error("String bundle for branding not present!"); + } + return bundle; +}); + +XPCOMUtils.defineLazyGetter(InternalPromptUtils, "ellipsis", function() { + let ellipsis = "\u2026"; + try { + ellipsis = Services.prefs.getComplexValue( + "intl.ellipsis", + Ci.nsIPrefLocalizedString + ).data; + } catch (e) {} + return ellipsis; +}); + +class ModalPrompter { + constructor({ + browsingContext = null, + domWin = null, + modalType = null, + async = false, + }) { + if (browsingContext && domWin) { + throw new Error("Pass either browsingContext or domWin"); + } + + if (domWin) { + // We have a domWin, get the associated browsing context + this.browsingContext = BrowsingContext.getFromWindow(domWin); + } else { + this.browsingContext = browsingContext; + } + + if ( + domWin && + (!modalType || modalType == MODAL_TYPE_WINDOW) && + !this.browsingContext?.isContent && + this.browsingContext?.associatedWindow?.gDialogBox + ) { + modalType = MODAL_TYPE_INTERNAL_WINDOW; + } + + // Use given modal type or fallback to default + this.modalType = modalType || ModalPrompter.defaultModalType; + + this.async = async; + + this.QueryInterface = ChromeUtils.generateQI([ + "nsIPrompt", + "nsIAuthPrompt", + "nsIAuthPrompt2", + "nsIWritablePropertyBag2", + ]); + } + + set modalType(modalType) { + // Setting modal type window is always allowed + if (modalType == MODAL_TYPE_WINDOW) { + this._modalType = modalType; + return; + } + + // For content prompts for non-content windows, use window prompts: + if (modalType == MODAL_TYPE_CONTENT && !this.browsingContext?.isContent) { + this._modalType = MODAL_TYPE_WINDOW; + return; + } + + // We can't use content / tab prompts if we don't have a suitable parent. + if ( + !this.browsingContext?.isContent && + modalType != MODAL_TYPE_INTERNAL_WINDOW + ) { + // Only show this error if we're not about to fall back again and show a different one. + if (this.browsingContext?.associatedWindow?.gDialogBox) { + Cu.reportError( + "Prompter: Browser not available. Falling back to internal window prompt." + ); + } + modalType = MODAL_TYPE_INTERNAL_WINDOW; + } + + if ( + modalType == MODAL_TYPE_INTERNAL_WINDOW && + (this.browsingContext?.isContent || + !this.browsingContext?.associatedWindow?.gDialogBox) + ) { + Cu.reportError( + "Prompter: internal dialogs not available in this context. Falling back to window prompt." + ); + modalType = MODAL_TYPE_WINDOW; + } + + this._modalType = modalType; + } + + get modalType() { + return this._modalType; + } + + /* ---------- internal methods ---------- */ + + /** + * Synchronous wrapper around {@link ModalPrompter#openPrompt} + * @param {Object} args Prompt arguments. When prompt has been closed, they are updated to reflect the result state. + */ + openPromptSync(args) { + let closed = false; + this.openPrompt(args) + .then(returnedArgs => { + if (returnedArgs) { + for (let key in returnedArgs) { + args[key] = returnedArgs[key]; + } + } + }) + .finally(() => { + closed = true; + }); + Services.tm.spinEventLoopUntilOrQuit( + "prompts/Prompter.jsm:openPromptSync", + () => closed + ); + } + + async openPrompt(args) { + if (!this.browsingContext) { + // We don't have a browsing context, fallback to a window prompt. + args.modalType = MODAL_TYPE_WINDOW; + this.openWindowPrompt(null, args); + return args; + } + + if (this._modalType == MODAL_TYPE_INTERNAL_WINDOW) { + await this.openInternalWindowPrompt( + this.browsingContext.associatedWindow, + args + ); + return args; + } + + // Select prompts are not part of CommonDialog + // and thus not supported as tab or content prompts yet. See Bug 1622817. + // Once they are integrated this override should be removed. + if (args.promptType == "select" && this.modalType !== MODAL_TYPE_WINDOW) { + Cu.reportError( + "Prompter: 'select' prompts do not support tab/content prompting. Falling back to window prompt." + ); + args.modalType = MODAL_TYPE_WINDOW; + } else { + args.modalType = this.modalType; + } + + const IS_CONTENT = + Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT; + + let actor; + try { + if (IS_CONTENT) { + // When in the content, get the PromptChild actor. + actor = this.browsingContext.window.windowGlobalChild.getActor( + "Prompt" + ); + } else { + // When in the parent, get the PromptParent actor. + actor = this.browsingContext.currentWindowGlobal.getActor("Prompt"); + } + } catch (_) { + // We can't get the prompt actor, fallback to window prompt. + let parentWin; + // If given a chrome BC we can try to get its window + if (!this.browsingContext.isContent && this.browsingContext.window) { + parentWin = this.browsingContext.window; + } else { + // Try to get the window which is the browsers parent + parentWin = this.browsingContext.top?.embedderElement?.ownerGlobal; + } + this.openWindowPrompt(parentWin, args); + return args; + } + + /* For prompts with a channel, we want to show the origin requesting + * authentication. This is different from the prompt principal, + * which is based on the document loaded in the browsing context over + * which the prompt appears. So if page foo.com loads bar.com, and the + * latter asks for auth, we want that bar.com's origin, not foo.com. + * To avoid confusion, we use different properties + * (authOrigin / promptPrincipal) to track this information. + */ + if (args.channel) { + try { + args.authOrigin = args.channel.URI.hostPort; + } catch (ex) { + args.authOrigin = args.channel.URI.prePath; + } + args.isInsecureAuth = + args.channel.URI.schemeIs("http") && + !args.channel.loadInfo.isTopLevelLoad; + } else { + args.promptPrincipal = this.browsingContext.window?.document.nodePrincipal; + } + if (IS_CONTENT) { + let docShell = this.browsingContext.docShell; + let inPermitUnload = docShell?.contentViewer?.inPermitUnload; + args.inPermitUnload = inPermitUnload; + let eventDetail = Cu.cloneInto( + { + tabPrompt: this.modalType != MODAL_TYPE_WINDOW, + inPermitUnload, + }, + this.browsingContext.window + ); + PromptUtils.fireDialogEvent( + this.browsingContext.window, + "DOMWillOpenModalDialog", + null, + eventDetail + ); + + // Put content window in the modal state while the prompt is open. + let windowUtils = this.browsingContext.window?.windowUtils; + if (windowUtils) { + windowUtils.enterModalState(); + } + } else if (args.inPermitUnload) { + args.promptPrincipal = this.browsingContext.currentWindowGlobal.documentPrincipal; + } + + // It is technically possible for multiple prompts to be sent from a single + // BrowsingContext. See bug 1266353. We use a randomly generated UUID to + // differentiate between the different prompts. + let id = "id" + Services.uuid.generateUUID().toString(); + + args._remoteId = id; + + let returnedArgs; + try { + if (IS_CONTENT) { + // If we're in the content process, send a message to the PromptParent + // window actor. + returnedArgs = await actor.sendQuery("Prompt:Open", args); + } else { + // If we're in the parent process we already have the parent actor. + // We can call its message handler directly. + returnedArgs = await actor.receiveMessage({ + name: "Prompt:Open", + data: args, + }); + } + + if (returnedArgs?.promptAborted) { + throw Components.Exception( + "prompt aborted by user", + Cr.NS_ERROR_NOT_AVAILABLE + ); + } + } finally { + if (IS_CONTENT) { + let windowUtils = this.browsingContext.window?.windowUtils; + if (windowUtils) { + windowUtils.leaveModalState(); + } + PromptUtils.fireDialogEvent( + this.browsingContext.window, + "DOMModalDialogClosed" + ); + } + } + return returnedArgs; + } + + /** + * Open a window modal prompt + * + * There's an implied contract that says modal prompts should still work when + * no "parent" window is passed for the dialog (eg, the "Master Password" + * dialog does this). These prompts must be shown even if there are *no* + * visible windows at all. + * We try and find a window to use as the parent, but don't consider if that + * is visible before showing the prompt. parentWindow may still be null if + * there are _no_ windows open. + * @param {Window} [parentWindow] - The parent window for the prompt, may be + * null. + * @param {Object} args - Prompt options and return values. + */ + openWindowPrompt(parentWindow = null, args) { + let uri = args.promptType == "select" ? SELECT_DIALOG : COMMON_DIALOG; + let propBag = PromptUtils.objectToPropBag(args); + Services.ww.openWindow( + parentWindow || Services.ww.activeWindow, + uri, + "_blank", + "centerscreen,chrome,modal,titlebar", + propBag + ); + PromptUtils.propBagToObject(propBag, args); + } + + async openInternalWindowPrompt(parentWindow, args) { + if (!parentWindow?.gDialogBox || !ModalPrompter.windowPromptSubDialog) { + this.openWindowPrompt(parentWindow, args); + return; + } + let propBag = PromptUtils.objectToPropBag(args); + propBag.setProperty("async", this.async); + let uri = args.promptType == "select" ? SELECT_DIALOG : COMMON_DIALOG; + await parentWindow.gDialogBox.open(uri, propBag); + propBag.deleteProperty("async"); + PromptUtils.propBagToObject(propBag, args); + } + + /** + * Calls async prompt method and optionally runs promise chained task on + * result data. Converts result data to nsIPropertyBag. + * @param {Object} args - Prompt arguments. + * @param {Function} [task] - Function which is called with the modified + * prompt args object once the prompt has been closed. Must return a + * result object for the prompt caller. + * @returns {Promise<nsIPropertyBag>} - Resolves with a property bag holding the + * prompt result properties. Resolves once prompt has been closed. + */ + async openPromptAsync(args, task) { + let result = await this.openPrompt(args); + // If task is not defined, the prompt method does not return + // anything. In this case we can resolve without value. + if (!task) { + return undefined; + } + // Convert task result to nsIPropertyBag and resolve + let taskResult = task(result); + if (!(taskResult instanceof Object)) { + throw new Error("task must return object"); + } + return PromptUtils.objectToPropBag(taskResult); + } + + /* + * ---------- interface disambiguation ---------- + * + * nsIPrompt and nsIAuthPrompt share 3 method names with slightly + * different arguments. All but prompt() have the same number of + * arguments, so look at the arg types to figure out how we're being + * called. :-( + */ + prompt() { + // also, the nsIPrompt flavor has 5 args instead of 6. + if (typeof arguments[2] == "object") { + return this.nsIPrompt_prompt.apply(this, arguments); + } + return this.nsIAuthPrompt_prompt.apply(this, arguments); + } + + promptUsernameAndPassword() { + // Both have 6 args, so use types. + if (typeof arguments[2] == "object") { + // Add the null channel: + let args = Array.from(arguments); + args.unshift(null); + return this.nsIPrompt_promptUsernameAndPassword.apply(this, args); + } + return this.nsIAuthPrompt_promptUsernameAndPassword.apply(this, arguments); + } + + promptPassword() { + // Both have 5 args, so use types. + if (typeof arguments[2] == "object") { + // Add the null channel: + let args = Array.from(arguments); + args.unshift(null); + return this.nsIPrompt_promptPassword.apply(this, args); + } + return this.nsIAuthPrompt_promptPassword.apply(this, arguments); + } + + /* ---------- nsIPrompt ---------- */ + + alert(title, text) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("Alert"); + } + + let args = { + promptType: "alert", + title, + text, + }; + + if (this.async) { + return this.openPromptAsync(args); + } + + return this.openPromptSync(args); + } + + alertCheck(title, text, checkLabel, checkValue) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("Alert"); + } + + // For sync calls checkValue is an XPCOM inout. XPCOM wraps primitves in + // objects for call by reference. + // The async version of this method uses call by value. + let checked = this.async ? checkValue : checkValue.value; + + let args = { + promptType: "alertCheck", + title, + text, + checkLabel, + checked, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ + checked: result.checked, + })); + } + + this.openPromptSync(args); + checkValue.value = args.checked; + return undefined; + } + + confirm(title, text) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("Confirm"); + } + + let args = { + promptType: "confirm", + title, + text, + ok: false, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ ok: result.ok })); + } + + this.openPromptSync(args); + return args.ok; + } + + confirmCheck(title, text, checkLabel, checkValue) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("ConfirmCheck"); + } + + let checked = this.async ? checkValue : checkValue.value; + + let args = { + promptType: "confirmCheck", + title, + text, + checkLabel, + checked, + ok: false, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ + // Checkbox state always returned, even if cancel clicked. + checked: result.checked, + // Did user click Ok or Cancel? + ok: result.ok, + })); + } + + this.openPromptSync(args); + checkValue.value = args.checked; + return args.ok; + } + + confirmEx( + title, + text, + flags, + button0, + button1, + button2, + checkLabel, + checkValue, + extraArgs = {} + ) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("Confirm"); + } + + let args = { + promptType: "confirmEx", + title, + text, + checkLabel, + checked: this.async ? checkValue : checkValue.value, + ok: false, + buttonNumClicked: 1, + ...extraArgs, + }; + + let [ + label0, + label1, + label2, + defaultButtonNum, + isDelayEnabled, + ] = InternalPromptUtils.confirmExHelper(flags, button0, button1, button2); + + args.defaultButtonNum = defaultButtonNum; + args.enableDelay = isDelayEnabled; + + if (label0) { + args.button0Label = label0; + if (label1) { + args.button1Label = label1; + if (label2) { + args.button2Label = label2; + } + } + } + + if (this.async) { + return this.openPromptAsync(args, result => ({ + checked: !!result.checked, + buttonNumClicked: result.buttonNumClicked, + })); + } + + this.openPromptSync(args); + checkValue.value = args.checked; + return args.buttonNumClicked; + } + + nsIPrompt_prompt(title, text, value, checkLabel, checkValue) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("Prompt"); + } + + let args = { + promptType: "prompt", + title, + text, + value: this.async ? value : value.value, + checkLabel, + checked: this.async ? checkValue : checkValue.value, + ok: false, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ + checked: !!result.checked, + value: result.value, + ok: result.ok, + })); + } + + this.openPromptSync(args); + + // Did user click Ok or Cancel? + let ok = args.ok; + if (ok) { + checkValue.value = args.checked; + value.value = args.value; + } + + return ok; + } + + nsIPrompt_promptUsernameAndPassword(channel, title, text, user, pass) { + if (!title) { + title = InternalPromptUtils.getLocalizedString( + "PromptUsernameAndPassword3", + [InternalPromptUtils.getBrandFullName()] + ); + } + + let args = { + channel, + promptType: "promptUserAndPass", + title, + text, + user: this.async ? user : user.value, + pass: this.async ? pass : pass.value, + button0Label: InternalPromptUtils.getLocalizedString("SignIn"), + ok: false, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ + user: result.user, + pass: result.pass, + ok: result.ok, + })); + } + + this.openPromptSync(args); + + // Did user click Ok or Cancel? + let ok = args.ok; + if (ok) { + user.value = args.user; + pass.value = args.pass; + } + + return ok; + } + + nsIPrompt_promptPassword(channel, title, text, pass) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("PromptPassword3", [ + InternalPromptUtils.getBrandFullName(), + ]); + } + + let args = { + channel, + promptType: "promptPassword", + title, + text, + pass: this.async ? pass : pass.value, + button0Label: InternalPromptUtils.getLocalizedString("SignIn"), + ok: false, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ + pass: result.pass, + ok: result.ok, + })); + } + + this.openPromptSync(args); + + // Did user click Ok or Cancel? + let ok = args.ok; + if (ok) { + pass.value = args.pass; + } + + return ok; + } + + select(title, text, list, selected) { + if (!title) { + title = InternalPromptUtils.getLocalizedString("Select"); + } + + let args = { + promptType: "select", + title, + text, + list, + selected: -1, + ok: false, + }; + + if (this.async) { + return this.openPromptAsync(args, result => ({ + selected: result.selected, + ok: result.ok, + })); + } + + this.openPromptSync(args); + + // Did user click Ok or Cancel? + let ok = args.ok; + if (ok) { + selected.value = args.selected; + } + + return ok; + } + + /* ---------- nsIAuthPrompt ---------- */ + + nsIAuthPrompt_prompt( + title, + text, + passwordRealm, + savePassword, + defaultText, + result + ) { + // The passwordRealm and savePassword args were ignored by nsPrompt.cpp + if (defaultText) { + result.value = defaultText; + } + return this.nsIPrompt_prompt(title, text, result, null, {}); + } + + nsIAuthPrompt_promptUsernameAndPassword( + title, + text, + passwordRealm, + savePassword, + user, + pass + ) { + // The passwordRealm and savePassword args were ignored by nsPrompt.cpp + return this.nsIPrompt_promptUsernameAndPassword( + null, + title, + text, + user, + pass + ); + } + + nsIAuthPrompt_promptPassword(title, text, passwordRealm, savePassword, pass) { + // The passwordRealm and savePassword args were ignored by nsPrompt.cpp, + // and we don't have a channel here. + return this.nsIPrompt_promptPassword(null, title, text, pass); + } + + /* ---------- nsIAuthPrompt2 ---------- */ + + promptAuth(channel, level, authInfo) { + let message = InternalPromptUtils.makeAuthMessage(this, channel, authInfo); + + let [username, password] = InternalPromptUtils.getAuthInfo(authInfo); + + let userParam = this.async ? username : { value: username }; + let passParam = this.async ? password : { value: password }; + + let result; + if (authInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD) { + result = this.nsIPrompt_promptPassword(channel, null, message, passParam); + } else { + result = this.nsIPrompt_promptUsernameAndPassword( + channel, + null, + message, + userParam, + passParam + ); + } + + // For the async case result is an nsIPropertyBag with prompt results. + if (this.async) { + return result.then(bag => { + let ok = bag.getProperty("ok"); + if (ok) { + let username = bag.getProperty("user"); + let password = bag.getProperty("pass"); + InternalPromptUtils.setAuthInfo(authInfo, username, password); + } + return ok; + }); + } + + // For the sync case result is the "ok" boolean which indicates whether + // the user has confirmed the dialog. + if (result) { + InternalPromptUtils.setAuthInfo( + authInfo, + userParam.value, + passParam.value + ); + } + return result; + } + + asyncPromptAuth( + channel, + callback, + context, + level, + authInfo, + checkLabel, + checkValue + ) { + // Nothing calls this directly; netwerk ends up going through + // nsIPromptService::GetPrompt, which delegates to login manager. + // Login manger handles the async bits itself, and only calls out + // promptAuth, never asyncPromptAuth. + // + // Bug 565582 will change this. + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + } + + /* ---------- nsIWritablePropertyBag2 ---------- */ + // Legacy way to set modal type when prompting via nsIPrompt. + // Please prompt via nsIPromptService. This will be removed in the future. + setPropertyAsUint32(name, value) { + if (name == "modalType") { + this.modalType = value; + } else { + throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE); + } + } +} + +XPCOMUtils.defineLazyPreferenceGetter( + ModalPrompter, + "defaultModalType", + "prompts.defaultModalType", + MODAL_TYPE_WINDOW +); + +XPCOMUtils.defineLazyPreferenceGetter( + ModalPrompter, + "windowPromptSubDialog", + "prompts.windowPromptSubDialog", + false +); + +function AuthPromptAdapterFactory() {} +AuthPromptAdapterFactory.prototype = { + classID: Components.ID("{6e134924-6c3a-4d86-81ac-69432dd971dc}"), + QueryInterface: ChromeUtils.generateQI(["nsIAuthPromptAdapterFactory"]), + + /* ---------- nsIAuthPromptAdapterFactory ---------- */ + + createAdapter(oldPrompter) { + return new AuthPromptAdapter(oldPrompter); + }, +}; + +// Takes an nsIAuthPrompt implementation, wraps it with a nsIAuthPrompt2 shell. +function AuthPromptAdapter(oldPrompter) { + this.oldPrompter = oldPrompter; +} +AuthPromptAdapter.prototype = { + QueryInterface: ChromeUtils.generateQI(["nsIAuthPrompt2"]), + oldPrompter: null, + + /* ---------- nsIAuthPrompt2 ---------- */ + + promptAuth(channel, level, authInfo, checkLabel, checkValue) { + let message = InternalPromptUtils.makeAuthMessage( + this.oldPrompter, + channel, + authInfo + ); + + let [username, password] = InternalPromptUtils.getAuthInfo(authInfo); + let userParam = { value: username }; + let passParam = { value: password }; + + let { displayHost, realm } = InternalPromptUtils.getAuthTarget( + channel, + authInfo + ); + let authTarget = displayHost + " (" + realm + ")"; + + let ok; + if (authInfo.flags & Ci.nsIAuthInformation.ONLY_PASSWORD) { + ok = this.oldPrompter.promptPassword( + null, + message, + authTarget, + Ci.nsIAuthPrompt.SAVE_PASSWORD_PERMANENTLY, + passParam + ); + } else { + ok = this.oldPrompter.promptUsernameAndPassword( + null, + message, + authTarget, + Ci.nsIAuthPrompt.SAVE_PASSWORD_PERMANENTLY, + userParam, + passParam + ); + } + + if (ok) { + InternalPromptUtils.setAuthInfo( + authInfo, + userParam.value, + passParam.value + ); + } + return ok; + }, + + asyncPromptAuth( + channel, + callback, + context, + level, + authInfo, + checkLabel, + checkValue + ) { + throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED); + }, +}; + +var EXPORTED_SYMBOLS = ["Prompter", "AuthPromptAdapterFactory"]; diff --git a/toolkit/components/prompts/src/SharedPromptUtils.jsm b/toolkit/components/prompts/src/SharedPromptUtils.jsm new file mode 100644 index 0000000000..805ffca5e1 --- /dev/null +++ b/toolkit/components/prompts/src/SharedPromptUtils.jsm @@ -0,0 +1,184 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this file, + * You can obtain one at http://mozilla.org/MPL/2.0/. */ + +var EXPORTED_SYMBOLS = ["PromptUtils", "EnableDelayHelper"]; + +var PromptUtils = { + // Fire a dialog open/close event. Used by tabbrowser to focus the + // tab which is triggering a prompt. + // For remote dialogs, we pass in a different DOM window and a separate + // target. If the caller doesn't pass in the target, then we'll simply use + // the passed-in DOM window. + // The detail may contain information about the principal on which the + // prompt is triggered, as well as whether or not this is a tabprompt + // (ie tabmodal alert/prompt/confirm and friends) + fireDialogEvent(domWin, eventName, maybeTarget, detail) { + let target = maybeTarget || domWin; + let eventOptions = { cancelable: true, bubbles: true }; + if (detail) { + eventOptions.detail = detail; + } + let event = new domWin.CustomEvent(eventName, eventOptions); + let winUtils = domWin.windowUtils; + winUtils.dispatchEventToChromeOnly(target, event); + }, + + objectToPropBag(obj) { + let bag = Cc["@mozilla.org/hash-property-bag;1"].createInstance( + Ci.nsIWritablePropertyBag2 + ); + bag.QueryInterface(Ci.nsIWritablePropertyBag); + + for (let propName in obj) { + bag.setProperty(propName, obj[propName]); + } + + return bag; + }, + + propBagToObject(propBag, obj) { + // Here we iterate over the object's original properties, not the bag + // (ie, the prompt can't return more/different properties than were + // passed in). This just helps ensure that the caller provides default + // values, lest the prompt forget to set them. + for (let propName in obj) { + obj[propName] = propBag.getProperty(propName); + } + }, +}; + +/** + * This helper handles the enabling/disabling of dialogs that might + * be subject to fast-clicking attacks. It handles the initial delayed + * enabling of the dialog, as well as disabling it on blur and reapplying + * the delay when the dialog regains focus. + * + * @param enableDialog A custom function to be called when the dialog + * is to be enabled. + * @param diableDialog A custom function to be called when the dialog + * is to be disabled. + * @param focusTarget The window used to watch focus/blur events. + */ +var EnableDelayHelper = function({ enableDialog, disableDialog, focusTarget }) { + this.enableDialog = makeSafe(enableDialog); + this.disableDialog = makeSafe(disableDialog); + this.focusTarget = focusTarget; + + this.disableDialog(); + + this.focusTarget.addEventListener("blur", this); + this.focusTarget.addEventListener("focus", this); + // While the user key-repeats, we want to renew the timer until keyup: + this.focusTarget.addEventListener("keyup", this, true); + this.focusTarget.addEventListener("keydown", this, true); + this.focusTarget.document.addEventListener("unload", this); + + this.startOnFocusDelay(); +}; + +EnableDelayHelper.prototype = { + get delayTime() { + return Services.prefs.getIntPref("security.dialog_enable_delay"); + }, + + handleEvent(event) { + if ( + !event.type.startsWith("key") && + event.target != this.focusTarget && + event.target != this.focusTarget.document + ) { + return; + } + + switch (event.type) { + case "keyup": + // As soon as any key goes up, we can stop treating keypresses + // as indicative of key-repeating that should prolong the timer. + this.focusTarget.removeEventListener("keyup", this, true); + this.focusTarget.removeEventListener("keydown", this, true); + break; + + case "keydown": + // Renew timer for repeating keydowns: + if (this._focusTimer) { + this._focusTimer.cancel(); + this._focusTimer = null; + this.startOnFocusDelay(); + event.preventDefault(); + } + break; + + case "blur": + this.onBlur(); + break; + + case "focus": + this.onFocus(); + break; + + case "unload": + this.onUnload(); + break; + } + }, + + onBlur() { + this.disableDialog(); + // If we blur while waiting to enable the buttons, just cancel the + // timer to ensure the delay doesn't fire while not focused. + if (this._focusTimer) { + this._focusTimer.cancel(); + this._focusTimer = null; + } + }, + + onFocus() { + this.startOnFocusDelay(); + }, + + onUnload() { + this.focusTarget.removeEventListener("blur", this); + this.focusTarget.removeEventListener("focus", this); + this.focusTarget.removeEventListener("keyup", this, true); + this.focusTarget.removeEventListener("keydown", this, true); + this.focusTarget.document.removeEventListener("unload", this); + + if (this._focusTimer) { + this._focusTimer.cancel(); + this._focusTimer = null; + } + + this.focusTarget = this.enableDialog = this.disableDialog = null; + }, + + startOnFocusDelay() { + if (this._focusTimer) { + return; + } + + this._focusTimer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer); + this._focusTimer.initWithCallback( + () => { + this.onFocusTimeout(); + }, + this.delayTime, + Ci.nsITimer.TYPE_ONE_SHOT + ); + }, + + onFocusTimeout() { + this._focusTimer = null; + this.enableDialog(); + }, +}; + +function makeSafe(fn) { + return function() { + // The dialog could be gone by now (if the user closed it), + // which makes it likely that the given fn might throw. + try { + fn(); + } catch (e) {} + }; +} diff --git a/toolkit/components/prompts/src/components.conf b/toolkit/components/prompts/src/components.conf new file mode 100644 index 0000000000..184f011bd5 --- /dev/null +++ b/toolkit/components/prompts/src/components.conf @@ -0,0 +1,26 @@ +# -*- 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': '{6e134924-6c3a-4d86-81ac-69432dd971dc}', + 'contract_ids': ['@mozilla.org/network/authprompt-adapter-factory;1'], + 'jsm': 'resource://gre/modules/Prompter.jsm', + 'constructor': 'AuthPromptAdapterFactory', + }, +] + +if buildconfig.substs['MOZ_WIDGET_TOOLKIT'] != 'android': + Classes += [ + { + 'js_name': 'prompt', + 'cid': '{1c978d25-b37f-43a8-a2d6-0c7a239ead87}', + 'contract_ids': ['@mozilla.org/prompter;1'], + 'interfaces': ['nsIPromptService'], + 'jsm': 'resource://gre/modules/Prompter.jsm', + 'constructor': 'Prompter', + }, + ] diff --git a/toolkit/components/prompts/src/moz.build b/toolkit/components/prompts/src/moz.build new file mode 100644 index 0000000000..3183266f2f --- /dev/null +++ b/toolkit/components/prompts/src/moz.build @@ -0,0 +1,15 @@ +# -*- 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/. + +EXTRA_JS_MODULES += [ + "CommonDialog.jsm", + "Prompter.jsm", + "SharedPromptUtils.jsm", +] + +XPCOM_MANIFESTS += [ + "components.conf", +] diff --git a/toolkit/components/prompts/test/.eslintrc.js b/toolkit/components/prompts/test/.eslintrc.js new file mode 100644 index 0000000000..af973e82fe --- /dev/null +++ b/toolkit/components/prompts/test/.eslintrc.js @@ -0,0 +1,8 @@ +"use strict"; + +module.exports = { + rules: { + // ownerGlobal doesn't exist in content privileged windows. + "mozilla/use-ownerGlobal": "off", + }, +}; diff --git a/toolkit/components/prompts/test/PromptTestUtils.jsm b/toolkit/components/prompts/test/PromptTestUtils.jsm new file mode 100644 index 0000000000..53c9da01cd --- /dev/null +++ b/toolkit/components/prompts/test/PromptTestUtils.jsm @@ -0,0 +1,248 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +/* + * Utility module for tests to interact with prompts spawned by nsIPrompt or + * nsIPromptService. + */ + +"use strict"; + +const { XPCOMUtils } = ChromeUtils.importESModule( + "resource://gre/modules/XPCOMUtils.sys.mjs" +); +const { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); + +const { TestUtils } = ChromeUtils.importESModule( + "resource://testing-common/TestUtils.sys.mjs" +); + +const EXPORTED_SYMBOLS = ["PromptTestUtils"]; + +const kPrefs = {}; + +// Whether prompts with modal type TAB are shown as SubDialog (true) or +// TabModalPrompt (false). +XPCOMUtils.defineLazyPreferenceGetter( + kPrefs, + "tabPromptSubDialogEnabled", + "prompts.tabChromePromptSubDialog", + false +); + +// Whether web content prompts (alert etc.) are shown as SubDialog (true) +// or TabModalPrompt (false) +XPCOMUtils.defineLazyPreferenceGetter( + kPrefs, + "contentPromptSubDialogEnabled", + "prompts.contentPromptSubDialog", + false +); + +function isCommonDialog(modalType) { + return ( + modalType === Services.prompt.MODAL_TYPE_WINDOW || + (kPrefs.tabPromptSubDialogEnabled && + modalType === Services.prompt.MODAL_TYPE_TAB) || + (kPrefs.contentPromptSubDialogEnabled && + modalType === Services.prompt.MODAL_TYPE_CONTENT) + ); +} + +let PromptTestUtils = { + /** + * Wait for a prompt from nsIPrompt or nsIPromptsService, interact with it and + * click the specified button to close it. + * @param {Browser|Window} [parent] - Parent of the prompt. This can be + * either the parent window or the browser. For tab prompts, if given a + * window, the currently selected browser in that window will be used. + * @param {Object} promptOptions - @see waitForPrompt + * @param {Object} promptActions - @see handlePrompt + * @returns {Promise} - A promise which resolves once the prompt has been + * closed. + */ + async handleNextPrompt(parent, promptOptions, promptActions) { + let dialog = await this.waitForPrompt(parent, promptOptions); + return this.handlePrompt(dialog, promptActions); + }, + + /** + * Interact with an existing prompt and close it. + * @param {Dialog} dialog - The dialog instance associated with the prompt. + * @param {Object} [actions] - Options on how to interact with the + * prompt and how to close it. + * @param {Boolean} [actions.checkboxState] - Set the checkbox state. + * true = checked, false = unchecked. + * @param {Number} [actions.buttonNumClick] - Which button to click to close + * the prompt. + * @param {String} [actions.loginInput] - Input text for the login text field. + * This field is also used for text input for the "prompt" type. + * @param {String} [actions.passwordInput] - Input text for the password text + * field. + * @returns {Promise} - A promise which resolves once the prompt has been + * closed. + */ + handlePrompt( + dialog, + { + checkboxState = null, + buttonNumClick = 0, + loginInput = null, + passwordInput = null, + } = {} + ) { + let promptClosePromise; + + // Get parent window to listen for prompt close event + let win; + if (isCommonDialog(dialog.args.modalType)) { + win = dialog.ui.prompt?.opener; + } else { + // Tab prompts should always have a parent window + win = dialog.ui.prompt.win; + } + + if (win) { + promptClosePromise = BrowserTestUtils.waitForEvent( + win, + "DOMModalDialogClosed" + ); + } else { + // We don't have a parent, wait for window close instead + promptClosePromise = BrowserTestUtils.windowClosed(dialog.ui.prompt); + } + + if (typeof checkboxState == "boolean") { + dialog.ui.checkbox.checked = checkboxState; + } + + if (loginInput != null) { + dialog.ui.loginTextbox.value = loginInput; + } + + if (passwordInput != null) { + dialog.ui.password1Textbox.value = passwordInput; + } + + let button = dialog.ui["button" + buttonNumClick]; + if (!button) { + throw new Error("Could not find button with index " + buttonNumClick); + } + button.click(); + + return promptClosePromise; + }, + + /** + * Wait for a prompt from nsIPrompt or nsIPromptsService to open. + * @param {Browser|Window} [parent] - Parent of the prompt. This can be either + * the parent window or the browser. For tab prompts, if given a window, the + * currently selected browser in that window will be used. + * If not given a parent, the method will return on prompts of any window. + * @param {Object} attrs - The prompt attributes to filter for. + * @param {Number} attrs.modalType - Whether the expected prompt is a content, tab or window prompt. + * nsIPromptService.<MODAL_TYPE_WINDOW|MODAL_TYPE_TAB|MODAL_TYPE_CONTENT> + * @param {String} [attrs.promptType] - Common dialog type of the prompt to filter for. + * @see {@link CommonDialog} for possible prompt types. + * @returns {Promise<CommonDialog>} - A Promise which resolves with a dialog + * object once the prompt has loaded. + */ + async waitForPrompt(parent, { modalType, promptType = null } = {}) { + if (!modalType) { + throw new Error("modalType is mandatory"); + } + + // Get window by browser or browser by window, depending on what is passed + // via the parent arg. If the caller passes parent=null, both will be null. + let parentWindow; + let parentBrowser; + if (parent) { + if (Element.isInstance(parent)) { + // Parent is browser + parentBrowser = parent; + parentWindow = parentBrowser.ownerGlobal; + } else if (parent instanceof Ci.nsIDOMChromeWindow) { + // Parent is window + parentWindow = parent; + parentBrowser = parentWindow.gBrowser?.selectedBrowser; + } else { + throw new Error("Invalid parent. Expected browser or dom window"); + } + } + + let topic = isCommonDialog(modalType) + ? "common-dialog-loaded" + : "tabmodal-dialog-loaded"; + + let dialog; + await TestUtils.topicObserved(topic, subject => { + // If we are not given a browser, use the currently selected browser of the window + let browser = + parentBrowser || subject.ownerGlobal.gBrowser?.selectedBrowser; + if (isCommonDialog(modalType)) { + // Is not associated with given parent window, skip + if (parentWindow && subject.opener !== parentWindow) { + return false; + } + + // For tab prompts, ensure that the associated browser matches. + if (browser && modalType == Services.prompt.MODAL_TYPE_TAB) { + let dialogBox = parentWindow.gBrowser.getTabDialogBox(browser); + let hasMatchingDialog = dialogBox + .getTabDialogManager() + ._dialogs.some( + d => d._frame?.browsingContext == subject.browsingContext + ); + if (!hasMatchingDialog) { + return false; + } + } + + if (browser && modalType == Services.prompt.MODAL_TYPE_CONTENT) { + let dialogBox = parentWindow.gBrowser.getTabDialogBox(browser); + let hasMatchingDialog = dialogBox + .getContentDialogManager() + ._dialogs.some( + d => d._frame?.browsingContext == subject.browsingContext + ); + if (!hasMatchingDialog) { + return false; + } + } + + // subject is the window object of the prompt which has a Dialog object + // attached. + dialog = subject.Dialog; + } else { + // subject is the tabprompt dom node + // Get the full prompt object which has the dialog object + let prompt = browser.tabModalPromptBox.getPrompt(subject); + + // Is not associated with given parent browser, skip. + if (!prompt) { + return false; + } + + dialog = prompt.Dialog; + } + + // Not the modalType we're looking for. + // For window prompts dialog.args.modalType is undefined. + if (isCommonDialog(modalType) && dialog.args.modalType !== modalType) { + return false; + } + + // Not the promptType we're looking for. + if (promptType && dialog.args.promptType !== promptType) { + return false; + } + + // Prompt found + return true; + }); + + return dialog; + }, +}; diff --git a/toolkit/components/prompts/test/bug619644_inner.html b/toolkit/components/prompts/test/bug619644_inner.html new file mode 100644 index 0000000000..cecfa78bad --- /dev/null +++ b/toolkit/components/prompts/test/bug619644_inner.html @@ -0,0 +1,7 @@ +<head></head><body><p>Original content</p> +<script> + window.opener.postMessage("", "*"); + confirm("Message"); + document.write("Extra content"); + window.opener.postMessage(document.documentElement.innerHTML, "*"); +</script></body> diff --git a/toolkit/components/prompts/test/bug625187_iframe.html b/toolkit/components/prompts/test/bug625187_iframe.html new file mode 100644 index 0000000000..740d59a617 --- /dev/null +++ b/toolkit/components/prompts/test/bug625187_iframe.html @@ -0,0 +1,16 @@ +<html> +<head> + <title>Test for Bug 625187 - the iframe</title> +<!-- + - Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ + - + - Contributor(s): + - Mihai Sucan <mihai.sucan@gmail.com> + --> +</head> +<body> +<p><button id="btn1" onclick="alert('hello world 2')">Button 2</button></p> +<p><button id="btn2" onclick="window.parent.alert('hello world 3')">Button 3</button></p> +</body> +</html> diff --git a/toolkit/components/prompts/test/chrome.ini b/toolkit/components/prompts/test/chrome.ini new file mode 100644 index 0000000000..90eee3a761 --- /dev/null +++ b/toolkit/components/prompts/test/chrome.ini @@ -0,0 +1,11 @@ +[DEFAULT] +support-files = + prompt_common.js + chromeScript.js + +[test_modal_prompts.html] +skip-if = + toolkit == 'android' #android: TIMED_OUT + os == 'linux' && (debug || asan || tsan) +[test_modal_select.html] +skip-if = toolkit == 'android' #android: TIMED_OUT diff --git a/toolkit/components/prompts/test/chromeScript.js b/toolkit/components/prompts/test/chromeScript.js new file mode 100644 index 0000000000..e31fbdc851 --- /dev/null +++ b/toolkit/components/prompts/test/chromeScript.js @@ -0,0 +1,354 @@ +/* eslint-env mozilla/chrome-script */ + +const { clearInterval, setInterval, setTimeout } = ChromeUtils.importESModule( + "resource://gre/modules/Timer.sys.mjs" +); + +const { BrowserTestUtils } = ChromeUtils.importESModule( + "resource://testing-common/BrowserTestUtils.sys.mjs" +); + +var tabSubDialogsEnabled = Services.prefs.getBoolPref( + "prompts.tabChromePromptSubDialog", + false +); + +var contentPromptSubdialogsEnabled = Services.prefs.getBoolPref( + "prompts.contentPromptSubDialog", + false +); + +// Define these to make EventUtils happy. +let window = this; +let parent = {}; + +let EventUtils = {}; +Services.scriptloader.loadSubScript( + "chrome://mochikit/content/tests/SimpleTest/EventUtils.js", + EventUtils +); + +addMessageListener("handlePrompt", msg => { + info("Received handlePrompt message"); + handlePromptWhenItAppears(msg.action, msg.modalType, msg.isSelect); +}); + +async function handlePromptWhenItAppears(action, modalType, isSelect) { + try { + if (!(await handlePrompt(action, modalType, isSelect))) { + setTimeout( + () => this.handlePromptWhenItAppears(action, modalType, isSelect), + 100 + ); + } + } catch (e) { + info(`handlePromptWhenItAppears: exception: ${e}`); + } +} + +function checkTabModal(prompt, browser) { + let doc = browser.ownerDocument; + + let { bottom: toolboxBottom } = doc + .getElementById("navigator-toolbox") + .getBoundingClientRect(); + + let { mainContainer } = prompt.ui; + + let { x, y } = mainContainer.getBoundingClientRect(); + ok(y > 0, "Container should have y > 0"); + // Inset by 1px since the corner point doesn't return the frame due to the + // border-radius. + is( + doc.elementFromPoint(x + 1, y + 1).parentNode, + mainContainer, + "Check tabmodalprompt is visible" + ); + + info("Click to the left of the dialog over the content area"); + isnot( + doc.elementFromPoint(x - 10, y + 50), + browser, + "Check clicks on the content area don't go to the browser" + ); + is( + doc.elementFromPoint(x - 10, y + 50), + prompt.element, + "Check clicks on the content area go to the prompt dialog background" + ); + + if (prompt.args.modalType == Ci.nsIPrompt.MODAL_TYPE_TAB) { + ok( + y <= toolboxBottom - 5, + "Dialog should overlap the toolbox by at least 5px" + ); + } else { + ok(y >= toolboxBottom, "Dialog must not overlap with toolbox."); + } + + ok( + browser.hasAttribute("tabmodalPromptShowing"), + "Check browser has @tabmodalPromptShowing" + ); +} + +async function handlePrompt(action, modalType, isSelect) { + info(`handlePrompt: modalType=${modalType}`); + + let ui; + let browserWin = Services.wm.getMostRecentWindow("navigator:browser"); + + if ( + (!contentPromptSubdialogsEnabled && + modalType === Services.prompt.MODAL_TYPE_CONTENT) || + (!tabSubDialogsEnabled && modalType === Services.prompt.MODAL_TYPE_TAB) + ) { + let gBrowser = browserWin.gBrowser; + let promptManager = gBrowser.getTabModalPromptBox(gBrowser.selectedBrowser); + let prompts = promptManager.listPrompts(); + if (!prompts.length) { + info("handlePrompt: no prompt found. retrying..."); + return false; // try again in a bit + } + + ui = prompts[0].Dialog.ui; + checkTabModal(prompts[0], gBrowser.selectedBrowser); + } else { + let doc = getDialogDoc(); + if (!doc) { + info("handlePrompt: no document found. retrying..."); + return false; // try again in a bit + } + + if (isSelect) { + ui = doc; + } else { + ui = doc.defaultView.Dialog.ui; + } + } + + let dialogClosed = BrowserTestUtils.waitForEvent( + browserWin, + "DOMModalDialogClosed" + ); + + let promptState; + if (isSelect) { + promptState = getSelectState(ui); + dismissSelect(ui, action); + } else { + promptState = getPromptState(ui); + dismissPrompt(ui, action); + } + + // Wait until the prompt has been closed before sending callback msg. + // Unless the test explicitly doesn't request a button click. + if (action.buttonClick !== "none") { + info(`handlePrompt: wait for dialogClosed`); + await dialogClosed; + } + + info(`handlePrompt: send promptHandled`); + sendAsyncMessage("promptHandled", { promptState }); + return true; +} + +function getSelectState(ui) { + let listbox = ui.getElementById("list"); + + let state = {}; + state.msg = ui.getElementById("info.txt").value; + state.selectedIndex = listbox.selectedIndex; + state.items = []; + + for (let i = 0; i < listbox.itemCount; i++) { + let item = listbox.getItemAtIndex(i).label; + state.items.push(item); + } + + return state; +} + +function getPromptState(ui) { + let state = {}; + state.msg = ui.infoBody.textContent; + state.infoRowHidden = ui.infoRow?.hidden || false; + state.titleHidden = ui.infoTitle.hidden; + state.textHidden = ui.loginContainer.hidden; + state.passHidden = ui.password1Container.hidden; + state.checkHidden = ui.checkboxContainer.hidden; + state.checkMsg = state.checkHidden ? "" : ui.checkbox.label; + state.checked = state.checkHidden ? false : ui.checkbox.checked; + // TabModalPrompts don't have an infoIcon + state.iconClass = ui.infoIcon ? ui.infoIcon.className : null; + state.textValue = ui.loginTextbox.value; + state.passValue = ui.password1Textbox.value; + + state.butt0Label = ui.button0.label; + state.butt1Label = ui.button1.label; + state.butt2Label = ui.button2.label; + + state.butt0Disabled = ui.button0.disabled; + state.butt1Disabled = ui.button1.disabled; + state.butt2Disabled = ui.button2.disabled; + + function isDefaultButton(b) { + return b.hasAttribute("default") && b.getAttribute("default") == "true"; + } + state.defButton0 = isDefaultButton(ui.button0); + state.defButton1 = isDefaultButton(ui.button1); + state.defButton2 = isDefaultButton(ui.button2); + + let e = Services.focus.focusedElement; + + if (e == null) { + state.focused = null; + } else if (ui.button0.isSameNode(e)) { + state.focused = "button0"; + } else if (ui.button1.isSameNode(e)) { + state.focused = "button1"; + } else if (ui.button2.isSameNode(e)) { + state.focused = "button2"; + } else if (e.isSameNode(ui.loginTextbox)) { + state.focused = "textField"; + } else if (e.isSameNode(ui.password1Textbox)) { + state.focused = "passField"; + } else if (ui.infoBody.isSameNode(e)) { + state.focused = "infoBody"; + } else { + state.focused = + "ERROR: unexpected element focused: " + (e ? e.localName : "<null>"); + } + + let treeOwner = + ui.prompt && ui.prompt.docShell && ui.prompt.docShell.treeOwner; + if (treeOwner && treeOwner.QueryInterface(Ci.nsIInterfaceRequestor)) { + // Check that the dialog is modal, chrome and dependent; + // We can't just check window.opener because that'll be + // a content window, which therefore isn't exposed (it'll lie and + // be null). + let flags = treeOwner.getInterface(Ci.nsIAppWindow).chromeFlags; + state.chrome = (flags & Ci.nsIWebBrowserChrome.CHROME_OPENAS_CHROME) != 0; + state.dialog = (flags & Ci.nsIWebBrowserChrome.CHROME_OPENAS_DIALOG) != 0; + state.chromeDependent = + (flags & Ci.nsIWebBrowserChrome.CHROME_DEPENDENT) != 0; + let wbc = treeOwner.getInterface(Ci.nsIWebBrowserChrome); + state.isWindowModal = wbc.isWindowModal(); + } + + // Check the dialog is a common dialog document and has been embedded. + let isEmbedded = !!ui.prompt?.docShell?.chromeEventHandler; + let isCommonDialogDoc = getDialogDoc()?.location.href.includes( + "commonDialog.xhtml" + ); + state.isSubDialogPrompt = isCommonDialogDoc && isEmbedded; + state.showCallerOrigin = ui.prompt.args.showCallerOrigin; + + return state; +} + +function dismissSelect(ui, action) { + let dialog = ui.getElementsByTagName("dialog")[0]; + let listbox = ui.getElementById("list"); + + if (action.selectItem) { + listbox.selectedIndex = 1; + } + + if (action.buttonClick == "ok") { + dialog.acceptDialog(); + } else if (action.buttonClick == "cancel") { + dialog.cancelDialog(); + } +} + +function dismissPrompt(ui, action) { + info(`dismissPrompt: action=${JSON.stringify(action)}`); + if (action.setCheckbox) { + // Annoyingly, the prompt code is driven by oncommand. + ui.checkbox.checked = true; + ui.checkbox.doCommand(); + } + + if ("textField" in action) { + ui.loginTextbox.setAttribute("value", action.textField); + } + + if ("passField" in action) { + ui.password1Textbox.setAttribute("value", action.passField); + } + + switch (action.buttonClick) { + case "ok": + case 0: + ui.button0.click(); + break; + case "cancel": + case 1: + ui.button1.click(); + break; + case 2: + ui.button2.click(); + break; + case "ESC": + // XXX This is assuming tab-modal. + let browserWin = Services.wm.getMostRecentWindow("navigator:browser"); + EventUtils.synthesizeKey("KEY_Escape", {}, browserWin); + break; + case "pollOK": + // Buttons are disabled at the moment, poll until they're reenabled. + // Can't use setInterval here, because the window's in a modal state + // and thus DOM events are suppressed. + let interval = setInterval(() => { + if (ui.button0.disabled) { + return; + } + ui.button0.click(); + clearInterval(interval); + }, 100); + break; + case "none": + break; + + default: + throw new Error("dismissPrompt action listed unknown button."); + } +} + +function getDialogDoc() { + // Trudge through all the open windows, until we find the one + // that has either commonDialog.xhtml or selectDialog.xhtml loaded. + // var enumerator = Services.wm.getEnumerator("navigator:browser"); + for (let { docShell } of Services.wm.getEnumerator(null)) { + var containedDocShells = docShell.getAllDocShellsInSubtree( + docShell.typeChrome, + docShell.ENUMERATE_FORWARDS + ); + for (let childDocShell of containedDocShells) { + // Get the corresponding document for this docshell + // We don't want it if it's not done loading. + if (childDocShell.busyFlags != Ci.nsIDocShell.BUSY_FLAGS_NONE) { + continue; + } + var childDoc = childDocShell.contentViewer.DOMDocument; + + if ( + childDoc.location.href != + "chrome://global/content/commonDialog.xhtml" && + childDoc.location.href != "chrome://global/content/selectDialog.xhtml" + ) { + continue; + } + + // We're expecting the dialog to be focused. If it's not yet, try later. + // (In particular, this is needed on Linux to reliably check focused elements.) + if (Services.focus.focusedWindow != childDoc.defaultView) { + continue; + } + + return childDoc; + } + } + + return null; +} diff --git a/toolkit/components/prompts/test/mochitest.ini b/toolkit/components/prompts/test/mochitest.ini new file mode 100644 index 0000000000..6f00eb3815 --- /dev/null +++ b/toolkit/components/prompts/test/mochitest.ini @@ -0,0 +1,17 @@ +[DEFAULT] +support-files = + ../../passwordmgr/test/authenticate.sjs + bug619644_inner.html + bug625187_iframe.html + prompt_common.js + chromeScript.js + +[test_bug619644.html] +skip-if = toolkit == 'android' # No tab prompts on android +[test_bug620145.html] +skip-if = toolkit == 'android' #TIMED_OUT +[test_subresources_prompts.html] +skip-if = toolkit == 'android' || verify +fail-if = xorigin +[test_dom_prompts.html] +skip-if = toolkit == 'android' #android: bug 1267092 diff --git a/toolkit/components/prompts/test/prompt_common.js b/toolkit/components/prompts/test/prompt_common.js new file mode 100644 index 0000000000..a47d421d3c --- /dev/null +++ b/toolkit/components/prompts/test/prompt_common.js @@ -0,0 +1,444 @@ +const { Cc, Ci, Cu: ChromeUtils } = SpecialPowers; + +/** + * Converts a property bag to object. + * @param {nsIPropertyBag} bag - The property bag to convert + * @returns {Object} - The object representation of the nsIPropertyBag + */ +function propBagToObject(bag) { + if (!(bag instanceof Ci.nsIPropertyBag)) { + throw new TypeError("Not a property bag"); + } + let result = {}; + for (let { name, value } of bag.enumerator) { + result[name] = value; + } + return result; +} + +var modalType; +var tabSubDialogsEnabled = SpecialPowers.Services.prefs.getBoolPref( + "prompts.tabChromePromptSubDialog", + false +); +var contentSubDialogsEnabled = SpecialPowers.Services.prefs.getBoolPref( + "prompts.contentPromptSubDialog", + false +); +var isSelectDialog = false; +var isOSX = "nsILocalFileMac" in SpecialPowers.Ci; +var isE10S = SpecialPowers.Services.appinfo.processType == 2; + +var gChromeScript = SpecialPowers.loadChromeScript( + SimpleTest.getTestFileURL("chromeScript.js") +); +SimpleTest.registerCleanupFunction(() => gChromeScript.destroy()); + +async function runPromptCombinations(window, testFunc) { + let util = new PromptTestUtil(window); + let run = () => { + info( + `Running tests (modalType=${modalType}, usePromptService=${util.usePromptService}, useBrowsingContext=${util.useBrowsingContext}, useAsync=${util.useAsync})` + ); + return testFunc(util); + }; + + // Prompt service with dom window parent only supports window prompts + util.usePromptService = true; + util.useBrowsingContext = false; + util.modalType = Ci.nsIPrompt.MODAL_TYPE_WINDOW; + modalType = util.modalType; + util.useAsync = false; + await run(); + + let modalTypes = [ + Ci.nsIPrompt.MODAL_TYPE_WINDOW, + Ci.nsIPrompt.MODAL_TYPE_TAB, + Ci.nsIPrompt.MODAL_TYPE_CONTENT, + ]; + + for (let type of modalTypes) { + util.modalType = type; + modalType = type; + + // Prompt service with browsing context sync + util.usePromptService = true; + util.useBrowsingContext = true; + util.useAsync = false; + await run(); + + // Prompt service with browsing context async + util.usePromptService = true; + util.useBrowsingContext = true; + util.useAsync = true; + await run(); + + // nsIPrompt + // modalType is set via nsIWritablePropertyBag (legacy) + util.usePromptService = false; + util.useBrowsingContext = false; + util.useAsync = false; + await run(); + } +} + +class PromptTestUtil { + constructor(window) { + this.window = window; + this.browsingContext = SpecialPowers.wrap( + window + ).windowGlobalChild.browsingContext; + this.promptService = SpecialPowers.Services.prompt; + this.nsPrompt = Cc["@mozilla.org/prompter;1"] + .getService(Ci.nsIPromptFactory) + .getPrompt(window, Ci.nsIPrompt); + + this.usePromptService = null; + this.useBrowsingContext = null; + this.useAsync = null; + this.modalType = null; + } + + get _prompter() { + if (this.usePromptService) { + return this.promptService; + } + return this.nsPrompt; + } + + async prompt(funcName, promptArgs) { + if ( + this.useBrowsingContext == null || + this.usePromptService == null || + this.useAsync == null || + this.modalType == null + ) { + throw new Error("Not initialized"); + } + let args = []; + if (this.usePromptService) { + if (this.useBrowsingContext) { + if (this.useAsync) { + funcName = `async${funcName[0].toUpperCase()}${funcName.substring( + 1 + )}`; + } else { + funcName += "BC"; + } + args = [this.browsingContext, this.modalType]; + } else { + args = [this.window]; + } + } else { + let bag = this.nsPrompt.QueryInterface(Ci.nsIWritablePropertyBag2); + bag.setPropertyAsUint32("modalType", this.modalType); + } + // Append the prompt arguments + args = args.concat(promptArgs); + + let interfaceName = this.usePromptService ? "Services.prompt" : "prompt"; + ok( + this._prompter[funcName], + `${interfaceName} should have method ${funcName}.` + ); + + info(`Calling ${interfaceName}.${funcName}(${args})`); + let result = this._prompter[funcName](...args); + is( + this.useAsync, + result != null && + result.constructor != null && + result.constructor.name === "Promise", + "If method is async it should return a promise." + ); + + if (this.useAsync) { + let propBag = await result; + return propBag && propBagToObject(propBag); + } + return result; + } +} + +function onloadPromiseFor(id) { + var iframe = document.getElementById(id); + return new Promise(resolve => { + iframe.addEventListener( + "load", + function(e) { + resolve(true); + }, + { once: true } + ); + }); +} + +/** + * Take an action on the next prompt that appears without checking the state in advance. + * This is useful when the action doesn't depend on which prompt is shown and you + * are expecting multiple prompts at once in an indeterminate order. + * If you know the state of the prompt you expect you should use `handlePrompt` instead. + * @param {object} action defining how to handle the prompt + * @returns {Promise} resolving with the prompt state. + */ +function handlePromptWithoutChecks(action) { + return new Promise(resolve => { + gChromeScript.addMessageListener("promptHandled", function handled(msg) { + gChromeScript.removeMessageListener("promptHandled", handled); + resolve(msg.promptState); + }); + gChromeScript.sendAsyncMessage("handlePrompt", { action, modalType }); + }); +} + +async function handlePrompt(state, action) { + let actualState = await handlePromptWithoutChecks(action); + checkPromptState(actualState, state); +} + +function checkPromptState(promptState, expectedState) { + info(`checkPromptState: Expected: ${expectedState.msg}`); + // XXX check title? OS X has title in content + is(promptState.msg, expectedState.msg, "Checking expected message"); + + let isOldContentPrompt = + !promptState.isSubDialogPrompt && + modalType === Ci.nsIPrompt.MODAL_TYPE_CONTENT; + + if (isOldContentPrompt && !promptState.showCallerOrigin) { + ok( + promptState.titleHidden, + "The title should be hidden for content prompts opened with tab modal prompt." + ); + } else if ( + isOSX || + promptState.isSubDialogPrompt || + promptState.showCallerOrigin + ) { + ok( + !promptState.titleHidden, + "Checking title always visible on OS X or when opened with common dialog" + ); + } else { + is( + promptState.titleHidden, + expectedState.titleHidden, + "Checking title visibility" + ); + } + is( + promptState.textHidden, + expectedState.textHidden, + "Checking textbox visibility" + ); + is( + promptState.passHidden, + expectedState.passHidden, + "Checking passbox visibility" + ); + is( + promptState.checkHidden, + expectedState.checkHidden, + "Checking checkbox visibility" + ); + is(promptState.checkMsg, expectedState.checkMsg, "Checking checkbox label"); + is(promptState.checked, expectedState.checked, "Checking checkbox checked"); + if ( + modalType === Ci.nsIPrompt.MODAL_TYPE_WINDOW || + (modalType === Ci.nsIPrompt.MODAL_TYPE_TAB && tabSubDialogsEnabled) + ) { + is( + promptState.iconClass, + expectedState.iconClass, + "Checking expected icon CSS class" + ); + } + is(promptState.textValue, expectedState.textValue, "Checking textbox value"); + is(promptState.passValue, expectedState.passValue, "Checking passbox value"); + + if (expectedState.butt0Label) { + is( + promptState.butt0Label, + expectedState.butt0Label, + "Checking accept-button label" + ); + } + if (expectedState.butt1Label) { + is( + promptState.butt1Label, + expectedState.butt1Label, + "Checking cancel-button label" + ); + } + if (expectedState.butt2Label) { + is( + promptState.butt2Label, + expectedState.butt2Label, + "Checking extra1-button label" + ); + } + + // For prompts with a time-delay button. + if (expectedState.butt0Disabled) { + is(promptState.butt0Disabled, true, "Checking accept-button is disabled"); + is( + promptState.butt1Disabled, + false, + "Checking cancel-button isn't disabled" + ); + } + + is( + promptState.defButton0, + expectedState.defButton == "button0", + "checking button0 default" + ); + is( + promptState.defButton1, + expectedState.defButton == "button1", + "checking button1 default" + ); + is( + promptState.defButton2, + expectedState.defButton == "button2", + "checking button2 default" + ); + + if ( + isOSX && + expectedState.focused && + expectedState.focused.startsWith("button") && + !promptState.infoRowHidden + ) { + is( + promptState.focused, + "infoBody", + "buttons don't focus on OS X, but infoBody does instead" + ); + } else { + is(promptState.focused, expectedState.focused, "Checking focused element"); + } + + if (expectedState.hasOwnProperty("chrome")) { + is( + promptState.chrome, + expectedState.chrome, + "Dialog should be opened as chrome" + ); + } + if (expectedState.hasOwnProperty("dialog")) { + is( + promptState.dialog, + expectedState.dialog, + "Dialog should be opened as a dialog" + ); + } + if (expectedState.hasOwnProperty("chromeDependent")) { + is( + promptState.chromeDependent, + expectedState.chromeDependent, + "Dialog should be opened as dependent" + ); + } + if (expectedState.hasOwnProperty("isWindowModal")) { + is( + promptState.isWindowModal, + expectedState.isWindowModal, + "Dialog should be modal" + ); + } +} + +function checkEchoedAuthInfo(expectedState, browsingContext) { + return SpecialPowers.spawn( + browsingContext, + [expectedState.user, expectedState.pass], + (expectedUser, expectedPass) => { + let doc = this.content.document; + + // The server echos back the HTTP auth info it received. + let username = doc.getElementById("user").textContent; + let password = doc.getElementById("pass").textContent; + let authok = doc.getElementById("ok").textContent; + + Assert.equal(authok, "PASS", "Checking for successful authentication"); + Assert.equal(username, expectedUser, "Checking for echoed username"); + Assert.equal(password, expectedPass, "Checking for echoed password"); + } + ); +} + +/** + * Create a Proxy to relay method calls on an nsIAuthPrompt[2] prompter to a chrome script which can + * perform the calls in the parent. Out and inout params will be copied back from the parent to + * content. + * + * @param chromeScript The reference to the chrome script that will listen to `proxyPrompter` + * messages in the parent and call the `methodName` method. + * The return value from the message handler should be an object with properties: + * `rv` - containing the return value of the method call. + * `args` - containing the array of arguments passed to the method since out or inout ones could have + * been modified. + */ +function PrompterProxy(chromeScript) { + return new Proxy( + {}, + { + get(target, prop, receiver) { + return (...args) => { + // Array of indices of out/inout params to copy from the parent back to the caller. + let outParams = []; + + switch (prop) { + case "prompt": { + outParams = [/* result */ 5]; + break; + } + case "promptAuth": { + outParams = []; + break; + } + case "promptPassword": { + outParams = [/* pwd */ 4]; + break; + } + case "promptUsernameAndPassword": { + outParams = [/* user */ 4, /* pwd */ 5]; + break; + } + default: { + throw new Error("Unknown nsIAuthPrompt method"); + } + } + + let result; + chromeScript + .sendQuery("proxyPrompter", { + args, + methodName: prop, + }) + .then(val => { + result = val; + }); + SpecialPowers.Services.tm.spinEventLoopUntil( + "Test(prompt_common.js:get)", + () => result + ); + + for (let outParam of outParams) { + // Copy the out or inout param value over the original + args[outParam].value = result.args[outParam].value; + } + + if (prop == "promptAuth") { + args[2].username = result.args[2].username; + args[2].password = result.args[2].password; + args[2].domain = result.args[2].domain; + } + + return result.rv; + }; + }, + } + ); +} diff --git a/toolkit/components/prompts/test/test_bug619644.html b/toolkit/components/prompts/test/test_bug619644.html new file mode 100644 index 0000000000..2b424c71a6 --- /dev/null +++ b/toolkit/components/prompts/test/test_bug619644.html @@ -0,0 +1,74 @@ +<!DOCTYPE HTML> +<html> +<!-- +https://bugzilla.mozilla.org/show_bug.cgi?id=619644 +--> +<head> + <title>Test for Bug 619644</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="prompt_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=619644">Mozilla Bug 619644</a> +<pre id="test"> +<script class="testbody" type="text/javascript"> +// This is a little yucky, but it works +// The contents of bug619644_inner.html +const expectedFinalDoc = +"<head><\/head><body><p>Original content<\/p>\n<script>\n window.opener.postMessage(\"\", \"*\");\n confirm(\"Message\");\n document.write(\"Extra content\");\n window.opener.postMessage(document.documentElement.innerHTML, \"*\");\n<\/script>Extra content<\/body>"; + +inittest(); + +var promptDone; + +function inittest() { + window.addEventListener("message", runtest); + window.open("bug619644_inner.html", "619644"); + + SimpleTest.waitForExplicitFinish(); +} + +function runtest(e) { + modalType = Ci.nsIPrompt.MODAL_TYPE_CONTENT; + + window.removeEventListener("message", runtest); + window.addEventListener("message", checktest); + + let state = { + msg: "Message", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + let action = { + buttonClick: "ESC", + }; + + promptDone = handlePrompt(state, action); +} + +function checktest(e) { + is(e.data, expectedFinalDoc, "ESC press should not abort document load"); + e.source.close(); + promptDone.then(endtest); +} + +function endtest() { + info("Ending test"); + SimpleTest.finish(); +} +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/prompts/test/test_bug620145.html b/toolkit/components/prompts/test/test_bug620145.html new file mode 100644 index 0000000000..3894a528ae --- /dev/null +++ b/toolkit/components/prompts/test/test_bug620145.html @@ -0,0 +1,96 @@ +<html> +<head> + <title>Test for Bug 620145</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="prompt_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=620145">Mozilla Bug 620145</a> +<pre id="test"> +</pre> + +<div id="text" style="max-width: 100px" onmouseup="openAlert()"> + This is a short piece of text used for testing that mouse selecting is + stopped when an alert appears. +</div> +<div id="text2" style="max-width: 100px"> + This is another short piece of text used for testing that mouse selecting is + stopped when an alert appears. +</div> +<button id="button" onmouseup="openAlert()">Button</button> + +<script class="testbody" type="text/javascript"> + +function openAlert() { + info("opening alert..."); + alert("hello!"); + info("...alert done."); +} + +add_task(async function runTest() { + var state, action; + // The <button> in this test's HTML opens a prompt when clicked. + // Here we send the events to simulate clicking it. + modalType = Ci.nsIPrompt.MODAL_TYPE_CONTENT; + + state = { + msg: "hello!", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + var button = $("button"); + dispatchMouseEvent(button, "mousedown"); + dispatchMouseEvent(button, "mouseup"); + // alert appears at this point, to be closed by the chrome script. + + await promptDone; + checkSelection(); + + // using same state and action. + promptDone = handlePrompt(state, action); + + var text = $("text"); + dispatchMouseEvent(text, "mousedown"); + dispatchMouseEvent(text, "mouseup"); + // alert appears at this point, to be closed by the chrome script. + + await promptDone; + checkSelection(); +}); + +function dispatchMouseEvent(target, type) { + var win = target.ownerDocument.defaultView; + let e = document.createEvent("MouseEvent"); + e.initEvent(type, false, false, win, 0, 1, 1, 1, 1, + false, false, false, false, 0, null); + var utils = SpecialPowers.getDOMWindowUtils(win); + utils.dispatchDOMEventViaPresShellForTesting(target, e); + ok(true, type + " sent to " + target.id); +} + +function checkSelection() { + synthesizeMouse($("text"), 25, 55, { type: "mousemove" }); + is(window.getSelection().toString(), "", "selection not made"); +} +</script> + +</body> +</html> diff --git a/toolkit/components/prompts/test/test_dom_prompts.html b/toolkit/components/prompts/test/test_dom_prompts.html new file mode 100644 index 0000000000..95595b8df2 --- /dev/null +++ b/toolkit/components/prompts/test/test_dom_prompts.html @@ -0,0 +1,207 @@ +<html> +<head> + <title>Test for DOM prompts</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="prompt_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" /> +</head> +<body> +<pre id="test"> +</pre> + +<script class="testbody" type="text/javascript"> +var rv; +var state, action; +modalType = Ci.nsIPrompt.MODAL_TYPE_CONTENT; + +add_task(async function test_alert_ok() { + info("Starting test: Alert"); + state = { + msg: "This is the alert text.", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + alert("This is the alert text."); + + await promptDone; +}); + +// bug 861605 made the arguments to alert/confirm optional (prompt already was). +add_task(async function test_alert_noargs() { + info("Starting test: Alert with no args"); + state = { + msg: "", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + try { + alert(); + ok(true, "alert() without arguments should not throw!"); + } catch (e) { + ok(false, "alert() without arguments should not throw!"); + } + + await promptDone; +}); + +add_task(async function test_confirm_ok() { + info("Starting test: Confirm"); + state = { + msg: "This is the confirm text.", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + rv = confirm("This is the confirm text."); + is(rv, true, "check prompt return value"); + + await promptDone; +}); + +// bug 861605 made the arguments to alert/confirm optional (prompt already was). +add_task(async function test_confirm_noargs() { + info("Starting test: Confirm with no args"); + state = { + msg: "", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + try { + rv = confirm(); + ok(true, "confirm() without arguments should not throw!"); + } catch (e) { + ok(false, "confirm() without arguments should not throw!"); + } + is(rv, true, "check prompt return value"); + + await promptDone; +}); + + +add_task(async function test_prompt_ok() { + info("Starting test: Prompt"); + state = { + msg: "This is the Prompt text.", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + rv = prompt("This is the Prompt text."); + is(rv, "", "check prompt return value"); + + await promptDone; +}); + +// bug 861605 made the arguments to alert/confirm optional (prompt already was). +add_task(async function test_prompt_noargs() { + info("Starting test: Prompt with no args"); + state = { + msg: "", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + try { + rv = prompt(); + ok(true, "prompt() without arguments should not throw!"); + } catch (e) { + ok(false, "prompt() without arguments should not throw!"); + } + is(rv, "", "check prompt return value"); + + await promptDone; +}); + +</script> + +</body> +</html> diff --git a/toolkit/components/prompts/test/test_modal_prompts.html b/toolkit/components/prompts/test/test_modal_prompts.html new file mode 100644 index 0000000000..df3438dbba --- /dev/null +++ b/toolkit/components/prompts/test/test_modal_prompts.html @@ -0,0 +1,1311 @@ + +<!DOCTYPE HTML> +<html> +<head> + <title>Modal Prompts Test</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="prompt_common.js"></script> +</head> +<body> +Prompter tests: modal prompts +<p id="display"></p> + +<div id="content" style="display: none"> + <iframe id="iframe"></iframe> +</div> + +<pre id="test"> +<script class="testbody" type="text/javascript"> +/* eslint-disable complexity */ +async function runTests(util) { + const { NetUtil } = SpecialPowers.ChromeUtils.import( + "resource://gre/modules/NetUtil.jsm" + ); + + // The ConfirmEx + delay test has slightly different behavior with the focus + // fixup rule vs. without. + await SpecialPowers.pushPrefEnv({ + set: [["dom.focus.fixup", true]], + }); + + let state, action, promptDone; + + let checkVal = {}; + let textVal = {}; + let passVal = {}; + let flags; + let isOK; + + // ===== + info("Starting test: Alert"); + state = { + msg: "This is the alert text.", + title: "TestTitle", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + promptDone = handlePrompt(state, action); + + promptArgs = ["TestTitle", "This is the alert text."]; + await util.prompt("alert", promptArgs); + + await promptDone; + + // ===== + info("Starting test: AlertCheck (null checkbox label, so it's hidden)"); + state = { + msg: "This is the alertCheck text.", + title: "TestTitle", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + promptDone = handlePrompt(state, action); + + promptArgs = [ + "TestTitle", + "This is the alertCheck text.", + null, + util.useAsync ? false : {}, + ]; + util.prompt("alertCheck", promptArgs); + + await promptDone; + + // ===== + info("Starting test: AlertCheck"); + state = { + msg: "This is the alertCheck text.", + title: "TestTitle", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: false, + textValue: "", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the alertCheck text.", + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + let result = await util.prompt("alertCheck", promptArgs); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "checkbox was checked" + ); + + await promptDone; + + // ===== + info("Starting test: Confirm (ok)"); + state = { + msg: "This is the confirm text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + promptDone = handlePrompt(state, action); + + promptArgs = ["TestTitle", "This is the confirm text."]; + result = await util.prompt("confirm", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + + await promptDone; + + // ===== + info("Starting test: Confirm (cancel)"); + state = { + msg: "This is the confirm text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + }; + + promptDone = handlePrompt(state, action); + + promptArgs = ["TestTitle", "This is the confirm text."]; + result = await util.prompt("confirm", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + + await promptDone; + + // ===== + info("Starting test: ConfirmCheck (ok, null checkbox label)"); + state = { + msg: "This is the confirmCheck text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + promptDone = handlePrompt(state, action); + + promptArgs = [ + "TestTitle", + "This is the confirmCheck text.", + null, + util.useAsync ? false : {}, + ]; + result = await util.prompt("confirmCheck", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + + await promptDone; + + // ===== + info("Starting test: ConfirmCheck (cancel, null checkbox label)"); + state = { + msg: "This is the confirmCheck text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + }; + + promptDone = handlePrompt(state, action); + + promptArgs = [ + "TestTitle", + "This is the confirmCheck text.", + null, + util.useAsync ? false : {}, + ]; + result = await util.prompt("confirmCheck", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + + await promptDone; + + // ===== + info("Starting test: ConfirmCheck (ok)"); + state = { + msg: "This is the confirmCheck text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: false, + textValue: "", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the confirmCheck text.", + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("confirmCheck", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + info("Starting test: ConfirmCheck (cancel)"); + state = { + msg: "This is the confirmCheck text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: false, + textValue: "", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the confirmCheck text.", + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("confirmCheck", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + info("Starting test: Prompt (ok, no default text)"); + state = { + msg: "This is the prompt text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + textField: "bacon", + }; + + promptDone = handlePrompt(state, action); + + textVal.value = ""; + promptArgs = ["TestTitle", "This is the prompt text.", util.useAsync ? textVal.value : textVal , null, util.useAsync ? false : {}]; + result = await util.prompt("prompt", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is( + util.useAsync ? result.value : textVal.value, + "bacon", + "checking expected text value" + ); + + await promptDone; + + // ===== + info("Starting test: Prompt (ok, default text)"); + state = { + msg: "This is the prompt text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: true, + textValue: "kittens", + passValue: "", + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + promptDone = handlePrompt(state, action); + + textVal.value = "kittens"; + promptArgs = ["TestTitle", "This is the prompt text.", util.useAsync ? textVal.value : textVal, null, util.useAsync ? false : {}]; + result = await util.prompt("prompt", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is( + util.useAsync ? result.value : textVal.value, + "kittens", + "checking expected text value" + ); + + await promptDone; + + // ===== + info("Starting test: Prompt (cancel, default text)"); + state = { + msg: "This is the prompt text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: true, + textValue: "puppies", + passValue: "", + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + }; + + promptDone = handlePrompt(state, action); + + textVal.value = "puppies"; + promptArgs = ["TestTitle", "This is the prompt text.", util.useAsync ? textVal.value : textVal, null, util.useAsync ? false : {}]; + result = await util.prompt("prompt", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + is( + util.useAsync ? result.value : textVal.value, + "puppies", + "checking expected text value" + ); + + await promptDone; + + // ===== + info("Starting test: Prompt (cancel, default text modified)"); + state = { + msg: "This is the prompt text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: true, + textValue: "puppies", + passValue: "", + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + textField: "bacon", + }; + + promptDone = handlePrompt(state, action); + + textVal.value = "puppies"; + promptArgs = ["TestTitle", "This is the prompt text.", util.useAsync ? textVal.value : textVal, null, util.useAsync ? false : {}]; + result = await util.prompt("prompt", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + is( + util.useAsync ? result.value : textVal.value, + "puppies", + "checking expected text value" + ); + + await promptDone; + + // ===== + info("Starting test: Prompt (ok, with checkbox)"); + state = { + msg: "This is the prompt text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: false, + textValue: "tribbles", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + textVal.value = "tribbles"; + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the prompt text.", + util.useAsync ? textVal.value : textVal, + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("prompt", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is( + util.useAsync ? result.value : textVal.value, + "tribbles", + "checking expected text value" + ); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + info("Starting test: Prompt (cancel, with checkbox)"); + state = { + msg: "This is the prompt text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: false, + passHidden: true, + checkHidden: false, + textValue: "tribbles", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + setCheckbox: true, + }; + promptDone = handlePrompt(state, action); + + textVal.value = "tribbles"; + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the prompt text.", + util.useAsync ? textVal.value : textVal, + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("prompt", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + is( + util.useAsync ? result.value : textVal.value, + "tribbles", + "checking expected text value" + ); + ok( + util.useAsync ? result.checked : !checkVal.value, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + // Just two tests for this, since password manager already tests this extensively. + info("Starting test: PromptUsernameAndPassword (ok)"); + state = { + msg: "This is the pUAP text.", + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "usr", + passValue: "ssh", + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + textField: "newusr", + passField: "newssh", + }; + + promptDone = handlePrompt(state, action); + + textVal.value = "usr"; + passVal.value = "ssh"; + promptArgs = [ + "TestTitle", + "This is the pUAP text.", + util.useAsync ? textVal.value : textVal, + util.useAsync ? passVal.value : passVal + ]; + result = await util.prompt("promptUsernameAndPassword", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is( + util.useAsync ? result.user : textVal.value, + "newusr", + "checking expected text value" + ); + is( + util.useAsync ? result.pass : passVal.value, + "newssh", + "checking expected pass value" + ); + + await promptDone; + + // ===== + info("Starting test: PromptUsernameAndPassword (cancel)"); + state = { + msg: "This is the pUAP text.", + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "usr", + passValue: "ssh", + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + textField: "newusr", + passField: "newssh", + }; + + promptDone = handlePrompt(state, action); + + textVal.value = "usr"; + passVal.value = "ssh"; + promptArgs = [ + "TestTitle", + "This is the pUAP text.", + util.useAsync ? textVal.value : textVal, + util.useAsync ? passVal.value : passVal + ]; + result = await util.prompt("promptUsernameAndPassword", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + ok( + (util.useAsync && result.user == "newusr") || textVal.value == "usr", + "checking expected text value" + ); + ok( + (util.useAsync && result.pass == "newpass") || passVal.value == "ssh", + "checking expected pass value" + ); + + await promptDone; + + // ===== + info("Starting test: PromptPassword (ok)"); + state = { + msg: "This is the promptPassword text.", + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: true, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "", + passValue: "ssh", + focused: "passField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + passField: "newssh", + }; + + promptDone = handlePrompt(state, action); + + passVal.value = "ssh"; + promptArgs = [ + "TestTitle", + "This is the promptPassword text.", + util.useAsync ? passVal.value : passVal + ]; + result = await util.prompt("promptPassword", promptArgs); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is( + util.useAsync ? result.pass : passVal.value, + "newssh", + "checking expected pass value" + ); + + await promptDone; + + // ===== + info("Starting test: PromptPassword (cancel)"); + state = { + msg: "This is the promptPassword text.", + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: true, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "", + passValue: "ssh", + focused: "passField", + defButton: "button0", + }; + action = { + buttonClick: "cancel", + passField: "newssh", + }; + + promptDone = handlePrompt(state, action); + + passVal.value = "ssh"; + promptArgs = [ + "TestTitle", + "This is the promptPassword text.", + util.useAsync ? passVal.value : passVal + ]; + result = await util.prompt("promptPassword", promptArgs); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + ok( + (util.useAsync && result.pass == "newssh") || passVal.value == "ssh", + "checking expected pass value" + ); + + await promptDone; + + // ===== + info("Starting test: ConfirmEx (ok/cancel, ok)"); + state = { + msg: "This is the confirmEx text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + butt0Label: "OK", + butt1Label: "Cancel", + }; + action = { + buttonClick: "ok", + }; + + promptDone = handlePrompt(state, action); + + flags = Ci.nsIPromptService.STD_OK_CANCEL_BUTTONS; + promptArgs = [ + "TestTitle", + "This is the confirmEx text.", + flags, + null, + null, + null, + null, + util.useAsync ? false : {}, + ]; + result = await util.prompt("confirmEx", promptArgs); + is( + util.useAsync ? result.buttonNumClicked : result, + 0, + "checked expected button num click" + ); + + await promptDone; + + // ===== + info("Starting test: ConfirmEx (yes/no, cancel)"); + state = { + msg: "This is the confirmEx text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + butt0Label: "Yes", + butt1Label: "No", + }; + action = { + buttonClick: "cancel", + }; + + promptDone = handlePrompt(state, action); + + flags = Ci.nsIPromptService.STD_YES_NO_BUTTONS; + promptArgs = [ + "TestTitle", + "This is the confirmEx text.", + flags, + null, + null, + null, + null, + util.useAsync ? false : {}, + ]; + result = await util.prompt("confirmEx", promptArgs); + is( + util.useAsync ? result.buttonNumClicked : result, + 1, + "checked expected button num click" + ); + + await promptDone; + + // ===== + info("Starting test: ConfirmEx (buttons from args, checkbox, ok)"); + state = { + msg: "This is the confirmEx text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: false, + textValue: "", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "button0", + defButton: "button0", + butt0Label: "butt0", + butt1Label: "butt1", + butt2Label: "butt2", + }; + action = { + buttonClick: "ok", + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + let b = Ci.nsIPromptService.BUTTON_TITLE_IS_STRING; + flags = + b * Ci.nsIPromptService.BUTTON_POS_2 + + b * Ci.nsIPromptService.BUTTON_POS_1 + + b * Ci.nsIPromptService.BUTTON_POS_0; + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the confirmEx text.", + flags, + "butt0", + "butt1", + "butt2", + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("confirmEx", promptArgs); + is( + util.useAsync ? result.buttonNumClicked : result, + 0, + "checked expected button num click" + ); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + info("Starting test: ConfirmEx (buttons from args, checkbox, cancel)"); + state = { + msg: "This is the confirmEx text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: false, + textValue: "", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "button1", // Default changed! + defButton: "button1", + butt0Label: "butt0", + butt1Label: "butt1", + butt2Label: "butt2", + }; + action = { + buttonClick: "cancel", + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + b = Ci.nsIPromptService.BUTTON_TITLE_IS_STRING; + flags = + b * Ci.nsIPromptService.BUTTON_POS_2 + + b * Ci.nsIPromptService.BUTTON_POS_1 + + b * Ci.nsIPromptService.BUTTON_POS_0; + flags ^= Ci.nsIPromptService.BUTTON_POS_1_DEFAULT; + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the confirmEx text.", + flags, + "butt0", + "butt1", + "butt2", + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("confirmEx", promptArgs); + is( + util.useAsync ? result.buttonNumClicked : result, + 1, + "checked expected button num click" + ); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + info("Starting test: ConfirmEx (buttons from args, checkbox, button3)"); + state = { + msg: "This is the confirmEx text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: false, + textValue: "", + passValue: "", + checkMsg: "Check me out!", + checked: false, + focused: "button2", // Default changed! + defButton: "button2", + butt0Label: "butt0", + butt1Label: "butt1", + butt2Label: "butt2", + }; + action = { + buttonClick: 2, + setCheckbox: true, + }; + + promptDone = handlePrompt(state, action); + + b = Ci.nsIPromptService.BUTTON_TITLE_IS_STRING; + flags = + b * Ci.nsIPromptService.BUTTON_POS_2 + + b * Ci.nsIPromptService.BUTTON_POS_1 + + b * Ci.nsIPromptService.BUTTON_POS_0; + flags ^= Ci.nsIPromptService.BUTTON_POS_2_DEFAULT; + checkVal.value = false; + promptArgs = [ + "TestTitle", + "This is the confirmEx text.", + flags, + "butt0", + "butt1", + "butt2", + "Check me out!", + util.useAsync ? checkVal.value : checkVal, + ]; + result = await util.prompt("confirmEx", promptArgs); + is( + util.useAsync ? result.buttonNumClicked : result, + 2, + "checked expected button num click" + ); + is( + util.useAsync ? result.checked : checkVal.value, + true, + "expected checkbox setting" + ); + + await promptDone; + + // ===== + // (skipped for E10S and tabmodal tests: window is required) + info("Starting test: Alert, no window"); + state = { + msg: "This is the alert text.", + title: "TestTitle", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + if (util.modalType === Ci.nsIPrompt.MODAL_TYPE_WINDOW && !isE10S) { + promptDone = handlePrompt(state, action); + + promptArgs = ["TestTitle", "This is the alert text."]; + await util.prompt("alert", promptArgs); + + await promptDone; + } + + // ===== + // (skipped for tabmodal tests: delay not supported) + info("Starting test: ConfirmEx (delay, ok)"); + state = { + msg: "This is the confirmEx delay text.", + title: "TestTitle", + iconClass: "question-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: null, // Nothing focused until the delay triggers. + defButton: "button0", + butt0Label: "OK", + butt1Label: "Cancel", + butt0Disabled: true, + }; + + if (isOSX) { + // OS X doesn't initially focus the button, but rather the infoBody. + // The focus stays there even after the button-enable delay has fired. + state.focused = "infoBody"; + } + + action = { + buttonClick: "pollOK", + }; + if (util.modalType === Ci.nsIPrompt.MODAL_TYPE_WINDOW) { + promptDone = handlePrompt(state, action); + + flags = + Ci.nsIPromptService.STD_OK_CANCEL_BUTTONS | + Ci.nsIPromptService.BUTTON_DELAY_ENABLE; + promptArgs = [ + "TestTitle", + "This is the confirmEx delay text.", + flags, + null, + null, + null, + null, + util.useAsync ? false : {}, + ]; + result = await util.prompt("confirmEx", promptArgs); + is( + util.useAsync ? result.buttonNumClicked : result, + 0, + "checked expected button num click" + ); + + await promptDone; + } + + // promptAuth already tested via password manager but do a few specific things here. + var channel = NetUtil.newChannel({ + uri: "http://example.com", + loadUsingSystemPrincipal: true, + }); + + var level = Ci.nsIAuthPrompt2.LEVEL_NONE; + var authinfo = { + username: "", + password: "", + domain: "", + flags: Ci.nsIAuthInformation.AUTH_HOST, + authenticationScheme: "basic", + realm: "", + }; + + let msg = + util.modalType == Ci.nsIPrompt.MODAL_TYPE_TAB + ? "This site is asking you to sign in." + : "http://example.com is requesting your username and password."; + // ===== + // (promptAuth is only accessible from the prompt service) + info("Starting test: promptAuth with empty realm"); + state = { + msg, + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "", + passValue: "", + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + textField: "username", + passField: "password", + }; + if (util.usePromptService && !util.useAsync) { + promptDone = handlePrompt(state, action); + + promptArgs = [channel, level, authinfo]; + isOK = await util.prompt("promptAuth", promptArgs); + is(isOK, true, "checked expected retval"); + is(authinfo.username, "username", "checking filled username"); + is(authinfo.password, "password", "checking filled password"); + + await promptDone; + } + + // ===== + // (promptAuth is only accessible from the prompt service) + msg = + util.modalType == Ci.nsIPrompt.MODAL_TYPE_TAB + ? "This site is asking you to sign in." + : "http://example.com is requesting your username and password. The site " + + "says: \u201cabcdefghi abcdefghi abcdefghi abcdefghi abcdefghi abcdefghi abcdefghi " + + "abcdefghi abcdefghi abcdefghi abcdefghi abcdefghi abcdefghi abcdefghi " + + "abcdefghi \u2026\u201d"; + + info("Starting test: promptAuth with long realm"); + state = { + msg, + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "", + passValue: "", + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + textField: "username", + passField: "password", + }; + if (util.usePromptService && !util.useAsync) { + promptDone = handlePrompt(state, action); + + var longString = ""; + for (var i = 0; i < 20; i++) longString += "abcdefghi "; // 200 chars long + authinfo.realm = longString; + authinfo.username = ""; + authinfo.password = ""; + promptArgs = [channel, level, authinfo]; + isOK = await util.prompt("promptAuth", promptArgs); + is(isOK, true, "checked expected retval"); + is(authinfo.username, "username", "checking filled username"); + is(authinfo.password, "password", "checking filled password"); + + await promptDone; + } + + msg = + util.modalType == Ci.nsIPrompt.MODAL_TYPE_TAB + ? ("This site is asking you to sign in. Warning: Your login information " + + "will be shared with example.com, not the website you are currently visiting.") + : ("http://example.com is requesting your username and password. " + + "WARNING: Your password will not be sent to the website you are currently visiting!"); + info("Starting test: promptAuth for a cross-origin and a empty realm"); + authinfo = { + username: "", + password: "", + domain: "", + flags: + Ci.nsIAuthInformation.AUTH_HOST | + Ci.nsIAuthInformation.CROSS_ORIGIN_SUB_RESOURCE, + authenticationScheme: "basic", + realm: "", + }; + state = { + msg, + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "", + passValue: "", + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + textField: "username", + passField: "password", + }; + if (util.usePromptService && !util.useAsync) { + promptDone = handlePrompt(state, action); + promptArgs = [channel, level, authinfo]; + isOK = await util.prompt("promptAuth", promptArgs); + is(isOK, true, "checked expected retval"); + is(authinfo.username, "username", "checking filled username"); + is(authinfo.password, "password", "checking filled password"); + + await promptDone; + } + + info("Starting test: promptAuth for a cross-origin with realm"); + authinfo = { + username: "", + password: "", + domain: "", + flags: + Ci.nsIAuthInformation.AUTH_HOST | + Ci.nsIAuthInformation.CROSS_ORIGIN_SUB_RESOURCE, + authenticationScheme: "basic", + realm: "Something!!!", + }; + state = { + msg, // Same as previous test, see above. + title: "TestTitle", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + textValue: "", + passValue: "", + focused: "textField", + defButton: "button0", + }; + action = { + buttonClick: "ok", + textField: "username", + passField: "password", + }; + if (util.usePromptService && !util.useAsync) { + promptDone = handlePrompt(state, action); + + promptArgs = [channel, level, authinfo]; + isOK = await util.prompt("promptAuth", promptArgs); + is(isOK, true, "checked expected retval"); + is(authinfo.username, "username", "checking filled username"); + is(authinfo.password, "password", "checking filled password"); + + await promptDone; + } +} + +let promptArgs; + +add_task(async function runPromptTests() { + await runPromptCombinations(window, runTests); +}); +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/prompts/test/test_modal_select.html b/toolkit/components/prompts/test/test_modal_select.html new file mode 100644 index 0000000000..27688cf329 --- /dev/null +++ b/toolkit/components/prompts/test/test_modal_select.html @@ -0,0 +1,138 @@ +<!DOCTYPE HTML> +<html> +<head> + <title>Modal Prompts Test</title> + <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script> + <script type="text/javascript" src="prompt_common.js"></script> +</head> +<body> +Prompter tests: modal prompts +<p id="display"></p> + +<div id="content" style="display: none"> + <iframe id="iframe"></iframe> +</div> + +<pre id="test"> +<script class="testbody" type="text/javascript"> +function checkPromptState(promptState, expectedState) { + // XXX check title? OS X has title in content + // XXX check focused element + // XXX check button labels? + + is(promptState.msg, expectedState.msg, "Checking expected message"); + + // Compare listbox contents + is(promptState.items.length, expectedState.items.length, "Checking listbox length"); + + if (promptState.items.length) + is(promptState.selectedIndex, 0, "Checking selected index"); + + for (let i = 0; i < promptState.items; i++) { + is(promptState.items[i], expectedState.items[i], "Checking list item #" + i); + } +} + +let selectVal = {}; +let isOK; + +function handlePrompt(state, action) { + return new Promise(resolve => { + gChromeScript.addMessageListener("promptHandled", function handled(msg) { + gChromeScript.removeMessageListener("promptHandled", handled); + checkPromptState(msg.promptState, state); + resolve(true); + }); + gChromeScript.sendAsyncMessage("handlePrompt", { action, isSelect: true}); + }); +} + +async function runTests(util) { + // Select prompt does not support tab or content prompts yet. See Bug 1622817. + if(util.modalType != Ci.nsIPrompt.MODAL_TYPE_WINDOW) { + info('Skipping modal type for select prompt...'); + return; + } + + // Empty list + info("Starting test: Select (0 items, ok)"); + let state = { + msg: "This is the select text.", + title: "TestTitle", + items: [], + }; + let action = { + buttonClick: "ok", + }; + let promptDone = handlePrompt(state, action); + let items = []; + selectVal.value = null; // outparam, just making sure. + let result = await util.prompt("select", ["TestTitle", "This is the select text.", items, util.useAsync ? false : selectVal]); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is(util.useAsync ? result.selected : selectVal.value, -1, "checking selected index"); + await promptDone; + + // ok + info("Starting test: Select (3 items, ok)"); + state = { + msg: "This is the select text.", + title: "TestTitle", + items: ["one", "two", "three"], + }; + action = { + buttonClick: "ok", + }; + promptDone = handlePrompt(state, action); + items = ["one", "two", "three"]; + selectVal.value = null; // outparam, just making sure. + result = await util.prompt("select", ["TestTitle", "This is the select text.", items, util.useAsync ? false : selectVal]); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is(util.useAsync ? result.selected : selectVal.value, 0, "checking selected index"); + await promptDone; + + // select item + info("Starting test: Select (3 items, selection changed, ok)"); + state = { + msg: "This is the select text.", + title: "TestTitle", + items: ["one", "two", "three"], + }; + action = { + buttonClick: "ok", + selectItem: 1, + }; + promptDone = handlePrompt(state, action); + items = ["one", "two", "three"]; + selectVal.value = null; // outparam, just making sure. + result = await util.prompt("select", ["TestTitle", "This is the select text.", items, util.useAsync ? false : selectVal]); + is(util.useAsync ? result.ok : result, true, "checked expected retval"); + is(util.useAsync ? result.selected : selectVal.value, 1, "checking selected index"); + await promptDone; + + // cancel prompt + info("Starting test: Select (3 items, cancel)"); + state = { + msg: "This is the select text.", + title: "TestTitle", + items: ["one", "two", "three"], + }; + action = { + buttonClick: "cancel", + }; + promptDone = handlePrompt(state, action); + items = ["one", "two", "three"]; + selectVal.value = null; // outparam, just making sure. + result = await util.prompt("select", ["TestTitle", "This is the select text.", items, util.useAsync ? false : selectVal]); + is(util.useAsync ? result.ok : result, false, "checked expected retval"); + ok(util.useAsync && result.selected == -1 || selectVal.value == 0, "checking selected index"); + await promptDone; +} + +add_task(async function runPromptTests() { + await runPromptCombinations(window, runTests); +}); + +</script> +</pre> +</body> +</html> diff --git a/toolkit/components/prompts/test/test_subresources_prompts.html b/toolkit/components/prompts/test/test_subresources_prompts.html new file mode 100644 index 0000000000..b71ad0694e --- /dev/null +++ b/toolkit/components/prompts/test/test_subresources_prompts.html @@ -0,0 +1,200 @@ +<html> +<head> + <title>Test subresources prompts (Bug 625187 and bug 1230462)</title> + <script type="text/javascript" src="/MochiKit/MochiKit.js"></script> + <script src="/tests/SimpleTest/SimpleTest.js"></script> + <script src="/tests/SimpleTest/EventUtils.js"></script> + <script type="text/javascript" src="prompt_common.js"></script> + <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"> +<!-- + - Any copyright is dedicated to the Public Domain. + - http://creativecommons.org/publicdomain/zero/1.0/ + - + - Contributor(s): + - Mihai Sucan <mihai.sucan@gmail.com> + --> +</head> +<body> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=625187">Mozilla Bug 625187</a> +<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1230462">Mozilla Bug 1230462</a> + +<p><button id="topbutton" onclick="alert('hello world')">Button</button></p> + +<iframe id="iframe_diff_origin" src="http://example.com/tests/toolkit/components/prompts/test/bug625187_iframe.html"></iframe> + +<iframe id="iframe_same_origin" src="bug625187_iframe.html"></iframe> + +<iframe id="iframe_prompt"></iframe> + +<pre id="test"></pre> + +<script class="testbody" type="text/javascript"> +var iframe1Loaded = onloadPromiseFor("iframe_diff_origin"); +var iframe2Loaded = onloadPromiseFor("iframe_same_origin"); +var iframe_prompt = document.getElementById("iframe_prompt"); + +// Depending on pref state we either show auth prompts as windows or on tab level. +let authPromptModalType = SpecialPowers.Services.prefs.getIntPref( + "prompts.modalType.httpAuth" +); + +add_task(async function runTest() { + modalType = Ci.nsIPrompt.MODAL_TYPE_CONTENT; + + info("Ensuring iframe1 has loaded..."); + await iframe1Loaded; + info("Ensuring iframe2 has loaded..."); + await iframe2Loaded; + let state, action; + + state = { + msg: "hello world", + iconClass: "alert-icon", + titleHidden: true, + textHidden: true, + passHidden: true, + checkHidden: true, + textValue: "", + passValue: "", + checkMsg: "", + checked: false, + focused: "button0", + defButton: "button0", + }; + action = { + buttonClick: "ok", + }; + + let promptDone = handlePrompt(state, action); + + await SpecialPowers.spawn(window, ["topbutton", "click"], dispatchMouseEvent); + + await promptDone; + + // mostly reusing same state/action + state.titleHidden = false; + state.msg = "hello world 2"; + promptDone = handlePrompt(state, action); + + var iframe = document.getElementById("iframe_diff_origin"); + await SpecialPowers.spawn(iframe.contentWindow, ["btn1", "click"], dispatchMouseEvent); + + await promptDone; + + // mostly reusing same state/action + state.titleHidden = true; + state.msg = "hello world 2"; + promptDone = handlePrompt(state, action); + + iframe = document.getElementById("iframe_same_origin"); + await SpecialPowers.spawn(iframe.contentWindow, ["btn1", "click"], dispatchMouseEvent); + + await promptDone; + + // mostly reusing same state/action + state.msg = "hello world 3"; + promptDone = handlePrompt(state, action); + await SpecialPowers.spawn(iframe.contentWindow, ["btn2", "click"], dispatchMouseEvent); + + await promptDone; +}); + +add_task(async function runTestAuth() { + // Following tests check prompt message for a cross-origin and not + // cross-origin subresources load + + // Let prompt_common know what kind of modal type is enabled for auth prompts. + modalType = authPromptModalType; + + let state, action; + + state = { + msg: "This site is asking you to sign in.", + title: "Authentication Required", + textValue: "", + passValue: "", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + + action = { + buttonClick: "ok", + setCheckbox: false, + textField: "mochiuser1", + passField: "mochipass1", + }; + + let promptDone = handlePrompt(state, action); + + var iframe3Loaded = onloadPromiseFor("iframe_prompt"); + iframe_prompt.src = "authenticate.sjs?user=mochiuser1&pass=mochipass1"; + await promptDone; + await iframe3Loaded; + await checkEchoedAuthInfo({user: "mochiuser1", pass: "mochipass1"}, + iframe_prompt); + + // Cross-origin subresourse test. + state = { + msg: "This site is asking you to sign in. Warning: Your login information " + + "will be shared with example.com, not the website you are currently visiting.", + title: "Authentication Required", + textValue: "", + passValue: "", + iconClass: "authentication-icon question-icon", + titleHidden: true, + textHidden: false, + passHidden: false, + checkHidden: true, + checkMsg: "", + checked: false, + focused: "textField", + defButton: "button0", + }; + + action = { + buttonClick: "ok", + setCheckbox: false, + textField: "mochiuser2", + passField: "mochipass2", + }; + + promptDone = handlePrompt(state, action); + + iframe3Loaded = onloadPromiseFor("iframe_prompt"); + iframe_prompt.src = "http://example.com/tests/toolkit/components/prompts/test/authenticate.sjs?user=mochiuser2&pass=mochipass2&realm=mochitest"; + await promptDone; + await iframe3Loaded; + await checkEchoedAuthInfo({user: "mochiuser2", pass: "mochipass2"}, + iframe_prompt); +}); + +/** + * Function to be passed to SpecialPowers.spawn that dispatches a MouseEvent + * of a certain type to some element in a subframe. + * + * @param {String} targetID The ID of the element that will have the event + * dispatched on. + * @param {String} type The type of MouseEvent. + * @returns Promise + * @resolves Once the event has been dispatched. + */ +async function dispatchMouseEvent(targetID, type) { + /* eslint-disable no-undef */ + let document = content.document; + let element = document.getElementById(targetID); + let event = document.createEvent("MouseEvent"); + event.initEvent(type, false, false, content, 0, 1, 1, 1, 1, + false, false, false, false, 0, null); + content.windowUtils.dispatchDOMEventViaPresShellForTesting(element, event); + /* eslint-enable no-undef */ +} +</script> +</body> +</html> |
