summaryrefslogtreecommitdiffstats
path: root/application/basilisk/base/content/urlbarBindings.xml
diff options
context:
space:
mode:
Diffstat (limited to 'application/basilisk/base/content/urlbarBindings.xml')
-rw-r--r--application/basilisk/base/content/urlbarBindings.xml2665
1 files changed, 2665 insertions, 0 deletions
diff --git a/application/basilisk/base/content/urlbarBindings.xml b/application/basilisk/base/content/urlbarBindings.xml
new file mode 100644
index 000000000..13eb5f4d5
--- /dev/null
+++ b/application/basilisk/base/content/urlbarBindings.xml
@@ -0,0 +1,2665 @@
+<?xml version="1.0"?>
+
+<!--
+-*- Mode: HTML -*-
+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/.
+-->
+
+<!DOCTYPE bindings [
+<!ENTITY % notificationDTD SYSTEM "chrome://global/locale/notification.dtd">
+%notificationDTD;
+<!ENTITY % browserDTD SYSTEM "chrome://browser/locale/browser.dtd">
+%browserDTD;
+<!ENTITY % brandDTD SYSTEM "chrome://branding/locale/brand.dtd">
+%brandDTD;
+]>
+
+<bindings id="urlbarBindings" xmlns="http://www.mozilla.org/xbl"
+ xmlns:html="http://www.w3.org/1999/xhtml"
+ xmlns:xul="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+ xmlns:xbl="http://www.mozilla.org/xbl">
+
+ <binding id="urlbar" extends="chrome://global/content/bindings/autocomplete.xml#autocomplete">
+
+ <content sizetopopup="pref">
+ <xul:hbox anonid="textbox-container"
+ class="autocomplete-textbox-container urlbar-textbox-container"
+ flex="1" xbl:inherits="focused">
+ <children includes="image|deck|stack|box">
+ <xul:image class="autocomplete-icon" allowevents="true"/>
+ </children>
+ <xul:hbox anonid="textbox-input-box"
+ class="textbox-input-box urlbar-input-box"
+ flex="1" xbl:inherits="tooltiptext=inputtooltiptext">
+ <children/>
+ <html:input anonid="input"
+ class="autocomplete-textbox urlbar-input textbox-input uri-element-right-align"
+ allowevents="true"
+ inputmode="url"
+ xbl:inherits="tooltiptext=inputtooltiptext,value,maxlength,disabled,size,readonly,placeholder,tabindex,accesskey"/>
+ </xul:hbox>
+ <xul:dropmarker anonid="historydropmarker"
+ class="autocomplete-history-dropmarker urlbar-history-dropmarker"
+ tooltiptext="&urlbar.openHistoryPopup.tooltip;"
+ allowevents="true"
+ xbl:inherits="open,enablehistory,parentfocused=focused"/>
+ <children includes="hbox"/>
+ </xul:hbox>
+ <xul:popupset anonid="popupset"
+ class="autocomplete-result-popupset"/>
+ <children includes="toolbarbutton"/>
+ </content>
+
+ <implementation implements="nsIObserver, nsIDOMEventListener">
+
+ <field name="ExtensionSearchHandler" readonly="true">
+ (Components.utils.import("resource://gre/modules/ExtensionSearchHandler.jsm", {})).ExtensionSearchHandler;
+ </field>
+
+ <constructor><![CDATA[
+ this._prefs = Components.classes["@mozilla.org/preferences-service;1"]
+ .getService(Components.interfaces.nsIPrefService)
+ .getBranch("browser.urlbar.");
+
+ this._prefs.addObserver("", this, false);
+ this.clickSelectsAll = this._prefs.getBoolPref("clickSelectsAll");
+ this.doubleClickSelectsAll = this._prefs.getBoolPref("doubleClickSelectsAll");
+ this.completeDefaultIndex = this._prefs.getBoolPref("autoFill");
+ this.timeout = this._prefs.getIntPref("delay");
+ this._formattingEnabled = this._prefs.getBoolPref("formatting.enabled");
+ this._mayTrimURLs = this._prefs.getBoolPref("trimURLs");
+ this._cacheUserMadeSearchSuggestionsChoice();
+ this.inputField.controllers.insertControllerAt(0, this._copyCutController);
+ this.inputField.addEventListener("paste", this);
+ this.inputField.addEventListener("mousedown", this);
+ this.inputField.addEventListener("mousemove", this);
+ this.inputField.addEventListener("mouseout", this);
+ this.inputField.addEventListener("overflow", this);
+ this.inputField.addEventListener("underflow", this);
+
+ var textBox = document.getAnonymousElementByAttribute(this,
+ "anonid", "textbox-input-box");
+ var cxmenu = document.getAnonymousElementByAttribute(textBox,
+ "anonid", "input-box-contextmenu");
+ var pasteAndGo;
+ cxmenu.addEventListener("popupshowing", function() {
+ if (!pasteAndGo)
+ return;
+ var controller = document.commandDispatcher.getControllerForCommand("cmd_paste");
+ var enabled = controller.isCommandEnabled("cmd_paste");
+ if (enabled)
+ pasteAndGo.removeAttribute("disabled");
+ else
+ pasteAndGo.setAttribute("disabled", "true");
+ });
+
+ var insertLocation = cxmenu.firstChild;
+ while (insertLocation.nextSibling &&
+ insertLocation.getAttribute("cmd") != "cmd_paste")
+ insertLocation = insertLocation.nextSibling;
+ if (insertLocation) {
+ pasteAndGo = document.createElement("menuitem");
+ let label = Services.strings.createBundle("chrome://browser/locale/browser.properties").
+ GetStringFromName("pasteAndGo.label");
+ pasteAndGo.setAttribute("label", label);
+ pasteAndGo.setAttribute("anonid", "paste-and-go");
+ pasteAndGo.setAttribute("oncommand",
+ "gURLBar.select(); goDoCommand('cmd_paste'); gURLBar.handleCommand();");
+ cxmenu.insertBefore(pasteAndGo, insertLocation.nextSibling);
+ }
+
+ this._enableOrDisableOneOffSearches();
+ ]]></constructor>
+
+ <destructor><![CDATA[
+ this._prefs.removeObserver("", this);
+ this._prefs = null;
+ this.inputField.controllers.removeController(this._copyCutController);
+ this.inputField.removeEventListener("paste", this);
+ this.inputField.removeEventListener("mousedown", this);
+ this.inputField.removeEventListener("mousemove", this);
+ this.inputField.removeEventListener("mouseout", this);
+ this.inputField.removeEventListener("overflow", this);
+ this.inputField.removeEventListener("underflow", this);
+ ]]></destructor>
+
+ <field name="_value">""</field>
+ <field name="gotResultForCurrentQuery">false</field>
+
+ <!--
+ This is set around HandleHenter so it can be used in handleCommand.
+ It is also used to track whether we must handle a delayed handleEnter,
+ by checking if it has been cleared.
+ -->
+ <field name="handleEnterInstance">null</field>
+
+ <!--
+ For performance reasons we want to limit the size of the text runs we
+ build and show to the user.
+ -->
+ <field name="textRunsMaxLen">255</field>
+
+ <!--
+ onBeforeValueGet is called by the base-binding's .value getter.
+ It can return an object with a "value" property, to override the
+ return value of the getter.
+ -->
+ <method name="onBeforeValueGet">
+ <body><![CDATA[
+ return { value: this._value };
+ ]]></body>
+ </method>
+
+ <!--
+ onBeforeValueSet is called by the base-binding's .value setter.
+ It should return the value that the setter should use.
+ -->
+ <method name="onBeforeValueSet">
+ <parameter name="aValue"/>
+ <body><![CDATA[
+ this._value = aValue;
+ var returnValue = aValue;
+ var action = this._parseActionUrl(aValue);
+
+ if (action) {
+ switch (action.type) {
+ case "switchtab": // Fall through.
+ case "remotetab": // Fall through.
+ case "visiturl": {
+ returnValue = action.params.displayUrl;
+ break;
+ }
+ case "keyword": // Fall through.
+ case "searchengine": {
+ returnValue = action.params.input;
+ break;
+ }
+ case "extension": {
+ returnValue = action.params.content;
+ break;
+ }
+ }
+ } else {
+ let originalUrl = ReaderMode.getOriginalUrlObjectForDisplay(aValue);
+ if (originalUrl) {
+ returnValue = originalUrl.spec;
+ }
+ }
+
+ // Set the actiontype only if the user is not overriding actions.
+ if (action && this._pressedNoActionKeys.size == 0) {
+ this.setAttribute("actiontype", action.type);
+ } else {
+ this.removeAttribute("actiontype");
+ }
+ return returnValue;
+ ]]></body>
+ </method>
+
+ <method name="onKeyPress">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ switch (aEvent.keyCode) {
+ case KeyEvent.DOM_VK_LEFT:
+ case KeyEvent.DOM_VK_RIGHT:
+ case KeyEvent.DOM_VK_HOME:
+ // Reset the selected index so that nsAutoCompleteController
+ // simply closes the popup without trying to fill anything.
+ this.popup.selectedIndex = -1;
+ break;
+ }
+ if (this.popup.popupOpen &&
+ !this.popup.disableKeyNavigation &&
+ this.popup.handleKeyPress(aEvent)) {
+ return true;
+ }
+ return this.handleKeyPress(aEvent);
+ ]]></body>
+ </method>
+
+ <field name="_mayTrimURLs">true</field>
+ <method name="trimValue">
+ <parameter name="aURL"/>
+ <body><![CDATA[
+ // This method must not modify the given URL such that calling
+ // nsIURIFixup::createFixupURI with the result will produce a different URI.
+ return this._mayTrimURLs ? trimURL(aURL) : aURL;
+ ]]></body>
+ </method>
+
+ <field name="_formattingEnabled">true</field>
+ <method name="formatValue">
+ <body><![CDATA[
+ if (!this._formattingEnabled || !this.editor)
+ return;
+
+ let controller = this.editor.selectionController;
+ let strikeOut = controller.getSelection(controller.SELECTION_URLSTRIKEOUT);
+ strikeOut.removeAllRanges();
+
+ let selection = controller.getSelection(controller.SELECTION_URLSECONDARY);
+ selection.removeAllRanges();
+
+ if (this.focused)
+ return;
+
+ let textNode = this.editor.rootElement.firstChild;
+ let value = textNode.textContent;
+ if (!value)
+ return;
+
+ // Get the URL from the fixup service:
+ let flags = Services.uriFixup.FIXUP_FLAG_FIX_SCHEME_TYPOS |
+ Services.uriFixup.FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP;
+ let uriInfo;
+ try {
+ uriInfo = Services.uriFixup.getFixupURIInfo(value, flags);
+ } catch (ex) {}
+ // Ignore if we couldn't make a URI out of this, the URI resulted in a search,
+ // or the URI has a non-http(s)/ftp protocol.
+ if (!uriInfo ||
+ !uriInfo.fixedURI ||
+ uriInfo.keywordProviderName ||
+ ["http", "https", "ftp"].indexOf(uriInfo.fixedURI.scheme) == -1) {
+ return;
+ }
+
+ // If we trimmed off the http scheme, ensure we stick it back on before
+ // trying to figure out what domain we're accessing, so we don't get
+ // confused by user:pass@host http URLs. We later use
+ // trimmedLength to ensure we don't count the length of a trimmed protocol
+ // when determining which parts of the URL to highlight as "preDomain".
+ let trimmedLength = 0;
+ if (uriInfo.fixedURI.scheme == "http" && !value.startsWith("http://")) {
+ value = "http://" + value;
+ trimmedLength = "http://".length;
+ }
+
+ let matchedURL = value.match(/^((?:[a-z]+:\/\/)(?:[^\/#?]+@)?)(\S+?)(?::\d+)?\s*(?:[\/#?]|$)/);
+ if (!matchedURL)
+ return;
+
+ // Strike out the "https" part if mixed active content is loaded.
+ if (this.getAttribute("pageproxystate") == "valid" &&
+ value.startsWith("https:") &&
+ gBrowser.securityUI.state &
+ Ci.nsIWebProgressListener.STATE_LOADED_MIXED_ACTIVE_CONTENT) {
+ let range = document.createRange();
+ range.setStart(textNode, 0);
+ range.setEnd(textNode, 5);
+ strikeOut.addRange(range);
+ }
+
+ let [, preDomain, domain] = matchedURL;
+ let baseDomain = domain;
+ let subDomain = "";
+ try {
+ baseDomain = Services.eTLD.getBaseDomainFromHost(uriInfo.fixedURI.host);
+ if (!domain.endsWith(baseDomain)) {
+ // getBaseDomainFromHost converts its resultant to ACE.
+ let IDNService = Cc["@mozilla.org/network/idn-service;1"]
+ .getService(Ci.nsIIDNService);
+ baseDomain = IDNService.convertACEtoUTF8(baseDomain);
+ }
+ } catch (e) {}
+ if (baseDomain != domain) {
+ subDomain = domain.slice(0, -baseDomain.length);
+ }
+
+ let rangeLength = preDomain.length + subDomain.length - trimmedLength;
+ if (rangeLength) {
+ let range = document.createRange();
+ range.setStart(textNode, 0);
+ range.setEnd(textNode, rangeLength);
+ selection.addRange(range);
+ }
+
+ let startRest = preDomain.length + domain.length - trimmedLength;
+ if (startRest < value.length - trimmedLength) {
+ let range = document.createRange();
+ range.setStart(textNode, startRest);
+ range.setEnd(textNode, value.length - trimmedLength);
+ selection.addRange(range);
+ }
+ ]]></body>
+ </method>
+
+ <method name="handleRevert">
+ <body><![CDATA[
+ var isScrolling = this.popupOpen;
+
+ gBrowser.userTypedValue = null;
+
+ // don't revert to last valid url unless page is NOT loading
+ // and user is NOT key-scrolling through autocomplete list
+ if (!XULBrowserWindow.isBusy && !isScrolling) {
+ URLBarSetURI();
+
+ // If the value isn't empty and the urlbar has focus, select the value.
+ if (this.value && this.hasAttribute("focused"))
+ this.select();
+ }
+
+ // tell widget to revert to last typed text only if the user
+ // was scrolling when they hit escape
+ return !isScrolling;
+ ]]></body>
+ </method>
+
+ <!--
+ This is ultimately called by the autocomplete controller as the result
+ of handleEnter when the Return key is pressed in the textbox. Since
+ onPopupClick also calls handleEnter, this is also called as a result in
+ that case.
+
+ @param event
+ The event that triggered the command.
+ @param openUILinkWhere
+ Optional. The "where" to pass to openUILinkIn. This method
+ computes the appropriate "where" given the event, but you can
+ use this to override it.
+ @param openUILinkParams
+ Optional. The parameters to pass to openUILinkIn. As with
+ "where", this method computes the appropriate parameters, but
+ any parameters you supply here will override those.
+ -->
+ <method name="handleCommand">
+ <parameter name="event"/>
+ <parameter name="openUILinkWhere"/>
+ <parameter name="openUILinkParams"/>
+ <body><![CDATA[
+ let isMouseEvent = event instanceof MouseEvent;
+ if (isMouseEvent && event.button == 2) {
+ // Do nothing for right clicks.
+ return;
+ }
+
+ // Determine whether to use the selected one-off search button. In
+ // one-off search buttons parlance, "selected" means that the button
+ // has been navigated to via the keyboard. So we want to use it if
+ // the triggering event is not a mouse click -- i.e., it's a Return
+ // key -- or if the one-off was mouse-clicked.
+ let selectedOneOff = this.popup.oneOffSearchButtons.selectedButton;
+ if (selectedOneOff &&
+ isMouseEvent &&
+ event.originalTarget != selectedOneOff) {
+ selectedOneOff = null;
+ }
+
+ // Do the command of the selected one-off if it's not an engine.
+ if (selectedOneOff && !selectedOneOff.engine) {
+ selectedOneOff.doCommand();
+ return;
+ }
+
+ let where = openUILinkWhere;
+ if (!where) {
+ if (isMouseEvent) {
+ where = whereToOpenLink(event, false, false);
+ } else {
+ // If the current tab is empty, ignore Alt+Enter (reuse this tab)
+ let altEnter = !isMouseEvent &&
+ event &&
+ event.altKey &&
+ !isTabEmpty(gBrowser.selectedTab);
+ where = altEnter ? "tab" : "current";
+ }
+ }
+
+ let url = this.value;
+ if (!url) {
+ return;
+ }
+
+ let mayInheritPrincipal = false;
+ let postData = null;
+ let browser = gBrowser.selectedBrowser;
+ let action = this._parseActionUrl(url);
+
+ if (selectedOneOff && selectedOneOff.engine) {
+ // If there's a selected one-off button then load a search using
+ // the one-off's engine.
+ [url, postData] =
+ this._parseAndRecordSearchEngineLoad(selectedOneOff.engine,
+ this.oneOffSearchQuery,
+ event, where,
+ openUILinkParams);
+ } else if (action) {
+ switch (action.type) {
+ case "visiturl":
+ // Unifiedcomplete uses fixupURI to tell if something is a visit
+ // or a search, and passes out the fixedURI as the url param.
+ // By using that uri we would end up passing a different string
+ // to the docshell that may run a different not-found heuristic.
+ // For example, "mozilla/run" would be fixed by unifiedcomplete
+ // to "http://mozilla/run". The docshell, once it can't resolve
+ // mozilla, would note the string has a scheme, and try to load
+ // http://mozilla.com/run instead of searching "mozilla/run".
+ // So, if we have the original input at hand, we pass it through
+ // and let the docshell handle it.
+ if (action.params.input) {
+ url = action.params.input;
+ break;
+ }
+ url = action.params.url;
+ break;
+ case "remotetab":
+ url = action.params.url;
+ break;
+ case "keyword":
+ if (action.params.postData) {
+ postData = getPostDataStream(action.params.postData);
+ }
+ mayInheritPrincipal = true;
+ url = action.params.url;
+ break;
+ case "switchtab":
+ url = action.params.url;
+ if (this.hasAttribute("actiontype")) {
+ this.handleRevert();
+ let prevTab = gBrowser.selectedTab;
+ if (switchToTabHavingURI(url) && isTabEmpty(prevTab)) {
+ gBrowser.removeTab(prevTab);
+ }
+ return;
+ }
+ break;
+ case "searchengine":
+ if (selectedOneOff && selectedOneOff.engine) {
+ // Replace the engine with the selected one-off engine.
+ action.params.engineName = selectedOneOff.engine.name;
+ }
+ const actionDetails = {
+ isSuggestion: !!action.params.searchSuggestion,
+ isAlias: !!action.params.alias
+ };
+ [url, postData] = this._parseAndRecordSearchEngineLoad(
+ action.params.engineName,
+ action.params.searchSuggestion || action.params.searchQuery,
+ event,
+ where,
+ openUILinkParams,
+ actionDetails
+ );
+ break;
+ case "extension":
+ this.handleRevert();
+ // Give the extension control of handling the command.
+ let searchString = action.params.content;
+ let keyword = action.params.keyword;
+ this.ExtensionSearchHandler.handleInputEntered(keyword, searchString, where);
+ return;
+ }
+ } else {
+ // This is a fallback for add-ons and old testing code that directly
+ // set value and try to confirm it. UnifiedComplete should always
+ // resolve to a valid url.
+ try {
+ new URL(url);
+ } catch (ex) {
+ let lastLocationChange = browser.lastLocationChange;
+ getShortcutOrURIAndPostData(url).then(data => {
+ if (where != "current" ||
+ browser.lastLocationChange == lastLocationChange) {
+ this._loadURL(data.url, browser, data.postData, where,
+ openUILinkParams, data.mayInheritPrincipal);
+ }
+ });
+ return;
+ }
+ }
+
+ this._loadURL(url, browser, postData, where, openUILinkParams,
+ mayInheritPrincipal);
+ ]]></body>
+ </method>
+
+ <property name="oneOffSearchQuery">
+ <getter><![CDATA[
+ // this.textValue may be an autofilled string. Search only with the
+ // portion that the user typed, if any, by preferring the autocomplete
+ // controller's searchString (including handleEnterInstance.searchString).
+ return (this.handleEnterInstance && this.handleEnterInstance.searchString) ||
+ this.mController.searchString ||
+ this.textValue;
+ ]]></getter>
+ </property>
+
+ <method name="_loadURL">
+ <parameter name="url"/>
+ <parameter name="browser"/>
+ <parameter name="postData"/>
+ <parameter name="openUILinkWhere"/>
+ <parameter name="openUILinkParams"/>
+ <parameter name="mayInheritPrincipal"/>
+ <body><![CDATA[
+ this.value = url;
+ browser.userTypedValue = url;
+ if (gInitialPages.includes(url)) {
+ browser.initialPageLoadedFromURLBar = url;
+ }
+ try {
+ addToUrlbarHistory(url);
+ } catch (ex) {
+ // Things may go wrong when adding url to session history,
+ // but don't let that interfere with the loading of the url.
+ Cu.reportError(ex);
+ }
+
+ let params = {
+ postData,
+ allowThirdPartyFixup: true,
+ };
+ if (openUILinkWhere == "current") {
+ params.targetBrowser = browser;
+ params.indicateErrorPageLoad = true;
+ params.allowPinnedTabHostChange = true;
+ params.disallowInheritPrincipal = !mayInheritPrincipal;
+ params.allowPopups = url.startsWith("javascript:");
+ } else {
+ params.initiatingDoc = document;
+ }
+
+ if (openUILinkParams) {
+ for (let key in openUILinkParams) {
+ params[key] = openUILinkParams[key];
+ }
+ }
+
+ // Focus the content area before triggering loads, since if the load
+ // occurs in a new tab, we want focus to be restored to the content
+ // area when the current tab is re-selected.
+ browser.focus();
+
+ if (openUILinkWhere != "current") {
+ this.handleRevert();
+ }
+
+ try {
+ openUILinkIn(url, openUILinkWhere, params);
+ } catch (ex) {
+ // This load can throw an exception in certain cases, which means
+ // we'll want to replace the URL with the loaded URL:
+ if (ex.result != Cr.NS_ERROR_LOAD_SHOWED_ERRORPAGE) {
+ this.handleRevert();
+ }
+ }
+
+ if (openUILinkWhere == "current") {
+ // Ensure the start of the URL is visible for usability reasons.
+ this.selectionStart = this.selectionEnd = 0;
+ }
+ ]]></body>
+ </method>
+
+ <method name="_parseAndRecordSearchEngineLoad">
+ <parameter name="engineOrEngineName"/>
+ <parameter name="query"/>
+ <parameter name="event"/>
+ <parameter name="openUILinkWhere"/>
+ <parameter name="openUILinkParams"/>
+ <parameter name="searchActionDetails"/>
+ <body><![CDATA[
+ let engine =
+ typeof(engineOrEngineName) == "string" ?
+ Services.search.getEngineByName(engineOrEngineName) :
+ engineOrEngineName;
+ let isOneOff = this.popup.oneOffSearchButtons
+ .maybeRecordTelemetry(event, openUILinkWhere, openUILinkParams);
+ // Infer the type of the event which triggered the search.
+ let eventType = "unknown";
+ if (event instanceof KeyboardEvent) {
+ eventType = "key";
+ } else if (event instanceof MouseEvent) {
+ eventType = "mouse";
+ }
+ // Augment the search action details object.
+ let details = searchActionDetails || {};
+ details.isOneOff = isOneOff;
+ details.type = eventType;
+
+ BrowserSearch.recordSearchInTelemetry(engine, "urlbar", details);
+ let submission = engine.getSubmission(query, null, "keyword");
+ return [submission.uri.spec, submission.postData];
+ ]]></body>
+ </method>
+
+ <method name="maybeCanonizeURL">
+ <parameter name="aTriggeringEvent"/>
+ <parameter name="aUrl"/>
+ <body><![CDATA[
+ // Only add the suffix when the URL bar value isn't already "URL-like",
+ // and only if we get a keyboard event, to match user expectations.
+ if (!/^\s*[^.:\/\s]+(?:\/.*|\s*)$/i.test(aUrl) ||
+ !(aTriggeringEvent instanceof KeyEvent)) {
+ return;
+ }
+
+ let url = aUrl;
+#ifdef XP_MACOSX
+ let accel = aTriggeringEvent.metaKey;
+#else
+ let accel = aTriggeringEvent.ctrlKey;
+#endif
+ let shift = aTriggeringEvent.shiftKey;
+ let suffix = "";
+
+ switch (true) {
+ case (accel && shift):
+ suffix = ".org/";
+ break;
+ case (shift):
+ suffix = ".net/";
+ break;
+ case (accel):
+ try {
+ suffix = gPrefService.getCharPref("browser.fixup.alternate.suffix");
+ if (suffix.charAt(suffix.length - 1) != "/")
+ suffix += "/";
+ } catch (e) {
+ suffix = ".com/";
+ }
+ break;
+ }
+
+ if (!suffix)
+ return;
+
+ // trim leading/trailing spaces (bug 233205)
+ url = url.trim();
+
+ // Tack www. and suffix on. If user has appended directories, insert
+ // suffix before them (bug 279035). Be careful not to get two slashes.
+ let firstSlash = url.indexOf("/");
+ if (firstSlash >= 0) {
+ url = url.substring(0, firstSlash) + suffix +
+ url.substring(firstSlash + 1);
+ } else {
+ url = url + suffix;
+ }
+
+ this.popup.overrideValue = "http://www." + url;
+ ]]></body>
+ </method>
+
+ <field name="_contentIsCropped">false</field>
+
+ <method name="_initURLTooltip">
+ <body><![CDATA[
+ if (this.focused || !this._contentIsCropped)
+ return;
+ this.inputField.setAttribute("tooltiptext", this.value);
+ ]]></body>
+ </method>
+
+ <method name="_hideURLTooltip">
+ <body><![CDATA[
+ this.inputField.removeAttribute("tooltiptext");
+ ]]></body>
+ </method>
+
+ <!-- Returns:
+ null if there's a security issue and we should do nothing.
+ a URL object if there is one that we're OK with loading,
+ a text value otherwise.
+ -->
+ <method name="_getDroppableItem">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ let links;
+ try {
+ links = browserDragAndDrop.dropLinks(aEvent);
+ } catch (ex) {
+ // this is possibly a security exception, in which case we should return
+ // null. Always return null because we can't *know* what exception is
+ // being returned.
+ return null;
+ }
+ // The URL bar automatically handles inputs with newline characters,
+ // so we can get away with treating text/x-moz-url flavours as text/plain.
+ if (links.length > 0 && links[0].url) {
+ aEvent.preventDefault();
+ let url = links[0].url;
+ let strippedURL = stripUnsafeProtocolOnPaste(url);
+ if (strippedURL != url) {
+ aEvent.stopImmediatePropagation();
+ return null;
+ }
+ let urlObj;
+ try {
+ // If this throws, urlSecurityCheck would also throw, as that's what it
+ // does with things that don't pass the IO service's newURI constructor
+ // without fixup. It's conceivable we may want to relax this check in
+ // the future (so e.g. www.foo.com gets fixed up), but not right now.
+ urlObj = new URL(url);
+ // If we succeed, try to pass security checks. If this works, return the
+ // URL object. If the *security checks* fail, return null.
+ try {
+ urlSecurityCheck(url,
+ gBrowser.contentPrincipal,
+ Ci.nsIScriptSecurityManager.DISALLOW_INHERIT_PRINCIPAL);
+ return urlObj;
+ } catch (ex) {
+ return null;
+ }
+ } catch (ex) {
+ // We couldn't make a URL out of this. Continue on, and return text below.
+ }
+ }
+ return aEvent.dataTransfer.getData("text/unicode");
+ ]]></body>
+ </method>
+
+ <method name="onDragOver">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ if (!this._getDroppableItem(aEvent)) {
+ aEvent.dataTransfer.dropEffect = "none";
+ }
+ ]]></body>
+ </method>
+
+ <method name="onDrop">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ let droppedItem = this._getDroppableItem(aEvent);
+ if (droppedItem) {
+ this.value = droppedItem instanceof URL ? droppedItem.href : droppedItem;
+ SetPageProxyState("invalid");
+ this.focus();
+ this.handleCommand();
+ // Force not showing the dropped URI immediately.
+ gBrowser.userTypedValue = null;
+ URLBarSetURI();
+ }
+ ]]></body>
+ </method>
+
+ <method name="_getSelectedValueForClipboard">
+ <body><![CDATA[
+ // Grab the actual input field's value, not our value, which could include moz-action:
+ var inputVal = this.inputField.value;
+ let selection = this.editor.selection;
+ var selectedVal = selection.toString();
+
+ // Handle multiple-range selection as a string for simplicity.
+ if (selection.rangeCount > 1) {
+ return selectedVal;
+ }
+
+ // If the selection doesn't start at the beginning or doesn't span the full domain or
+ // the URL bar is modified or there is no text at all, nothing else to do here.
+ if (this.selectionStart > 0 || this.valueIsTyped || selectedVal == "")
+ return selectedVal;
+ // The selection doesn't span the full domain if it doesn't contain a slash and is
+ // followed by some character other than a slash.
+ if (!selectedVal.includes("/")) {
+ let remainder = inputVal.replace(selectedVal, "");
+ if (remainder != "" && remainder[0] != "/")
+ return selectedVal;
+ }
+
+ let uriFixup = Cc["@mozilla.org/docshell/urifixup;1"].getService(Ci.nsIURIFixup);
+
+ let uri;
+ if (this.getAttribute("pageproxystate") == "valid") {
+ uri = gBrowser.currentURI;
+ } else {
+ // We're dealing with an autocompleted value, create a new URI from that.
+ try {
+ uri = uriFixup.createFixupURI(inputVal, Ci.nsIURIFixup.FIXUP_FLAG_NONE);
+ } catch (e) {}
+ if (!uri)
+ return selectedVal;
+ }
+
+ // Avoid copying 'about:reader?url=', and always provide the original URI:
+ // Reader mode ensures we call createExposableURI itself.
+ let readerStrippedURI = ReaderMode.getOriginalUrlObjectForDisplay(uri.spec);
+ if (readerStrippedURI) {
+ uri = readerStrippedURI;
+ } else {
+ // Only copy exposable URIs
+ try {
+ uri = uriFixup.createExposableURI(uri);
+ } catch (ex) {}
+ }
+
+ // If the entire URL is selected, just use the actual loaded URI,
+ // unless we want a decoded URI, or it's a data: or javascript: URI,
+ // since those are hard to read when encoded.
+ if (inputVal == selectedVal &&
+ !uri.schemeIs("javascript") && !uri.schemeIs("data") &&
+ !Services.prefs.getBoolPref("browser.urlbar.decodeURLsOnCopy")) {
+ return uri.spec;
+ }
+
+ // Just the beginning of the URL is selected, or we want a decoded
+ // url. First check for a trimmed value.
+ let spec = uri.spec;
+ let trimmedSpec = this.trimValue(spec);
+ if (spec != trimmedSpec) {
+ // Prepend the portion that trimValue removed from the beginning.
+ // This assumes trimValue will only truncate the URL at
+ // the beginning or end (or both).
+ let trimmedSegments = spec.split(trimmedSpec);
+ selectedVal = trimmedSegments[0] + selectedVal;
+ }
+
+ return selectedVal;
+ ]]></body>
+ </method>
+
+ <field name="_copyCutController"><![CDATA[
+ ({
+ urlbar: this,
+ doCommand(aCommand) {
+ var urlbar = this.urlbar;
+ var val = urlbar._getSelectedValueForClipboard();
+ if (!val)
+ return;
+
+ if (aCommand == "cmd_cut" && this.isCommandEnabled(aCommand)) {
+ let start = urlbar.selectionStart;
+ let end = urlbar.selectionEnd;
+ urlbar.inputField.value = urlbar.inputField.value.substring(0, start) +
+ urlbar.inputField.value.substring(end);
+ urlbar.selectionStart = urlbar.selectionEnd = start;
+
+ let event = document.createEvent("UIEvents");
+ event.initUIEvent("input", true, false, window, 0);
+ urlbar.dispatchEvent(event);
+
+ SetPageProxyState("invalid");
+ }
+
+ Cc["@mozilla.org/widget/clipboardhelper;1"]
+ .getService(Ci.nsIClipboardHelper)
+ .copyString(val);
+ },
+ supportsCommand(aCommand) {
+ switch (aCommand) {
+ case "cmd_copy":
+ case "cmd_cut":
+ return true;
+ }
+ return false;
+ },
+ isCommandEnabled(aCommand) {
+ return this.supportsCommand(aCommand) &&
+ (aCommand != "cmd_cut" || !this.urlbar.readOnly) &&
+ this.urlbar.selectionStart < this.urlbar.selectionEnd;
+ },
+ onEvent(aEventName) {}
+ })
+ ]]></field>
+
+ <method name="observe">
+ <parameter name="aSubject"/>
+ <parameter name="aTopic"/>
+ <parameter name="aData"/>
+ <body><![CDATA[
+ if (aTopic == "nsPref:changed") {
+ switch (aData) {
+ case "clickSelectsAll":
+ case "doubleClickSelectsAll":
+ this[aData] = this._prefs.getBoolPref(aData);
+ break;
+ case "autoFill":
+ this.completeDefaultIndex = this._prefs.getBoolPref(aData);
+ break;
+ case "delay":
+ this.timeout = this._prefs.getIntPref(aData);
+ break;
+ case "formatting.enabled":
+ this._formattingEnabled = this._prefs.getBoolPref(aData);
+ break;
+ case "userMadeSearchSuggestionsChoice":
+ case "suggest.searches":
+ this._cacheUserMadeSearchSuggestionsChoice();
+ if (this._userMadeSearchSuggestionsChoice) {
+ this.popup.searchSuggestionsNotificationWasDismissed(
+ this._prefs.getBoolPref("suggest.searches")
+ );
+ }
+ break;
+ case "trimURLs":
+ this._mayTrimURLs = this._prefs.getBoolPref(aData);
+ break;
+ case "oneOffSearches":
+ this._enableOrDisableOneOffSearches();
+ break;
+ }
+ }
+ ]]></body>
+ </method>
+
+ <method name="_enableOrDisableOneOffSearches">
+ <body><![CDATA[
+ let enable = this._prefs.getBoolPref("oneOffSearches");
+ this.popup.enableOneOffSearches(enable);
+ ]]></body>
+ </method>
+
+ <method name="handleEvent">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ switch (aEvent.type) {
+ case "paste":
+ let originalPasteData = aEvent.clipboardData.getData("text/plain");
+ if (!originalPasteData) {
+ return;
+ }
+
+ let oldValue = this.inputField.value;
+ let oldStart = oldValue.substring(0, this.inputField.selectionStart);
+ // If there is already non-whitespace content in the URL bar
+ // preceding the pasted content, it's not necessary to check
+ // protocols used by the pasted content:
+ if (oldStart.trim()) {
+ return;
+ }
+ let oldEnd = oldValue.substring(this.inputField.selectionEnd);
+
+ let pasteData = stripUnsafeProtocolOnPaste(originalPasteData);
+ if (originalPasteData != pasteData) {
+ // Unfortunately we're not allowed to set the bits being pasted
+ // so cancel this event:
+ aEvent.preventDefault();
+ aEvent.stopImmediatePropagation();
+
+ this.inputField.value = oldStart + pasteData + oldEnd;
+ // Fix up cursor/selection:
+ let newCursorPos = oldStart.length + pasteData.length;
+ this.inputField.selectionStart = newCursorPos;
+ this.inputField.selectionEnd = newCursorPos;
+ }
+ break;
+ case "mousedown":
+ if (this.doubleClickSelectsAll &&
+ aEvent.button == 0 && aEvent.detail == 2) {
+ this.editor.selectAll();
+ aEvent.preventDefault();
+ }
+ break;
+ case "mousemove":
+ this._initURLTooltip();
+ break;
+ case "mouseout":
+ this._hideURLTooltip();
+ break;
+ case "overflow":
+ this._contentIsCropped = true;
+ break;
+ case "underflow":
+ this._contentIsCropped = false;
+ this._hideURLTooltip();
+ break;
+ }
+ ]]></body>
+ </method>
+
+ <!--
+ onBeforeTextValueSet is called by the base-binding's .textValue getter.
+ It should return the value that the getter should use.
+ -->
+ <method name="onBeforeTextValueGet">
+ <body><![CDATA[
+ return { value: this.inputField.value };
+ ]]></body>
+ </method>
+
+ <!--
+ onBeforeTextValueSet is called by the base-binding's .textValue setter.
+ It should return the value that the setter should use.
+ -->
+ <method name="onBeforeTextValueSet">
+ <parameter name="aValue"/>
+ <body><![CDATA[
+ let val = aValue;
+ let uri;
+ try {
+ uri = makeURI(val);
+ } catch (ex) {}
+
+ if (uri) {
+ // Do not touch moz-action URIs at all. They depend on being
+ // properly encoded and decoded and will break if decoded
+ // unexpectedly.
+ if (!this._parseActionUrl(val)) {
+ val = losslessDecodeURI(uri);
+ }
+ }
+
+ return val;
+ ]]></body>
+ </method>
+
+ <method name="_parseActionUrl">
+ <parameter name="aUrl"/>
+ <body><![CDATA[
+ const MOZ_ACTION_REGEX = /^moz-action:([^,]+),(.*)$/;
+ if (!MOZ_ACTION_REGEX.test(aUrl))
+ return null;
+
+ // URL is in the format moz-action:ACTION,PARAMS
+ // Where PARAMS is a JSON encoded object.
+ let [, type, params] = aUrl.match(MOZ_ACTION_REGEX);
+
+ let action = {
+ type,
+ };
+
+ action.params = JSON.parse(params);
+ for (let key in action.params) {
+ action.params[key] = decodeURIComponent(action.params[key]);
+ }
+
+ if ("url" in action.params) {
+ let uri;
+ try {
+ uri = makeURI(action.params.url);
+ action.params.displayUrl = losslessDecodeURI(uri);
+ } catch (e) {
+ action.params.displayUrl = action.params.url;
+ }
+ }
+
+ return action;
+ ]]></body>
+ </method>
+
+ <property name="_noActionKeys" readonly="true">
+ <getter><![CDATA[
+ if (!this.__noActionKeys) {
+ this.__noActionKeys = new Set([
+ KeyEvent.DOM_VK_ALT,
+ KeyEvent.DOM_VK_SHIFT,
+ ]);
+#ifdef XP_MACOSX
+ let modifier = KeyEvent.DOM_VK_META;
+#else
+ let modifier = KeyEvent.DOM_VK_CONTROL;
+#endif
+
+ this.__noActionKeys.add(modifier);
+ }
+ return this.__noActionKeys;
+ ]]></getter>
+ </property>
+
+ <field name="_pressedNoActionKeys"><![CDATA[
+ new Set()
+ ]]></field>
+
+ <method name="_clearNoActions">
+ <parameter name="aURL"/>
+ <body><![CDATA[
+ this._pressedNoActionKeys.clear();
+ this.popup.removeAttribute("noactions");
+ let action = this._parseActionUrl(this._value);
+ if (action)
+ this.setAttribute("actiontype", action.type);
+ ]]></body>
+ </method>
+
+ <method name="onInput">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ if (!this.mIgnoreInput && this.mController.input == this) {
+ this._value = this.inputField.value;
+ gBrowser.userTypedValue = this.value;
+ this.valueIsTyped = true;
+ // Only wait for a result when we are sure to get one. In some
+ // cases, like when pasting the same exact text, we may not fire
+ // a new search and we won't get a result.
+ if (this.mController.handleText()) {
+ this.gotResultForCurrentQuery = false;
+ }
+ }
+ this.resetActionType();
+ ]]></body>
+ </method>
+
+ <method name="handleEnter">
+ <parameter name="event"/>
+ <body><![CDATA[
+ // We need to ensure we're using a selected autocomplete result.
+ // A result should automatically be selected by default,
+ // however autocomplete is async and therefore we may not
+ // have a result set relating to the current input yet. If that
+ // happens, we need to mark that when the first result does get added,
+ // it needs to be handled as if enter was pressed with that first
+ // result selected.
+ // If anything other than the default (first) result is selected, then
+ // it must have been manually selected by the human. We let this
+ // explicit choice be used, even if it may be related to a previous
+ // input.
+ // However, if the default result is automatically selected, we
+ // ensure that it corresponds to the current input.
+
+ // Store the current search string so it can be used in
+ // handleCommand, which will be called as a result of
+ // mController.handleEnter().
+ // Note this is also used to detect if we should perform a delayed
+ // handleEnter, in such a case it won't have been cleared.
+ this.handleEnterInstance = {
+ searchString: this.mController.searchString,
+ event
+ };
+
+ if (this.popup.selectedIndex != 0 || this.gotResultForCurrentQuery) {
+ this.maybeCanonizeURL(event, this.value);
+ let rv = this.mController.handleEnter(false, event);
+ this.handleEnterInstance = null;
+ this.popup.overrideValue = null;
+ return rv;
+ }
+
+ return true;
+ ]]></body>
+ </method>
+
+ <method name="handleDelete">
+ <body><![CDATA[
+ // If the heuristic result is selected, then the autocomplete
+ // controller's handleDelete implementation will remove it, which is
+ // not what we want. So in that case, call handleText so it acts as
+ // a backspace on the text value instead of removing the result.
+ if (this.popup.selectedIndex == 0 &&
+ this.popup._isFirstResultHeuristic) {
+ this.mController.handleText();
+ return false;
+ }
+ return this.mController.handleDelete();
+ ]]></body>
+ </method>
+
+ <field name="_userMadeSearchSuggestionsChoice"><![CDATA[
+ false
+ ]]></field>
+
+ <method name="_cacheUserMadeSearchSuggestionsChoice">
+ <body><![CDATA[
+ this._userMadeSearchSuggestionsChoice =
+ this._prefs.getBoolPref("userMadeSearchSuggestionsChoice") ||
+ this._prefs.getBoolPref("suggest.searches");
+ ]]></body>
+ </method>
+
+ <property name="shouldShowSearchSuggestionsNotification" readonly="true">
+ <getter><![CDATA[
+ return !this._userMadeSearchSuggestionsChoice &&
+ !this.inPrivateContext &&
+ // When _urlbarFocused is true, tabbrowser would close the
+ // popup if it's opened here, so don't show the notification.
+ !gBrowser.selectedBrowser._urlbarFocused &&
+ Services.prefs.getBoolPref("browser.search.suggest.enabled") &&
+ this._prefs.getIntPref("daysBeforeHidingSuggestionsPrompt");
+ ]]></getter>
+ </property>
+
+ </implementation>
+
+ <handlers>
+ <handler event="keydown"><![CDATA[
+ if (this._noActionKeys.has(event.keyCode) &&
+ this.popup.selectedIndex >= 0 &&
+ !this._pressedNoActionKeys.has(event.keyCode)) {
+ if (this._pressedNoActionKeys.size == 0) {
+ this.popup.setAttribute("noactions", "true");
+ this.removeAttribute("actiontype");
+ }
+ this._pressedNoActionKeys.add(event.keyCode);
+ }
+ ]]></handler>
+
+ <handler event="keyup"><![CDATA[
+ if (this._noActionKeys.has(event.keyCode) &&
+ this._pressedNoActionKeys.has(event.keyCode)) {
+ this._pressedNoActionKeys.delete(event.keyCode);
+ if (this._pressedNoActionKeys.size == 0)
+ this._clearNoActions();
+ }
+ ]]></handler>
+
+ <handler event="focus"><![CDATA[
+ if (event.originalTarget == this.inputField) {
+ this._hideURLTooltip();
+ this.formatValue();
+ if (this.getAttribute("pageproxystate") != "valid") {
+ UpdatePopupNotificationsVisibility();
+ }
+ }
+ ]]></handler>
+
+ <handler event="blur"><![CDATA[
+ if (event.originalTarget == this.inputField) {
+ this._clearNoActions();
+ this.formatValue();
+ if (this.getAttribute("pageproxystate") != "valid") {
+ UpdatePopupNotificationsVisibility();
+ }
+ }
+ if (ExtensionSearchHandler.hasActiveInputSession()) {
+ ExtensionSearchHandler.handleInputCancelled();
+ }
+ ]]></handler>
+
+ <handler event="dragstart" phase="capturing"><![CDATA[
+ // Drag only if the gesture starts from the input field.
+ if (this.inputField != event.originalTarget &&
+ !(this.inputField.compareDocumentPosition(event.originalTarget) &
+ Node.DOCUMENT_POSITION_CONTAINED_BY))
+ return;
+
+ // Drag only if the entire value is selected and it's a valid URI.
+ var isFullSelection = this.selectionStart == 0 &&
+ this.selectionEnd == this.textLength;
+ if (!isFullSelection ||
+ this.getAttribute("pageproxystate") != "valid")
+ return;
+
+ var urlString = gBrowser.selectedBrowser.currentURI.spec;
+ var title = gBrowser.selectedBrowser.contentTitle || urlString;
+ var htmlString = "<a href=\"" + urlString + "\">" + urlString + "</a>";
+
+ var dt = event.dataTransfer;
+ dt.setData("text/x-moz-url", urlString + "\n" + title);
+ dt.setData("text/unicode", urlString);
+ dt.setData("text/html", htmlString);
+
+ dt.effectAllowed = "copyLink";
+ event.stopPropagation();
+ ]]></handler>
+
+ <handler event="dragover" phase="capturing" action="this.onDragOver(event, this);"/>
+ <handler event="drop" phase="capturing" action="this.onDrop(event, this);"/>
+ <handler event="select"><![CDATA[
+ if (!Cc["@mozilla.org/widget/clipboard;1"]
+ .getService(Ci.nsIClipboard)
+ .supportsSelectionClipboard())
+ return;
+
+ if (!window.QueryInterface(Ci.nsIInterfaceRequestor)
+ .getInterface(Ci.nsIDOMWindowUtils)
+ .isHandlingUserInput)
+ return;
+
+ var val = this._getSelectedValueForClipboard();
+ if (!val)
+ return;
+
+ Cc["@mozilla.org/widget/clipboardhelper;1"]
+ .getService(Ci.nsIClipboardHelper)
+ .copyStringToClipboard(val, Ci.nsIClipboard.kSelectionClipboard);
+ ]]></handler>
+ </handlers>
+
+ </binding>
+
+ <binding id="urlbar-rich-result-popup" extends="chrome://global/content/bindings/autocomplete.xml#autocomplete-rich-result-popup">
+
+ <resources>
+ <stylesheet src="chrome://browser/content/search/searchbarBindings.css"/>
+ <stylesheet src="chrome://browser/skin/searchbar.css"/>
+ </resources>
+
+ <content ignorekeys="true" level="top" consumeoutsideclicks="never"
+ aria-owns="richlistbox">
+ <xul:hbox anonid="search-suggestions-notification"
+ align="center"
+ role="alert"
+ aria-describedby="search-suggestions-notification-text">
+ <xul:description flex="1">
+ &urlbar.searchSuggestionsNotification.question;
+ <!-- Several things here are to make the label accessibile via an
+ accesskey so that a11y doesn't suck: the accesskey, using an
+ onclick handler instead of an href attribute, the control
+ attribute, and having the control attribute refer to a valid ID
+ that is the label itself. -->
+ <xul:label id="search-suggestions-notification-learn-more"
+ class="text-link"
+ role="link"
+ value="&urlbar.searchSuggestionsNotification.learnMore;"
+ accesskey="&urlbar.searchSuggestionsNotification.learnMore.accesskey;"
+ onclick="document.getBindingParent(this).openSearchSuggestionsNotificationLearnMoreURL();"
+ control="search-suggestions-notification-learn-more"/>
+ </xul:description>
+ <xul:button anonid="search-suggestions-notification-disable"
+ label="&urlbar.searchSuggestionsNotification.disable;"
+ accesskey="&urlbar.searchSuggestionsNotification.disable.accesskey;"
+ onclick="document.getBindingParent(this).dismissSearchSuggestionsNotification(false);"/>
+ <xul:button anonid="search-suggestions-notification-enable"
+ label="&urlbar.searchSuggestionsNotification.enable;"
+ accesskey="&urlbar.searchSuggestionsNotification.enable.accesskey;"
+ onclick="document.getBindingParent(this).dismissSearchSuggestionsNotification(true);"/>
+ </xul:hbox>
+ <xul:richlistbox anonid="richlistbox" class="autocomplete-richlistbox"
+ flex="1"/>
+ <xul:hbox anonid="footer">
+ <children/>
+ <xul:vbox anonid="one-off-search-buttons"
+ class="search-one-offs"
+ compact="true"
+ includecurrentengine="true"
+ disabletab="true"
+ flex="1"/>
+ </xul:hbox>
+ </content>
+
+ <implementation>
+ <field name="_maxResults">0</field>
+
+ <field name="_bundle" readonly="true">
+ Cc["@mozilla.org/intl/stringbundle;1"].
+ getService(Ci.nsIStringBundleService).
+ createBundle("chrome://browser/locale/places/places.properties");
+ </field>
+
+ <field name="searchSuggestionsNotification" readonly="true">
+ document.getAnonymousElementByAttribute(
+ this, "anonid", "search-suggestions-notification"
+ );
+ </field>
+
+ <field name="footer" readonly="true">
+ document.getAnonymousElementByAttribute(this, "anonid", "footer");
+ </field>
+
+ <field name="oneOffSearchButtons" readonly="true">
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "one-off-search-buttons");
+ </field>
+
+ <field name="_oneOffSearchesEnabled">false</field>
+
+ <field name="_overrideValue">null</field>
+ <property name="overrideValue"
+ onget="return this._overrideValue;"
+ onset="this._overrideValue = val; return val;"/>
+
+ <method name="onPopupClick">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ if (aEvent.button == 2) {
+ // Ignore right-clicks.
+ return;
+ }
+ // Otherwise "call super" -- do what autocomplete-base-popup does.
+ let controller = this.view.QueryInterface(Components.interfaces.nsIAutoCompleteController);
+ controller.handleEnter(true, aEvent);
+ ]]></body>
+ </method>
+
+ <method name="enableOneOffSearches">
+ <parameter name="enable"/>
+ <body><![CDATA[
+ this._oneOffSearchesEnabled = enable;
+ if (enable) {
+ this.oneOffSearchButtons.telemetryOrigin = "urlbar";
+ this.oneOffSearchButtons.style.display = "-moz-box";
+ this.oneOffSearchButtons.popup = this;
+ this.oneOffSearchButtons.textbox = this.input;
+ } else {
+ this.oneOffSearchButtons.telemetryOrigin = null;
+ this.oneOffSearchButtons.style.display = "none";
+ this.oneOffSearchButtons.popup = null;
+ this.oneOffSearchButtons.textbox = null;
+ }
+ ]]></body>
+ </method>
+
+ <method name="openSearchSuggestionsNotificationLearnMoreURL">
+ <body><![CDATA[
+ let url = Services.urlFormatter.formatURL(
+ Services.prefs.getCharPref("app.support.baseURL") + "suggestions"
+ );
+ openUILinkIn(url, "tab");
+ ]]></body>
+ </method>
+
+ <method name="dismissSearchSuggestionsNotification">
+ <parameter name="enableSuggestions"/>
+ <body><![CDATA[
+ // Make sure the urlbar is focused. It won't be, for example, if the
+ // user used an accesskey to make an opt-in choice. mIgnoreFocus
+ // prevents the text from being selected.
+ this.input.mIgnoreFocus = true;
+ this.input.focus();
+ this.input.mIgnoreFocus = false;
+
+ Services.prefs.setBoolPref(
+ "browser.urlbar.suggest.searches", enableSuggestions
+ );
+ Services.prefs.setBoolPref(
+ "browser.urlbar.userMadeSearchSuggestionsChoice", true
+ );
+ // The input's pref observer will now hide the notification.
+ ]]></body>
+ </method>
+
+ <!-- Override this so that navigating between items results in an item
+ always being selected. -->
+ <method name="getNextIndex">
+ <parameter name="reverse"/>
+ <parameter name="amount"/>
+ <parameter name="index"/>
+ <parameter name="maxRow"/>
+ <body><![CDATA[
+ if (maxRow < 0)
+ return -1;
+
+ let newIndex = index + (reverse ? -1 : 1) * amount;
+
+ // We only want to wrap if navigation is in any direction by one item,
+ // otherwise we clamp to one end of the list.
+ // ie, hitting page-down will only cause is to wrap if we're already
+ // at one end of the list.
+
+ // Allow the selection to be removed if the first result is not a
+ // heuristic result.
+ if (!this._isFirstResultHeuristic) {
+ if (reverse && index == -1 || newIndex > maxRow && index != maxRow)
+ newIndex = maxRow;
+ else if (!reverse && index == -1 || newIndex < 0 && index != 0)
+ newIndex = 0;
+
+ if (newIndex < 0 && index == 0 || newIndex > maxRow && index == maxRow)
+ newIndex = -1;
+
+ return newIndex;
+ }
+
+ // Otherwise do not allow the selection to be removed.
+ if (newIndex < 0) {
+ newIndex = index > 0 ? 0 : maxRow;
+ } else if (newIndex > maxRow) {
+ newIndex = index < maxRow ? maxRow : 0;
+ }
+ return newIndex;
+ ]]></body>
+ </method>
+
+ <property name="_isFirstResultHeuristic" readonly="true">
+ <getter>
+ <![CDATA[
+ // The popup usually has a special "heuristic" first result (added
+ // by UnifiedComplete.js) that is automatically selected when the
+ // popup opens.
+ return this.input.mController.matchCount > 0 &&
+ this.input.mController
+ .getStyleAt(0)
+ .split(/\s+/).indexOf("heuristic") > 0;
+ ]]>
+ </getter>
+ </property>
+
+ <property name="maxResults">
+ <getter>
+ <![CDATA[
+ if (!this._maxResults) {
+ var prefService =
+ Components.classes["@mozilla.org/preferences-service;1"]
+ .getService(Components.interfaces.nsIPrefBranch);
+ this._maxResults = prefService.getIntPref("browser.urlbar.maxRichResults");
+ }
+ return this._maxResults;
+ ]]>
+ </getter>
+ <setter>
+ <![CDATA[
+ return this._maxResults = parseInt(val);
+ ]]>
+ </setter>
+ </property>
+
+ <method name="openAutocompletePopup">
+ <parameter name="aInput"/>
+ <parameter name="aElement"/>
+ <body>
+ <![CDATA[
+ // initially the panel is hidden
+ // to avoid impacting startup / new window performance
+ aInput.popup.hidden = false;
+
+ let showNotification = aInput.shouldShowSearchSuggestionsNotification;
+ if (showNotification) {
+ let prefs = aInput._prefs;
+ let now = new Date();
+ let date = now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate();
+ let previousDate = prefs.getIntPref("lastSuggestionsPromptDate");
+ if (previousDate < date) {
+ let remainingDays =
+ prefs.getIntPref("daysBeforeHidingSuggestionsPrompt") - 1;
+ prefs.setIntPref("daysBeforeHidingSuggestionsPrompt",
+ remainingDays);
+ prefs.setIntPref("lastSuggestionsPromptDate", date);
+ if (!remainingDays)
+ showNotification = false;
+ }
+ }
+
+ if (showNotification) {
+ this._showSearchSuggestionsNotification();
+ } else if (this.classList.contains("showSearchSuggestionsNotification")) {
+ this._hideSearchSuggestionsNotification();
+ }
+
+ this._openAutocompletePopup(aInput, aElement);
+ ]]>
+ </body>
+ </method>
+
+ <method name="_openAutocompletePopup">
+ <parameter name="aInput"/>
+ <parameter name="aElement"/>
+ <body><![CDATA[
+ if (this.mPopupOpen) {
+ return;
+ }
+
+ this.mInput = aInput;
+ aInput.controller.setInitiallySelectedIndex(this._isFirstResultHeuristic ? 0 : -1);
+ this.view = aInput.controller.QueryInterface(Components.interfaces.nsITreeView);
+ this._invalidate();
+
+ var rect = window.document.documentElement.getBoundingClientRect();
+ var width = rect.right - rect.left;
+ this.setAttribute("width", width);
+
+ // Adjust the direction of the autocomplete popup list based on the textbox direction, bug 649840
+ var popupDirection = aElement.ownerDocument.defaultView.getComputedStyle(aElement).direction;
+ this.style.direction = popupDirection;
+
+ // Make the popup's starting margin negative so that the leading edge
+ // of the popup aligns with the window border.
+ let elementRect = aElement.getBoundingClientRect();
+ if (popupDirection == "rtl") {
+ let offset = elementRect.right - rect.right
+ this.style.marginRight = offset + "px";
+ } else {
+ let offset = rect.left - elementRect.left;
+ this.style.marginLeft = offset + "px";
+ }
+
+ // Keep the popup items' site icons aligned with the urlbar's identity
+ // icon if it's not too far from the edge of the window. If there are
+ // at most two toolbar buttons between the window edge and the urlbar,
+ // then consider that as "not too far." The forward button's
+ // visibility may have changed since the last time the popup was
+ // opened, so this needs to happen now. Do it *before* the popup
+ // opens because otherwise the items will visibly shift.
+ let nodes = [...document.getElementById("nav-bar-customization-target").childNodes];
+ let urlbarPosition = nodes.findIndex(n => n.id == "urlbar-container");
+ let alignSiteIcons = urlbarPosition <= 2 &&
+ nodes.slice(0, urlbarPosition)
+ .every(n => n.localName == "toolbarbutton");
+ if (alignSiteIcons) {
+ let identityRect =
+ document.getElementById("identity-icon").getBoundingClientRect();
+ this.siteIconStart = popupDirection == "rtl" ? identityRect.right
+ : identityRect.left;
+ } else {
+ // Reset the alignment so that the site icons are positioned
+ // according to whatever's in the CSS.
+ this.siteIconStart = undefined;
+ }
+
+ // Position the popup below the navbar. To get the y-coordinate,
+ // which is an offset from the bottom of the input, subtract the
+ // bottom of the navbar from the buttom of the input.
+ let yOffset =
+ document.getElementById("nav-bar").getBoundingClientRect().bottom -
+ aInput.getBoundingClientRect().bottom;
+ this.openPopup(aElement, "after_start", 0, yOffset, false, false);
+ ]]></body>
+ </method>
+
+ <method name="_updateFooterVisibility">
+ <body>
+ <![CDATA[
+ this.footer.collapsed = this._matchCount == 0;
+ ]]>
+ </body>
+ </method>
+
+ <method name="_showSearchSuggestionsNotification">
+ <body>
+ <![CDATA[
+ // With the notification shown, the listbox's height can sometimes be
+ // too small when it's flexed, as it normally is. Also, it can start
+ // out slightly scrolled down. Both problems appear together, most
+ // often when the popup is very narrow and the notification's text
+ // must wrap. Work around them by removing the flex.
+ //
+ // But without flexing the listbox, the listbox's height animation
+ // sometimes fails to complete, leaving the popup too tall. Work
+ // around that problem by disabling the listbox animation.
+ this.richlistbox.flex = 0;
+ this.setAttribute("dontanimate", "true");
+
+ this.classList.add("showSearchSuggestionsNotification");
+ this._updateFooterVisibility();
+
+ // This event allows accessibility APIs to see the notification.
+ if (!this.popupOpen) {
+ let event = document.createEvent("Events");
+ event.initEvent("AlertActive", true, true);
+ this.searchSuggestionsNotification.dispatchEvent(event);
+ }
+ ]]>
+ </body>
+ </method>
+
+ <method name="searchSuggestionsNotificationWasDismissed">
+ <parameter name="enableSuggestions"/>
+ <body>
+ <![CDATA[
+ if (!this.popupOpen) {
+ this._hideSearchSuggestionsNotification();
+ return;
+ }
+ this._hideSearchSuggestionsNotificationWithAnimation().then(() => {
+ if (enableSuggestions && this.input.textValue) {
+ // Start a new search so that suggestions appear immediately.
+ this.input.controller.startSearch(this.input.textValue);
+ }
+ });
+ ]]>
+ </body>
+ </method>
+
+ <method name="_hideSearchSuggestionsNotification">
+ <body>
+ <![CDATA[
+ this.classList.remove("showSearchSuggestionsNotification");
+ this.richlistbox.flex = 1;
+ this.removeAttribute("dontanimate");
+ if (this._matchCount) {
+ // Update popup height.
+ this._invalidate();
+ } else {
+ this.closePopup();
+ }
+ ]]>
+ </body>
+ </method>
+
+ <method name="_hideSearchSuggestionsNotificationWithAnimation">
+ <body>
+ <![CDATA[
+ return new Promise(resolve => {
+ let notificationHeight = this.searchSuggestionsNotification
+ .getBoundingClientRect()
+ .height;
+ this.searchSuggestionsNotification.style.marginTop =
+ "-" + notificationHeight + "px";
+
+ let popupHeightPx =
+ (this.getBoundingClientRect().height - notificationHeight) + "px";
+ this.style.height = popupHeightPx;
+
+ let onTransitionEnd = () => {
+ this.removeEventListener("transitionend", onTransitionEnd, true);
+ this.searchSuggestionsNotification.style.marginTop = "0px";
+ this.style.removeProperty("height");
+ this._hideSearchSuggestionsNotification();
+ resolve();
+ };
+ this.addEventListener("transitionend", onTransitionEnd, true);
+ });
+ ]]>
+ </body>
+ </method>
+
+ <method name="_selectedOneOffChanged">
+ <body><![CDATA[
+ // Update all searchengine result items to use the newly selected
+ // engine.
+ for (let item of this.richlistbox.childNodes) {
+ if (item.collapsed) {
+ break;
+ }
+ let url = item.getAttribute("url");
+ if (url) {
+ let action = item._parseActionUrl(url);
+ if (action && action.type == "searchengine") {
+ item._adjustAcItem();
+ }
+ }
+ }
+ ]]></body>
+ </method>
+
+ <!-- This handles keypress changes to the selection among the one-off
+ search buttons and between the one-offs and the listbox. It returns
+ true if the keypress was consumed and false if not. -->
+ <method name="handleKeyPress">
+ <parameter name="aEvent"/>
+ <body><![CDATA[
+ this.oneOffSearchButtons.handleKeyPress(aEvent, this._matchCount,
+ !this._isFirstResultHeuristic,
+ gBrowser.userTypedValue);
+ return aEvent.defaultPrevented;
+ ]]></body>
+ </method>
+
+ <!-- This is called when a one-off is clicked and when "search in new tab"
+ is selected from a one-off context menu. -->
+ <method name="handleOneOffSearch">
+ <parameter name="event"/>
+ <parameter name="engine"/>
+ <parameter name="where"/>
+ <parameter name="params"/>
+ <body><![CDATA[
+ this.input.handleCommand(event, where, params);
+ ]]></body>
+ </method>
+
+ <!-- Result listitems call this to determine which search engine they
+ should show in their labels and include in their url attributes. -->
+ <property name="overrideSearchEngineName" readonly="true">
+ <getter><![CDATA[
+ let button = this.oneOffSearchButtons.selectedButton;
+ return button && button.engine && button.engine.name;
+ ]]></getter>
+ </property>
+
+ <method name="createResultLabel">
+ <parameter name="item"/>
+ <parameter name="proposedLabel"/>
+ <body>
+ <![CDATA[
+ let parts = [proposedLabel];
+
+ let action = this.mInput._parseActionUrl(item.getAttribute("url"));
+ if (action) {
+ switch (action.type) {
+ case "searchengine":
+ parts = [
+ action.params.searchSuggestion || action.params.searchQuery,
+ action.params.engineName,
+ ];
+ break;
+ case "switchtab":
+ case "remotetab":
+ parts = [
+ item.getAttribute("title"),
+ item.getAttribute("displayurl"),
+ ];
+ break;
+ }
+ }
+
+ let types = item.getAttribute("type").split(/\s+/);
+ let type = types.find(t => t != "action" && t != "heuristic");
+ try {
+ // Some types intentionally do not map to strings, which is not
+ // an error.
+ parts.push(this._bundle.GetStringFromName(type + "ResultLabel"));
+ } catch (e) {}
+
+ return parts.filter(str => str).join(" ");
+ ]]>
+ </body>
+ </method>
+
+ <method name="onResultsAdded">
+ <body>
+ <![CDATA[
+ // If nothing is selected yet, select the first result if it is a
+ // pre-selected "heuristic" result. (See UnifiedComplete.js.)
+ if (this.selectedIndex == -1 && this._isFirstResultHeuristic) {
+ // Don't fire DOMMenuItemActive so that screen readers still see
+ // the input as being focused.
+ this.richlistbox.suppressMenuItemEvent = true;
+ this.input.controller.setInitiallySelectedIndex(0);
+ this.richlistbox.suppressMenuItemEvent = false;
+ }
+
+ this.input.gotResultForCurrentQuery = true;
+
+ // Check if we should perform a delayed handleEnter.
+ if (this.input.handleEnterInstance) {
+ let instance = this.input.handleEnterInstance;
+ this.input.handleEnterInstance = null;
+ // Don't handle this immediately or we could cause a recursive
+ // loop where the controller sets popupOpen and re-enters here.
+ setTimeout(() => {
+ // Safety check: handle only if the search string didn't change.
+ let { event, searchString } = instance;
+ if (this.input.mController.searchString == searchString) {
+ this.input.maybeCanonizeURL(event, searchString);
+ this.input.mController.handleEnter(false, event);
+ this.overrideValue = null;
+ }
+ }, 0);
+ }
+ ]]>
+ </body>
+ </method>
+
+ <method name="_onSearchBegin">
+ <body><![CDATA[
+ // Set the selected index to 0 (heuristic) until a result comes back
+ // and we can evaluate it better.
+ //
+ // This is required to properly manage delayed handleEnter:
+ // 1. if a search starts we set selectedIndex to 0 here, and it will
+ // be updated by onResultsAdded. Since selectedIndex is 0,
+ // handleEnter will delay the action if a result didn't arrive yet.
+ // 2. if a search doesn't start (for example if autocomplete is
+ // disabled), this won't be called, and the selectedIndex will be
+ // the default -1 value. Then handleEnter will know it should not
+ // delay the action, cause a result wont't ever arrive.
+ this.input.controller.setInitiallySelectedIndex(0);
+ ]]></body>
+ </method>
+
+ <field name="_addonIframe">null</field>
+ <field name="_addonIframeOwner">null</field>
+ <field name="_addonIframeOverriddenFunctionsByName">{}</field>
+
+ <!-- These methods must be overridden and properly handled by the API
+ runtime so that it doesn't break the popup. If any of these methods
+ is not overridden, then initAddonIframe should throw. -->
+ <field name="_addonIframeOverrideFunctionNames">[
+ "_invalidate",
+ ]</field>
+
+ <field name="_addonIframeHiddenAnonids">[
+ "search-suggestions-notification",
+ "richlistbox",
+ "one-off-search-buttons",
+ ]</field>
+ <field name="_addonIframeHiddenDisplaysByAnonid">{}</field>
+
+ <method name="initAddonIframe">
+ <parameter name="owner"/>
+ <parameter name="overrides"/>
+ <body><![CDATA[
+ if (this._addonIframeOwner) {
+ // Another add-on has already requested the iframe. Return null to
+ // signal to the calling add-on that it should not take over the
+ // popup. First add-on wins for now.
+ return null;
+ }
+ // Make sure all overrides are provided before doing anything.
+ for (let name of this._addonIframeOverrideFunctionNames) {
+ if (typeof(overrides[name]) != "function") {
+ throw new Error(
+ "Override for method '" + name + "' must be given"
+ );
+ }
+ }
+ // OK, insert the iframe.
+ this._addonIframeOwner = owner;
+ this._addonIframe = this._makeAddonIframe();
+ this._addonIframeOverriddenFunctionsByName = {};
+ for (let name of this._addonIframeOverrideFunctionNames) {
+ this._addonIframeOverriddenFunctionsByName[name] = this[name];
+ this[name] = overrides[name];
+ }
+ return this._addonIframe;
+ ]]></body>
+ </method>
+
+ <method name="destroyAddonIframe">
+ <parameter name="owner"/>
+ <body><![CDATA[
+ if (this._addonIframeOwner != owner) {
+ throw new Error("You're not the iframe owner");
+ }
+ this._addonIframeOwner = null;
+ this._addonIframe.remove();
+ this._addonIframe = null;
+ for (let anonid of this._addonIframeHiddenAnonids) {
+ let child = document.getAnonymousElementByAttribute(
+ this, "anonid", anonid
+ );
+ child.style.display =
+ this._addonIframeHiddenDisplaysByAnonid[anonid];
+ }
+ for (let name in this._addonIframeOverriddenFunctionsByName) {
+ this[name] = this._addonIframeOverriddenFunctionsByName[name];
+ }
+ this._addonIframeOverriddenFunctionsByName = {};
+ ]]></body>
+ </method>
+
+ <method name="_makeAddonIframe">
+ <body><![CDATA[
+ this._addonIframeHiddenDisplaysByAnonid = {};
+ for (let anonid of this._addonIframeHiddenAnonids) {
+ let child = document.getAnonymousElementByAttribute(
+ this, "anonid", anonid
+ );
+ this._addonIframeHiddenDisplaysByAnonid[anonid] =
+ child.style.display;
+ child.style.display = "none";
+ }
+ let XUL_NS =
+ "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+ let iframe = document.createElementNS(XUL_NS, "iframe");
+ iframe.setAttribute("type", "content");
+ iframe.setAttribute("flex", "1");
+ iframe.style.transition = "height 100ms";
+ this.appendChild(iframe);
+ return iframe;
+ ]]></body>
+ </method>
+
+ </implementation>
+ <handlers>
+
+ <handler event="SelectedOneOffButtonChanged"><![CDATA[
+ this._selectedOneOffChanged();
+ ]]></handler>
+
+ <handler event="mousedown"><![CDATA[
+ // Required to make the xul:label.text-link elements in the search
+ // suggestions notification work correctly when clicked on Linux.
+ // This is copied from the mousedown handler in
+ // browser-search-autocomplete-result-popup, which apparently had a
+ // similar problem.
+ event.preventDefault();
+ ]]></handler>
+
+ </handlers>
+ </binding>
+
+ <binding id="addon-progress-notification" extends="chrome://global/content/bindings/notification.xml#popup-notification">
+ <implementation>
+ <constructor><![CDATA[
+ if (!this.notification)
+ return;
+
+ this.notification.options.installs.forEach(function(aInstall) {
+ aInstall.addListener(this);
+ }, this);
+
+ // Calling updateProgress can sometimes cause this notification to be
+ // removed in the middle of refreshing the notification panel which
+ // makes the panel get refreshed again. Just initialise to the
+ // undetermined state and then schedule a proper check at the next
+ // opportunity
+ this.setProgress(0, -1);
+ this._updateProgressTimeout = setTimeout(this.updateProgress.bind(this), 0);
+ ]]></constructor>
+
+ <destructor><![CDATA[
+ this.destroy();
+ ]]></destructor>
+
+ <field name="progressmeter" readonly="true">
+ document.getElementById("addon-progress-notification-progressmeter");
+ </field>
+ <field name="progresstext" readonly="true">
+ document.getElementById("addon-progress-notification-progresstext");
+ </field>
+ <property name="DownloadUtils" readonly="true">
+ <getter><![CDATA[
+ let module = {};
+ Components.utils.import("resource://gre/modules/DownloadUtils.jsm", module);
+ Object.defineProperty(this, "DownloadUtils", {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: module.DownloadUtils
+ });
+ return module.DownloadUtils;
+ ]]></getter>
+ </property>
+
+ <method name="destroy">
+ <body><![CDATA[
+ if (!this.notification)
+ return;
+
+ this.notification.options.installs.forEach(function(aInstall) {
+ aInstall.removeListener(this);
+ }, this);
+ clearTimeout(this._updateProgressTimeout);
+ ]]></body>
+ </method>
+
+ <method name="setProgress">
+ <parameter name="aProgress"/>
+ <parameter name="aMaxProgress"/>
+ <body><![CDATA[
+ if (aMaxProgress == -1) {
+ this.progressmeter.setAttribute("mode", "undetermined");
+ } else {
+ this.progressmeter.setAttribute("mode", "determined");
+ this.progressmeter.setAttribute("value", (aProgress * 100) / aMaxProgress);
+ }
+
+ let now = Date.now();
+
+ if (!this.notification.lastUpdate) {
+ this.notification.lastUpdate = now;
+ this.notification.lastProgress = aProgress;
+ return;
+ }
+
+ let delta = now - this.notification.lastUpdate;
+ if ((delta < 400) && (aProgress < aMaxProgress))
+ return;
+
+ delta /= 1000;
+
+ // This code is taken from nsDownloadManager.cpp
+ let speed = (aProgress - this.notification.lastProgress) / delta;
+ if (this.notification.speed)
+ speed = speed * 0.9 + this.notification.speed * 0.1;
+
+ this.notification.lastUpdate = now;
+ this.notification.lastProgress = aProgress;
+ this.notification.speed = speed;
+
+ let status = null;
+ [status, this.notification.last] = this.DownloadUtils.getDownloadStatus(aProgress, aMaxProgress, speed, this.notification.last);
+ this.progresstext.setAttribute("value", status);
+ this.progresstext.setAttribute("tooltiptext", status);
+ ]]></body>
+ </method>
+
+ <method name="cancel">
+ <body><![CDATA[
+ let installs = this.notification.options.installs;
+ installs.forEach(function(aInstall) {
+ try {
+ aInstall.cancel();
+ } catch (e) {
+ // Cancel will throw if the download has already failed
+ }
+ }, this);
+
+ PopupNotifications.remove(this.notification);
+ ]]></body>
+ </method>
+
+ <method name="updateProgress">
+ <body><![CDATA[
+ if (!this.notification)
+ return;
+
+ let downloadingCount = 0;
+ let progress = 0;
+ let maxProgress = 0;
+
+ this.notification.options.installs.forEach(function(aInstall) {
+ if (aInstall.maxProgress == -1)
+ maxProgress = -1;
+ progress += aInstall.progress;
+ if (maxProgress >= 0)
+ maxProgress += aInstall.maxProgress;
+ if (aInstall.state < AddonManager.STATE_DOWNLOADED)
+ downloadingCount++;
+ });
+
+ if (downloadingCount == 0) {
+ this.destroy();
+ if (Preferences.get("xpinstall.customConfirmationUI", false)) {
+ this.progressmeter.setAttribute("mode", "undetermined");
+ let status = gNavigatorBundle.getString("addonDownloadVerifying");
+ this.progresstext.setAttribute("value", status);
+ this.progresstext.setAttribute("tooltiptext", status);
+ } else {
+ PopupNotifications.remove(this.notification);
+ }
+ } else {
+ this.setProgress(progress, maxProgress);
+ }
+ ]]></body>
+ </method>
+
+ <method name="onDownloadProgress">
+ <body><![CDATA[
+ this.updateProgress();
+ ]]></body>
+ </method>
+
+ <method name="onDownloadFailed">
+ <body><![CDATA[
+ this.updateProgress();
+ ]]></body>
+ </method>
+
+ <method name="onDownloadCancelled">
+ <body><![CDATA[
+ this.updateProgress();
+ ]]></body>
+ </method>
+
+ <method name="onDownloadEnded">
+ <body><![CDATA[
+ this.updateProgress();
+ ]]></body>
+ </method>
+ </implementation>
+ </binding>
+
+ <binding id="plugin-popupnotification-center-item">
+ <content align="center">
+ <xul:vbox pack="center" anonid="itemBox" class="itemBox">
+ <xul:description anonid="center-item-label" class="center-item-label" />
+ <xul:hbox flex="1" pack="start" align="center" anonid="center-item-warning">
+ <xul:image anonid="center-item-warning-icon" class="center-item-warning-icon"/>
+ <xul:label anonid="center-item-warning-label"/>
+ <xul:label anonid="center-item-link" value="&checkForUpdates;" class="text-link"/>
+ </xul:hbox>
+ </xul:vbox>
+ <xul:vbox pack="center">
+ <xul:menulist class="center-item-menulist"
+ anonid="center-item-menulist">
+ <xul:menupopup>
+ <xul:menuitem anonid="allownow" value="allownow"
+ label="&pluginActivateNow.label;" />
+ <xul:menuitem anonid="allowalways" value="allowalways"
+ label="&pluginActivateAlways.label;" />
+ <xul:menuitem anonid="block" value="block"
+ label="&pluginBlockNow.label;" />
+ </xul:menupopup>
+ </xul:menulist>
+ </xul:vbox>
+ </content>
+ <resources>
+ <stylesheet src="chrome://global/skin/notification.css"/>
+ </resources>
+ <implementation>
+ <constructor><![CDATA[
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-label").value = this.action.pluginName;
+
+ let curState = "block";
+ if (this.action.fallbackType == Ci.nsIObjectLoadingContent.PLUGIN_ACTIVE) {
+ if (this.action.pluginPermissionType == Ci.nsIPermissionManager.EXPIRE_SESSION) {
+ curState = "allownow";
+ } else {
+ curState = "allowalways";
+ }
+ }
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-menulist").value = curState;
+
+ let warningString = "";
+ let linkString = "";
+
+ let link = document.getAnonymousElementByAttribute(this, "anonid", "center-item-link");
+
+ let url;
+ let linkHandler;
+
+ if (this.action.pluginTag.enabledState == Ci.nsIPluginTag.STATE_DISABLED) {
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-menulist").hidden = true;
+ warningString = gNavigatorBundle.getString("pluginActivateDisabled.label");
+ linkString = gNavigatorBundle.getString("pluginActivateDisabled.manage");
+ linkHandler = function(event) {
+ event.preventDefault();
+ gPluginHandler.managePlugins();
+ };
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-warning-icon").hidden = true;
+ } else {
+ url = this.action.detailsLink;
+
+ switch (this.action.blocklistState) {
+ case Ci.nsIBlocklistService.STATE_NOT_BLOCKED:
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-warning").hidden = true;
+ break;
+ case Ci.nsIBlocklistService.STATE_BLOCKED:
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-menulist").hidden = true;
+ warningString = gNavigatorBundle.getString("pluginActivateBlocked.label");
+ linkString = gNavigatorBundle.getString("pluginActivate.learnMore");
+ break;
+ case Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE:
+ warningString = gNavigatorBundle.getString("pluginActivateOutdated.label");
+ linkString = gNavigatorBundle.getString("pluginActivate.updateLabel");
+ break;
+ case Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE:
+ warningString = gNavigatorBundle.getString("pluginActivateVulnerable.label");
+ linkString = gNavigatorBundle.getString("pluginActivate.riskLabel");
+ break;
+ }
+ }
+ document.getAnonymousElementByAttribute(this, "anonid", "center-item-warning-label").value = warningString;
+
+ let chromeWin = window.QueryInterface(Ci.nsIDOMChromeWindow);
+ let isWindowPrivate = PrivateBrowsingUtils.isWindowPrivate(chromeWin);
+
+ if (isWindowPrivate) {
+ // TODO: temporary compromise of hiding some privacy leaks, remove once bug 892487 is fixed
+ let allowalways = document.getAnonymousElementByAttribute(this, "anonid", "allowalways");
+ let block = document.getAnonymousElementByAttribute(this, "anonid", "block");
+ let allownow = document.getAnonymousElementByAttribute(this, "anonid", "allownow");
+
+ allowalways.hidden = curState !== "allowalways";
+ block.hidden = curState !== "block";
+ allownow.hidden = curState === "allowalways";
+ }
+
+ if (url || linkHandler) {
+ link.value = linkString;
+ if (url) {
+ link.href = url;
+ }
+ if (linkHandler) {
+ link.addEventListener("click", linkHandler);
+ }
+ } else {
+ link.hidden = true;
+ }
+ ]]></constructor>
+ <property name="value">
+ <getter>
+ return document.getAnonymousElementByAttribute(this, "anonid",
+ "center-item-menulist").value;
+ </getter>
+ <setter><!-- This should be used only in automated tests -->
+ document.getAnonymousElementByAttribute(this, "anonid",
+ "center-item-menulist").value = val;
+ </setter>
+ </property>
+ </implementation>
+ </binding>
+
+ <binding id="click-to-play-plugins-notification" extends="chrome://global/content/bindings/notification.xml#popup-notification">
+ <content align="start" style="width: &pluginNotification.width;;">
+ <xul:vbox flex="1" align="stretch" class="popup-notification-main-box"
+ xbl:inherits="popupid">
+ <xul:hbox class="click-to-play-plugins-notification-description-box" flex="1" align="start">
+ <xul:description class="click-to-play-plugins-outer-description" flex="1">
+ <html:span anonid="click-to-play-plugins-notification-description" />
+ <xul:label class="text-link click-to-play-plugins-notification-link" anonid="click-to-play-plugins-notification-link" />
+ </xul:description>
+ <xul:toolbarbutton anonid="closebutton"
+ class="messageCloseButton popup-notification-closebutton tabbable close-icon"
+ xbl:inherits="oncommand=closebuttoncommand"
+ tooltiptext="&closeNotification.tooltip;"/>
+ </xul:hbox>
+ <xul:grid anonid="click-to-play-plugins-notification-center-box"
+ class="click-to-play-plugins-notification-center-box">
+ <xul:columns>
+ <xul:column flex="1"/>
+ <xul:column/>
+ </xul:columns>
+ <xul:rows>
+ <children includes="row"/>
+ <xul:hbox pack="start" anonid="plugin-notification-showbox">
+ <xul:button label="&pluginNotification.showAll.label;"
+ accesskey="&pluginNotification.showAll.accesskey;"
+ class="plugin-notification-showbutton"
+ oncommand="document.getBindingParent(this)._setState(2)"/>
+ </xul:hbox>
+ </xul:rows>
+ </xul:grid>
+ <xul:hbox anonid="button-container"
+ class="click-to-play-plugins-notification-button-container"
+ pack="center" align="center">
+ <xul:button anonid="primarybutton"
+ class="click-to-play-popup-button"
+ oncommand="document.getBindingParent(this)._onButton(this)"
+ flex="1"/>
+ <xul:button anonid="secondarybutton"
+ class="click-to-play-popup-button"
+ oncommand="document.getBindingParent(this)._onButton(this);"
+ flex="1"/>
+ </xul:hbox>
+ <xul:box hidden="true">
+ <children/>
+ </xul:box>
+ </xul:vbox>
+ </content>
+ <resources>
+ <stylesheet src="chrome://global/skin/notification.css"/>
+ </resources>
+ <implementation>
+ <field name="_states">
+ ({SINGLE: 0, MULTI_COLLAPSED: 1, MULTI_EXPANDED: 2})
+ </field>
+ <field name="_primaryButton">
+ document.getAnonymousElementByAttribute(this, "anonid", "primarybutton");
+ </field>
+ <field name="_secondaryButton">
+ document.getAnonymousElementByAttribute(this, "anonid", "secondarybutton")
+ </field>
+ <field name="_buttonContainer">
+ document.getAnonymousElementByAttribute(this, "anonid", "button-container")
+ </field>
+ <field name="_brandShortName">
+ document.getElementById("bundle_brand").getString("brandShortName")
+ </field>
+ <field name="_items">[]</field>
+ <constructor><![CDATA[
+ const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+ let sortedActions = [];
+ for (let action of this.notification.options.pluginData.values()) {
+ sortedActions.push(action);
+ }
+ sortedActions.sort((a, b) => a.pluginName.localeCompare(b.pluginName));
+
+ for (let action of sortedActions) {
+ let item = document.createElementNS(XUL_NS, "row");
+ item.setAttribute("class", "plugin-popupnotification-centeritem");
+ item.action = action;
+ this.appendChild(item);
+ this._items.push(item);
+ }
+ switch (this._items.length) {
+ case 0:
+ PopupNotifications._dismiss();
+ break;
+ case 1:
+ this._setState(this._states.SINGLE);
+ break;
+ default:
+ if (this.notification.options.primaryPlugin) {
+ this._setState(this._states.MULTI_COLLAPSED);
+ } else {
+ this._setState(this._states.MULTI_EXPANDED);
+ }
+ }
+ ]]></constructor>
+ <method name="_setState">
+ <parameter name="state" />
+ <body><![CDATA[
+ var grid = document.getAnonymousElementByAttribute(this, "anonid", "click-to-play-plugins-notification-center-box");
+
+ if (this._states.SINGLE == state) {
+ grid.hidden = true;
+ this._setupSingleState();
+ return;
+ }
+
+ let prePath = this.notification.options.principal.URI.prePath;
+ this._setupDescription("pluginActivateMultiple.message", null, prePath);
+
+ var showBox = document.getAnonymousElementByAttribute(this, "anonid", "plugin-notification-showbox");
+
+ var dialogStrings = Services.strings.createBundle("chrome://global/locale/dialog.properties");
+ this._primaryButton.label = dialogStrings.GetStringFromName("button-accept");
+ this._primaryButton.setAttribute("default", "true");
+
+ this._secondaryButton.label = dialogStrings.GetStringFromName("button-cancel");
+ this._primaryButton.setAttribute("action", "_multiAccept");
+ this._secondaryButton.setAttribute("action", "_cancel");
+
+ grid.hidden = false;
+
+ if (this._states.MULTI_COLLAPSED == state) {
+ for (let child of this.childNodes) {
+ if (child.tagName != "row") {
+ continue;
+ }
+ child.hidden = this.notification.options.primaryPlugin !=
+ child.action.permissionString;
+ }
+ showBox.hidden = false;
+ } else {
+ for (let child of this.childNodes) {
+ if (child.tagName != "row") {
+ continue;
+ }
+ child.hidden = false;
+ }
+ showBox.hidden = true;
+ }
+ this._setupLink(null);
+ ]]></body>
+ </method>
+ <method name="_setupSingleState">
+ <body><![CDATA[
+ var action = this._items[0].action;
+ var prePath = action.pluginPermissionPrePath;
+ let chromeWin = window.QueryInterface(Ci.nsIDOMChromeWindow);
+ let isWindowPrivate = PrivateBrowsingUtils.isWindowPrivate(chromeWin);
+
+ let label, linkLabel, button1, button2;
+
+ if (action.fallbackType == Ci.nsIObjectLoadingContent.PLUGIN_ACTIVE) {
+ button1 = {
+ label: "pluginBlockNow.label",
+ accesskey: "pluginBlockNow.accesskey",
+ action: "_singleBlock"
+ };
+ button2 = {
+ label: "pluginContinue.label",
+ accesskey: "pluginContinue.accesskey",
+ action: "_singleContinue",
+ default: true
+ };
+ switch (action.blocklistState) {
+ case Ci.nsIBlocklistService.STATE_NOT_BLOCKED:
+ label = "pluginEnabled.message";
+ linkLabel = "pluginActivate.learnMore";
+ break;
+
+ case Ci.nsIBlocklistService.STATE_BLOCKED:
+ Cu.reportError(Error("Cannot happen!"));
+ break;
+
+ case Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE:
+ label = "pluginEnabledOutdated.message";
+ linkLabel = "pluginActivate.updateLabel";
+ break;
+
+ case Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE:
+ label = "pluginEnabledVulnerable.message";
+ linkLabel = "pluginActivate.riskLabel"
+ break;
+
+ default:
+ Cu.reportError(Error("Unexpected blocklist state"));
+ }
+
+ // TODO: temporary compromise, remove this once bug 892487 is fixed
+ if (isWindowPrivate) {
+ this._buttonContainer.hidden = true;
+ }
+ } else if (action.pluginTag.enabledState == Ci.nsIPluginTag.STATE_DISABLED) {
+ let linkElement =
+ document.getAnonymousElementByAttribute(
+ this, "anonid", "click-to-play-plugins-notification-link");
+ linkElement.textContent = gNavigatorBundle.getString("pluginActivateDisabled.manage");
+ linkElement.setAttribute("onclick", "gPluginHandler.managePlugins()");
+
+ let descElement = document.getAnonymousElementByAttribute(this, "anonid", "click-to-play-plugins-notification-description");
+ descElement.textContent = gNavigatorBundle.getFormattedString(
+ "pluginActivateDisabled.message", [action.pluginName, this._brandShortName]) + " ";
+ this._buttonContainer.hidden = true;
+ return;
+ } else if (action.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED) {
+ let descElement = document.getAnonymousElementByAttribute(this, "anonid", "click-to-play-plugins-notification-description");
+ descElement.textContent = gNavigatorBundle.getFormattedString(
+ "pluginActivateBlocked.message", [action.pluginName, this._brandShortName]) + " ";
+ this._setupLink("pluginActivate.learnMore", action.detailsLink);
+ this._buttonContainer.hidden = true;
+ return;
+ } else {
+ button1 = {
+ label: "pluginActivateNow.label",
+ accesskey: "pluginActivateNow.accesskey",
+ action: "_singleActivateNow"
+ };
+ button2 = {
+ label: "pluginActivateAlways.label",
+ accesskey: "pluginActivateAlways.accesskey",
+ action: "_singleActivateAlways"
+ };
+ switch (action.blocklistState) {
+ case Ci.nsIBlocklistService.STATE_NOT_BLOCKED:
+ label = "pluginActivateNew.message";
+ linkLabel = "pluginActivate.learnMore";
+ button2.default = true;
+ break;
+
+ case Ci.nsIBlocklistService.STATE_VULNERABLE_UPDATE_AVAILABLE:
+ label = "pluginActivateOutdated.message";
+ linkLabel = "pluginActivate.updateLabel";
+ button1.default = true;
+ break;
+
+ case Ci.nsIBlocklistService.STATE_VULNERABLE_NO_UPDATE:
+ label = "pluginActivateVulnerable.message";
+ linkLabel = "pluginActivate.riskLabel"
+ button1.default = true;
+ break;
+
+ default:
+ Cu.reportError(Error("Unexpected blocklist state"));
+ }
+
+ // TODO: temporary compromise, remove this once bug 892487 is fixed
+ if (isWindowPrivate) {
+ button1.default = true;
+ this._secondaryButton.hidden = true;
+ }
+ }
+ this._setupDescription(label, action.pluginName, prePath);
+ this._setupLink(linkLabel, action.detailsLink);
+
+ this._primaryButton.label = gNavigatorBundle.getString(button1.label);
+ this._primaryButton.accessKey = gNavigatorBundle.getString(button1.accesskey);
+ this._primaryButton.setAttribute("action", button1.action);
+
+ this._secondaryButton.label = gNavigatorBundle.getString(button2.label);
+ this._secondaryButton.accessKey = gNavigatorBundle.getString(button2.accesskey);
+ this._secondaryButton.setAttribute("action", button2.action);
+ if (button1.default) {
+ this._primaryButton.setAttribute("default", "true");
+ } else if (button2.default) {
+ this._secondaryButton.setAttribute("default", "true");
+ }
+ ]]></body>
+ </method>
+ <method name="_setupDescription">
+ <parameter name="baseString" />
+ <parameter name="pluginName" /> <!-- null for the multiple-plugin case -->
+ <parameter name="prePath" />
+ <body><![CDATA[
+ var span = document.getAnonymousElementByAttribute(this, "anonid", "click-to-play-plugins-notification-description");
+ while (span.lastChild) {
+ span.removeChild(span.lastChild);
+ }
+
+ var args = ["__prepath__", this._brandShortName];
+ if (pluginName) {
+ args.unshift(pluginName);
+ }
+ var bases = gNavigatorBundle.getFormattedString(baseString, args).
+ split("__prepath__", 2);
+
+ span.appendChild(document.createTextNode(bases[0]));
+ var prePathSpan = document.createElementNS("http://www.w3.org/1999/xhtml", "em");
+ prePathSpan.appendChild(document.createTextNode(prePath));
+ span.appendChild(prePathSpan);
+ span.appendChild(document.createTextNode(bases[1] + " "));
+ ]]></body>
+ </method>
+ <method name="_setupLink">
+ <parameter name="linkString"/>
+ <parameter name="linkUrl" />
+ <body><![CDATA[
+ var link = document.getAnonymousElementByAttribute(this, "anonid", "click-to-play-plugins-notification-link");
+ if (!linkString || !linkUrl) {
+ link.hidden = true;
+ return;
+ }
+
+ link.hidden = false;
+ link.textContent = gNavigatorBundle.getString(linkString);
+ link.href = linkUrl;
+ ]]></body>
+ </method>
+ <method name="_onButton">
+ <parameter name="aButton" />
+ <body><![CDATA[
+ let methodName = aButton.getAttribute("action");
+ this[methodName]();
+ ]]></body>
+ </method>
+ <method name="_singleActivateNow">
+ <body><![CDATA[
+ gPluginHandler._updatePluginPermission(this.notification,
+ this._items[0].action,
+ "allownow");
+ this._cancel();
+ ]]></body>
+ </method>
+ <method name="_singleBlock">
+ <body><![CDATA[
+ gPluginHandler._updatePluginPermission(this.notification,
+ this._items[0].action,
+ "block");
+ this._cancel();
+ ]]></body>
+ </method>
+ <method name="_singleActivateAlways">
+ <body><![CDATA[
+ gPluginHandler._updatePluginPermission(this.notification,
+ this._items[0].action,
+ "allowalways");
+ this._cancel();
+ ]]></body>
+ </method>
+ <method name="_singleContinue">
+ <body><![CDATA[
+ gPluginHandler._updatePluginPermission(this.notification,
+ this._items[0].action,
+ "continue");
+ this._cancel();
+ ]]></body>
+ </method>
+ <method name="_multiAccept">
+ <body><![CDATA[
+ for (let item of this._items) {
+ let action = item.action;
+ if (action.pluginTag.enabledState == Ci.nsIPluginTag.STATE_DISABLED ||
+ action.blocklistState == Ci.nsIBlocklistService.STATE_BLOCKED) {
+ continue;
+ }
+ gPluginHandler._updatePluginPermission(this.notification,
+ item.action, item.value);
+ }
+ this._cancel();
+ ]]></body>
+ </method>
+ <method name="_cancel">
+ <body><![CDATA[
+ PopupNotifications._dismiss();
+ ]]></body>
+ </method>
+ <method name="_accept">
+ <parameter name="aEvent" />
+ <body><![CDATA[
+ if (aEvent.defaultPrevented)
+ return;
+ aEvent.preventDefault();
+ if (this._primaryButton.getAttribute("default") == "true") {
+ this._primaryButton.click();
+ } else if (this._secondaryButton.getAttribute("default") == "true") {
+ this._secondaryButton.click();
+ }
+ ]]></body>
+ </method>
+ </implementation>
+ <handlers>
+ <!-- The _accept method checks for .defaultPrevented so that if focus is in a button,
+ enter activates the button and not this default action -->
+ <handler event="keypress" keycode="VK_RETURN" group="system" action="this._accept(event);"/>
+ </handlers>
+ </binding>
+
+ <!-- This binding is only retained for add-ons compatibility -->
+ <binding id="menuitem-iconic-tooltip" extends="chrome://global/content/bindings/menu.xml#menuitem-iconic">
+ <implementation>
+ <constructor><![CDATA[
+ this.setAttribute("tooltiptext", this.getAttribute("acceltext"));
+ // TODO: Simplify this to this.setAttribute("acceltext", "") once bug
+ // 592424 is fixed
+ document.getAnonymousElementByAttribute(this, "anonid", "accel").firstChild.setAttribute("value", "");
+ ]]></constructor>
+ </implementation>
+ </binding>
+</bindings>